# Photo Wall (C)

Un visionneur d'images avec Clutter
Chris Kühl
chrisk@openismus.com
Johannes Schmid
jhs@gnome.org

# Mur de photos

      Dans cet exemple, nous allons fabriquer un visionneur d'images simple avec Clutter. Vous apprendrez :

        comment dimensionner et positionner les ClutterActor,
        comment placer une image dans un ClutterActor,
        comment faire des transitions simples avec la structure d'animation de Clutter,
        comment faire réagir les ClutterActor aux événements de la souris,
        et comment récupérer des noms de fichier depuis un répertoire.

# Introduction

Clutter est une bibliothèque pour créer des interfaces utilisateur dynamiques utilisant OpenGL pour l'accélération matérielle. Cet exemple montre une petite partie, mais néanmoins centrale, de la bibliothèque Clutter pour écrire un programme simple, mais sympathique, de visionneur d'images.

Pour nous aider dans cette tâche, nous utilisons également quelques autres éléments classiques de GLib. Parmi les plus importants, nous utiliserons `GSList`, une liste simplement chaînée, pour contenir nos `ClutterActor` et une autre pour les noms de chemin des fichiers. Nous utiliserons également `GDir`, un utilitaire pour travailler avec des répertoires, afin d'accéder au répertoire de nos images et de récupérer les chemins de fichier.

# Création d'un projet dans Anjuta

Avant de commencer à programmer, vous devez ouvrir un nouveau projet dans Anjuta. Ceci crée tous les fichiers qui vous sont nécessaires pour construire et exécuter votre programme plus tard. C'est aussi utile pour tout regrouper en un seul endroit.

Lancez Anjuta et cliquez sur Fichier Nouveau Projet pour ouvrir l'assistant de création de projet.

Cliquez sur l'onglet C, choisissez Gtk+ (simple), cliquez sur Continuer et renseignez les champs requis des pages suivantes avec vos informations. Saisissez murdephotos (sans accent) comme nom de projet et de répertoire.

Assurez-vous d'avoir désactivé Utiliser GtkBuilder pour l'interface utilisateur car nous allons créer l'interface utilisateur manuellement dans cet exemple. Consultez le tutoriel Accordeur de guitare si vous souhaitez savoir comment utiliser le constructeur d'interface GtkBuilder.

Activez Configuration des paquets externes. Sur la page suivante, sélectionnez clutter-1.0 dans la liste pour inclure la bibliothèque Clutter à votre projet.

Cliquez sur Appliquer et votre projet est créé. Ouvrez src/main.c depuis l'onglet Projet ou l'onglet Fichiers. Vous devez voir apparaître du code commençant par les lignes :

#include <config.h> #include <gtk/gtk.h>

# Un aperçu du mur de photos

Notre visionneur d'images vous montre un mur de photos.

Quand une image est cliquée, elle est animée pour remplir la zone d'affichage. Lorsque la photo qui possède le focus est cliquée, elle retourne à sa position d'origine en utilisant une animation qui dure également 500 millisecondes.

# Configuration initiale

La partie de code suivante contient beaucoup de définitions et de variables qui sont utilisées dans les sections suivantes. Servez-vous en comme référence. Copiez ce code au début du fichier src/main.c :

#include <clutter/clutter.h>

#define STAGE_WIDTH 800 #define STAGE_HEIGHT 600

#define THUMBNAIL_SIZE 200 #define ROW_COUNT (STAGE_HEIGHT / THUMBNAIL_SIZE) #define COL_COUNT (STAGE_WIDTH / THUMBNAIL_SIZE) #define THUMBNAIL_COUNT (ROW_COUNT * COL_COUNT)

#define ANIMATION_DURATION_MS 500

#define FOCUS_DEPTH 100.0 #define UNFOCUS_DEPTH 0.0

#define IMAGE_DIR_PATH "./berlin_images/"

static GSList *actor_list = NULL; static GSList *img_path_list = NULL;

typedef struct Position { float x; float y; } Position;

static Position origin = {0, 0};

# Immersion dans le code

Nous commencerons par analyser la fonction `main()` dans son ensemble. Ensuite nous discuterons des autres parties du programme en détail. Modifiez le fichier src/main.c pour qu'il contienne la fonction `main()`. Vous pouvez aussi supprimer la fonction `create_window()` car on n'en a plus besoin dans cet exemple.

int main(int argc, char *argv[]) { ClutterColor stage_color = { 16, 16, 16, 255 }; ClutterActor *stage = NULL;

clutter_init(&argc, &argv);

stage = clutter_stage_get_default(); clutter_actor_set_size(stage, STAGE_WIDTH, STAGE_HEIGHT); clutter_stage_set_color(CLUTTER_STAGE (stage), &stage_color);

load_image_path_names();

guint row = 0; guint col = 0; for(row=0; row < ROW_COUNT; ++row) { for(col=0; col < COL_COUNT; ++col) { GSList *img_path_node = g_slist_nth(img_path_list, (row * COL_COUNT) + col); ClutterActor *actor = clutter_texture_new_from_file((gchar *)(img_path_node->data), NULL); initialize_actor(actor, row, col); clutter_container_add_actor(CLUTTER_CONTAINER(stage), actor); actor_list = g_slist_prepend(actor_list, actor); } }

/* Show the stage. */ clutter_actor_show(stage);

/* Start the clutter main loop. */ clutter_main();

return 0; }

Ligne 4 : configuration de `ClutterColor` en paramétrant les valeurs rouge, vert, bleu et celle de transparence (alpha). Les valeurs sont comprises entre 0 et 255. Pour la transparence, une valeur de 255 représente l'opacité.

Ligne 7 : vous devez initialiser Clutter. Attention, si vous oubliez de le faire, vous aurez de très étranges messages d'erreur. Vous êtes prévenu.

Lignes 9‒11 : ici nous obtenons le `ClutterStage` par défaut qui a été fourni par `clutter_init` puis nous définissons sa taille en utilisant les variables définies à la section précédente et l'adresse du `ClutterColor` que nous venons de définir.

Un `ClutterStage` est le `ClutterActor` de premier niveau sur lequel les autres `ClutterActor` sont disposés.

Ligne 13 : ici nous appelons notre fonction pour obtenir les chemins des fichiers image. Nous l'examinerons dans un instant.

Ligne 15-27 : c'est l'endroit où nous paramétrons les `ClutterActor`, chargeons les images et les disposons au bon endroit dans le mur d'images. Nous regarderons cela en détail dans la section suivante.

Ligne 29 : affichage de « stage » et de tous ses enfants, c'est-à-dire nos images.

Ligne 32 : démarrage de la boucle principale de Clutter.

# Mise en place de nos acteurs image

Dans Clutter, un acteur est l'élément visuel le plus élémentaire. En gros, tout ce que vous voyez est un acteur.

Dans cette section, nous allons regarder plus en détail la boucle utilisée pour paramétrer les `ClutterActor` qui affichent nos images.

for(row=0; row < ROW_COUNT; ++row) { for(col=0; col < COL_COUNT; ++col) { GSList *img_path_node = g_slist_nth(img_path_list, (row * COL_COUNT) + col); ClutterActor *actor = clutter_texture_new_from_file((gchar *)(img_path_node->data), NULL); initialize_actor(actor, row, col); clutter_container_add_actor(CLUTTER_CONTAINER(stage), actor); actor_list = g_slist_prepend(actor_list, actor); } }

Ligne 5 : ici nous voulons obtenir le chemin à la nième position de la `GSList` qui contient les noms de chemin de nos images. La nième position est calculée à partir de `row` et `col`. La valeur retournée est un pointeur vers une `GSList` qui est juste un nœud dans la liste. Nous l'utiliserons dans la ligne suivante pour obtenir le chemin réel. Le premier argument est un pointeur vers le début de la liste.

Ligne 6 : c'est ici que nous créons réellement le `ClutterActor` et disposons l'image dans l'acteur. Le premier argument est le chemin qui permet d'accéder au nœud de notre `GSList`. Le deuxième sert à rapporter une erreur mais nous allons ignorer cela pour faire court.

Ligne 7 : nous regarderons cette fonction dans une section ultérieure.

Ligne 8 : cela ajoute le `ClutterActor` au « stage », qui est un conteneur. Cela suppose une notion d'appartenance du `ClutterActor` qui est quelque chose que vous devrez comprendre lorsque vous irez un peu plus loin dans le développement de GNOME. Consultez la documentation de `GObject` pour des détails pointus.

Ligne 9 : cela ajoute notre `ClutterActor` à une `GSList` afin que nous puissions plus tard itérer sur les `ClutterActor`.

Il est intéressant de noter que nous ajoutons les `ClutterActor` en tête de liste plutôt qu'en fin de liste afin d'éviter d'avoir à parcourir la liste à chaque insertion. Vous verrez souvent `g_slist_prepend` suivi de `g_slist_reverse` car c'est plus rapide que d'insérer beaucoup d'objets à la fin de la liste.

# Chargement des images

Oublions un court instant Clutter pour regarder comment nous pouvons obtenir les noms des fichiers contenus dans notre répertoire d'images.

static void load_image_path_names() { /* Ensure we can access the directory. */ GError *error = NULL; GDir *dir = g_dir_open(IMAGE_DIR_PATH, 0, &error); if(error) { g_warning("g_dir_open() failed with error: %s\n", error->message); g_clear_error(&error); return; }

const gchar *filename = g_dir_read_name(dir); while(filename) { if(g_str_has_suffix(filename, ".jpg") || g_str_has_suffix(filename, ".png")) { gchar *path = g_build_filename(IMAGE_DIR_PATH, filename, NULL); img_path_list = g_slist_prepend(img_path_list, path); } filename = g_dir_read_name(dir); } }

Lignes 5 et 12 : cela ouvre notre répertoire ou, en cas d'erreur, quitte la fonction après affichage d'un message d'erreur.

Ligne 14-23 : la première ligne récupère un nouveau nom de fichier à partir du `GDir` que nous avons ouvert précédemment. S'il existe des fichiers images (ce que nous vérifions en examinant son extension, « .png » ou « .jpg ») dans le répertoire, nous continuons en ajoutant le chemin du répertoire de l'image devant le nom de fichier puis en l'ajoutant en tête de la liste définie auparavant. Enfin, nous essayons d'obtenir le prochain nom de fichier et nous recommençons la boucle si un autre fichier a été trouvé.

# Mise en place des acteurs

Examinons maintenant le choix de la taille et du positionnement des `ClutterActor` et également la préparation du `ClutterActor` pour une interaction de l'utilisateur.

/* This function handles setting up and placing the rectangles. */ static void initialize_actor(ClutterActor *actor, guint row, guint col) { clutter_actor_set_size(actor, THUMBNAIL_SIZE, THUMBNAIL_SIZE); clutter_actor_set_position(actor, col * THUMBNAIL_SIZE, row * THUMBNAIL_SIZE); clutter_actor_set_reactive(actor, TRUE);

g_signal_connect(actor, "button-press-event", G_CALLBACK(actor_clicked_cb), NULL); }

Ligne 7 : le fait de définir un acteur comme « reactive » signifie qu'il réagit aux événements, au `button-press-event` dans notre cas. Pour le mur de photos, tous les `ClutterActor` du mur doivent être initialisés comme « reactive ».

Ligne 9-12 : nous connectons maintenant l'événement `button-press-event` à la fonction de rappel `actor_clicked_cb` que nous examinons ci-dessous.

À cet instant, nous obtenons un mur d'images qui sont prêtes à être regardées.

# Réaction aux clics

static gboolean actor_clicked_cb(ClutterActor *actor, ClutterEvent *event, gpointer user_data) { /* Flag to keep track of our state. */ static gboolean is_focused = FALSE;

g_slist_foreach(actor_list, foreach_set_focus_state, &is_focused);

if(is_focused) { clutter_actor_animate(actor, CLUTTER_LINEAR, ANIMATION_DURATION_MS, "x", origin.x, "y", origin.y, "depth", UNFOCUS_DEPTH, "width", (float) THUMBNAIL_SIZE, "height", (float) THUMBNAIL_SIZE, NULL); } else { /*Save the current location before animating. */ clutter_actor_get_position(actor, &origin.x, &origin.y); clutter_actor_set_reactive(actor, TRUE); clutter_actor_animate(actor, CLUTTER_LINEAR, ANIMATION_DURATION_MS, "x", (STAGE_WIDTH - STAGE_HEIGHT) / 2.0, "y", 0.0, "depth", FOCUS_DEPTH, "width", (float) STAGE_HEIGHT, "height", (float) STAGE_HEIGHT, NULL); }

/* Toggle our flag. */ is_focused = !is_focused;

return TRUE; }

Ligne 1-4 : nous devons être sûr que notre fonction de rappel correspond à la signature requise par notre signal `button_clicked_event`. Dans notre exemple, nous n'utilisons que le premier argument, le `ClutterActor` qui est réellement cliqué.

Quelques mots sur les arguments que nous n'utilisons pas dans cet exemple. L'événement `ClutterEvent` est différent en fonction de l'événement géré. Par exemple, un événement appui sur une touche du clavier produit un `ClutterKeyEvent` à partir duquel vous pouvez obtenir comme information, entre autres, la touche qui a été enfoncée. Pour un événement clic de souris, vous obtenez un `ClutterButtonEvent` à partir duquel vous pouvez connaître les valeurs `x` et `y`. Consultez la documentation de Clutter pour les autres types d'événement `ClutterEvent`.

`user_data` est ce qui sert à transmettre des données dans la fonction. Un pointeur vers n'importe quel type de données peut être transmis. Si vous avez besoin de transmettre plusieurs données à la fonction de rappel, vous pouvez mettre les données dans une structure et transmettre son adresse.

Ligne 7 : nous définissons un drapeau de type « static » pour enregistrer l'état dans lequel nous sommes : en mode mur ou en mode focus. Nous commençons en mode mur donc aucune image ne possède le focus, par conséquent, nous paramétrons le drapeau à `FALSE` (FAUX) au départ.

Ligne 9 : cette ligne de code exécute une fonction personnalisée `foreach_set_focus_state`, pour chaque élément de notre `actor_list`, en lui transmettant l'adresse du drapeau `is_focused`. Nous verrons la définition de la fonction `foreach_set_focus_state` dans la prochaine section.

Ligne 13-19 : ces lignes sont atteintes lorsqu'une image possède actuellement le focus et que nous voulons retourner en mode mur. La fonction `clutter_actor_animate` est utilisée pour animer une ou des propriétés d'un `ClutterActor` à partir du ou des états actuels vers les états spécifiés. Les arguments sont les suivants :

L'adresse du `ClutterActor` à animer

Le mode d'animation à utiliser. Ici nous utilisons `CLUTTER_LINEAR` pour avoir une vitesse d'animation constante.

La durée de l'animation en millisecondes. J'ai choisi 500 ms pour cet exemple.

Les arguments restants sont des paires propriété/valeur. Ici nous voulons définir la valeur `x` à la valeur `x` initiale, où ce `ClutterActor` était avant de posséder le focus.

Le dernier argument doit toujours être `NULL` pour indiquer qu'il n'y a plus de propriétés à définir.

La propriété `depth` nécessite un peu plus d'explications. Nous avons besoin de mettre au premier plan l'image qui possède le focus afin qu'elle ne glisse pas derrière d'autres `ClutterActor`. Dans cette section, nous réajustons sa propriété à la même altitude que les autres images sur le mur.

« Depth » détermine aussi quels `ClutterActor` reçoivent les événements. Un `ClutterActor` avec une altitude plus grande reçoit les événements de clic et peut choisir si l'événement est transmis au `ClutterActor` en dessous de lui. Nous verrons comment cela fonctionne un peu plus loin.

Ligne 24 : ces lignes sont atteintes lorsque nous sommes actuellement dans l'état mur et que nous allons donner le focus à un `ClutterActor`. Ici nous enregistrons la position de départ afin de pouvoir le repositionner plus tard.

Ligne 25 : le fait de paramétrer la propriété `reactive` du `ClutterActor` à `TRUE` rend ce `ClutterActor` réactif aux événements. Dans cet état de focus, le seul `ClutterActor` qui doit recevoir des événements est le `ClutterActor` qui est actuellement affiché. Un clic sur ce `ClutterActor` le repositionne à sa position de départ.

Ligne 27-33 : similaire au bloc de code ci-dessus. Notez que nous paramétrons l'altitude afin de placer l'acteur devant les autres images.

Ligne 37 : ici nous basculons le drapeau `is_focused` vers l'état actuel.

Comme mentionné ci-dessus, les `ClutterActor` qui possèdent des valeurs `depth` plus grandes reçoivent les événements mais peuvent autoriser les `ClutterActor` en dessous d'eux à recevoir les événements également. En renvoyant `TRUE`, l'acteur empêche la transmission des événements alors qu'en renvoyant `FALSE` la transmission se fait.

Rappelez-vous cependant que pour recevoir des événements les `ClutterActor` doivent être définis à `reactive`.

Ce qui suit est la fonction bien commode transmise à `g_slist_foreach`.

static void foreach_set_focus_state(gpointer data, gpointer user_data) { ClutterActor *actor = CLUTTER_ACTOR(data); gboolean is_reactive = *((gboolean*)user_data);

clutter_actor_set_reactive(actor, is_reactive); }

Ligne 2-5 : la signature de cette fonction nécessite deux `gpointer`. Le premier est un pointeur vers le `ClutterActor` que notre `GSList` contient et l'autre est le drapeau `is_focused` que nous avons transmis dans la section précédente. Nous allons en garder une trace et les enregistrer pour pouvoir les utiliser facilement.

Ligne 7 : en fonction de la valeur booléenne transmise, le `ClutterActor` est paramétré pour répondre aux événements ou pas.

# Construction et lancement de l'application

Le programme complet devrait maintenant être prêt à fonctionner. Tout ce dont vous avez besoin est de quelques images à charger. Par défaut, les images sont chargées à partir d'un répertoire berlin_images. Vous pouvez, si vous voulez, modifier la ligne `#define IMAGE_DIR_PATH` qui se trouve au début du fichier pour faire référence à votre répertoire de photos ou créer un répertoire berlin_images en cliquant sur Projet Nouveau répertoire... et en créant un sous-répertoire berlin_images dans le répertoire murdephotos. Assurez-vous de mettre au moins 12 images dans le répertoire !

Après avoir fait cela, cliquez sur Construire Construire le projet pour tout reconstruire, puis sur Exécuter Exécuter pour lancer l'application.

Si vous ne l'avez pas déjà fait, choisissez l'application Debug/src/murdephotos dans la boîte de dialogue qui apparaît. Enfin, cliquez sur Lancer et amusez-vous !

# Implémentation de référence

Si vous rencontrez des difficultés avec ce tutoriel, comparez votre programme à ce programme de référence.