Réalisez votre propre écran de veille pour Windows

Introduction du cours

Bonjour à tous les Zér0s, et bienvenue dans ce tutoriel sur la réalisation d'un écran de veille.

Certains d'entre vous ont déjà du voir l'ancienne version du tutoriel. Cette dernière a fait l'objet de remarques selon lesquelles il était bien trop lourd et indigeste. Je vous présente donc ce tutoriel entièrement reformulé pour essayer de le faire plus court et plus clair. J'espère qu'il vous plaira à tous.

Pour les nouveaux, eh bien bienvenue aussi. J'espère également que ce tutoriel vous conviendra.

Je vais donc vous apprendre à réaliser un écran de veille en C++, ou plutôt à réaliser un "point d'entrée pour écran de veille".

Gné ? Un point d'entrée pour un écran de veille ?

Oui. Disons que je vais vous expliquer comment réaliser une classe qui permettra de mettre en route une application de type écran de veille. En gros, il vous suffira par la suite de créer une instance de cette classe pour créer vos propres écrans de veille à partir de celle-ci sans avoir à vous soucier du technique qu'il y a derrière. Pendant le développement de cette classe, nous allons créer un écran de veille d'exemple, pour avoir quelque chose comme ceci :

En raison de certaines parties du code assez pointues, ce tutoriel est classé en difficulté intermédiaire. Pour la plupart d'entre vous, vous y découvrirez des concepts non appris dans les cours de base du C. Je vous rappelle cependant que le but est d'écrire ce code une fois pour toutes, et qu'il ne sera pas nécessaire d'utiliser ces notions pour créer vos écrans de veille sur cette base par la suite. Si vous ne comprenez pas à 100% les concepts futurs, l'important est que vous réussissiez à les implémenter. Je m'efforcerai de faire du mieux possible pour que ça passe.

Avant de commencer ce tutoriel, il est plus que fortement recommandé de comprendre et de savoir utiliser les langages de programmation C et C++. Si ce n'est pas le cas, je vous rappelle qu'il existe un cours sur chacun de ces langages sur le Site du Zéro. Il vous suffit de choisir le cours que vous désirez dans la partie gauche du site. Il est également conseillé d'avoir vu et compris le tutoriel annexe sur le C++ situé ici (tutoriel avancé sur le C++), car nous allons utiliser une technique décrite dans ce cours. Enfin, ce tuto explique comment réaliser un écran de veille sous Windows uniquement. En effet, certains concepts de programmation système vont être utilisés. N'essayez donc pas de compiler sous Linux, cela ne passera pas.

(au passage si quelqu'un sait comment réaliser le même genre de chose sous Linux, je suis preneur bien entendu :-° )

Ah, petit détail avant de commencer encore : le tuto est marqué en "copie non autorisée", mais bien évidemment vous pouvez utiliser le code fourni comme bon vous semble. Je souhaite simplement que le contenu textuel de ce tutoriel ne soit pas recopié quelle qu'en soit la fin. Je vous remercie par avance.

Allez c'est parti ! Ta-taa yo-yooooooooooooooo

Théorie de base et prérequis

Avant de foncer dans le code, nous allons d'abord voir ensemble ce qu'est un écran de veille, et donc ce qui nous attend par la suite. Ensuite nous mettrons tout en place et nous pourrons attaquer le code à proprement parler

Un écran de veille... c'est quoi?

C'est une bonne question ; mais la réponse est tout aussi simpliste vous allez voir ^^
En fait, un écran de veille est un fichier au format .scr, qui se trouve dans le dossier System32 de Windows (ou SysWOW64 si vous possédez une version 64 bits de votre système)
En allant y faire un tour, on peut y voir des fichiers comme celui-ci (pêché dans Windows 7)

Le dossier System32 (ou SysWOW64) est un dossier extrêmement important de votre système d'exploitation. Il ne faut jamais, au grand jamais toucher aux fichiers qui s'y trouvent ! Nous allons dans ce tuto toucher uniquement au fichier .scr sur lequel nous allons travailler.

C'est le système qui s'occupe de lancer le .scr correspondant à l'écran de veille choisi lorsque l'utilisateur n'est pas actif pendant une certain laps de temps (celui que l'on choisit dans l'écran de configuration des écrans de veille). Mais un .scr peut également être lancé directement, essayez donc. Quand vous lancez le .scr, vous avez l'écran de veille correspondant qui se met en route, et qui disparaît quand vous bougez la souris par exemple. Vous noterez que en lançant l'écran de veille de cette façon, même en mode protection le système ne vous demandera pas votre mot de passe pour le fermer.

Donc, c'est un fichier .scr. C'est bien, mais en programmation C++ on ne peut faire que des .exe et des librairies statiques et dynamiques, mais un .scr, on fait comment ?

J'y viens : vous allez être surpris, mais c'est parfaitement faisable. Vous allez à présent découvrir la plus grande révélation du monde entier, préparez vous au choc ^^
Un .scr, eh bien... c'est un .exe que l'on aura renommé en .scr

Donc un .scr c'est un .exe ; mais dans ce cas, qu'y a t-il à nous apprendre ? si on sait faire un .exe on sait faire un .scr non ?

Eh bien, pas tout à fait, et pour une raison très simple : un écran de veille, ce n'est pas seulement une application que l'on lance et qui affiche une jolie animation (tant qu'à faire ) à l'écran. En effet, c'est une application qui doit avoir différents comportements selon ce qu'on lui demande :

• Afficher l'écran de veille en plein écran ;

• Afficher un aperçu dans la fenêtre de sélection des écrans de veille (voir la première image du tuto) ;

• Lancer le mode configuration pour pouvoir régler les paramètres.

Ce que nous allons développer ici, c'est donc une classe C++ qui aura la charge de distinguer toutes ces différentes demandes et initialiser le programme en fonction de ces dernières. Il ne restera plus pour le programmeur qu'à développer la partie configuration et la partie affichage - voire 2 parties différentes si l'aperçu n'est pas identique à l'écran de veille en lui-même, ce qui est parfois le cas.

Nous allons à présent voir quels outils et quelles librairies nous allons utiliser pour cela.

Prérequis

Alors pour travailler tranquille, nous allons avoir besoin d'une petite ribambelle d'outils. Pour commencer, il faut un IDE. Je vais utiliser pour cet exemple Visual Studio 2008 de Microsoft, que je vous conseille fortement. Mais vous êtes bien entendu libres d'utiliser l'IDE qui vous plaît. Je n'ai pas testé la compilation des fichiers sources avec d'autres IDE et je ne sais pas ce que ça peut donner, donc il est probable que la compilation puisse être plus délicate.
À noter que certains IDE comme Code::Blocks proposent d'utiliser le compilateur de Visual Studio. Vous pouvez donc installer VS et utiliser son compilateur fourni avec votre IDE préféré.

Si vous compilez une librairie avec le compilateur de VS, cette dernière ne sera utilisable que par VS (même version obligatoire). Les autres IDE utilisent généralement tous le même compilateur sous Windows, à savoir celui fourni avec minGw (équivalent Windows de GCC).

Si vous souhaitez installer VS, il suffit de procéder comme suit :

• Allez sur cette page : Télécharger Visual C++ 2008 Express Edition

• Cliquez sur "Visual Studio 2008 express" en dessous de "Downloads", ensuite sélectionnez "Visual C++ 2008 express edition", "French" et enfin "Free download".

• Lancez l'exéctuable que vous venez de télécharger et installez VS.

A l'heure où j'écris ces lignes, Visual Studio 2010 existe déjà, cependant les librairies tierce-partie que nous allons utiliser pour notre projet ne sont pas encore disponibles pour cette version. Si vous l'utilisez, il vous faudra télécharger les sources de ces librairies et les recompiler avec VS 2010 pour pouvoir les utiliser - expérience faite par un ami qui s'est bien amusé semblerait t-il ^^.

Ensuite, nous allons utiliser une autre bibliothèque : nous aurons besoin de créer une application graphique avec des fenêtres. De plus une bibliothèque qui nous fournit un support pour développer avec une librairie 3D comme OpenGL nous donnerait un avantage supplémentaire. Nous allons donc utiliser...

SDL ?

Non. C'était bien tenté, mais nous n'allons pas utiliser SDL, pour une raison plus que valable, que je ne peux pas vous expliquer ici (c'est un peu technique), mais sur laquelle nous allons revenir plus tard. A la place, nous allons utiliser SFML. SFML est une bibliothèque qui a le même but et les mêmes fonctionnalités que la SDL, mais qui est plus complète et qui est basée sur l'objet (SDL fonctionne en procédural). Je remercie au passage Sylphcius pour cette petite précision concernant SFML dans son commentaire sur l'ancien tutoriel.

Je viens de me rendre compte qu'un tuto sur SFML est désormais disponible sur le site du zér0. Si vous voulez vous pencher sur cette bibliothèque intéressante, je vous propose de lire ce big-tuto.

Pour télécharger SFML, il suffit de se rendre ici : Télécharger SFML
Choisissez simplement la version de SFML correspondant au compilateur que vous utilisez, avec ou sans la doc et les exemples selon votre humeur du jour. Ensuite lancez l'exécutable et suivez les instructions.

Vous trouverez sur le site des tutoriels pour vous expliquer comment configurer votre IDE pour accuillir SFML.

Maintenant que nous avons tout le nécessaire, nous allons pouvoir attaquer la mise en place du projet et du squelette de base de l'application.

Stooooooop ! o_O Ca me paraît un peu gros de devoir utiliser tout ça ! J'ai entendu parler d'une librairie fournie par Windows qui s'appelle "scrnsave" et qui permet de faire des écrans de veille justement. Ce n'est pas plus simple de faire avec ça plutôt que de réinventer la roue ?

Bonne question ^^ Je voulais éviter le sujet, mais vu qu'elle est posée je réponds franchement : à la question "est-ce que je réinvente la roue ?", je répondrais ceci :

Citation

Ptêt' ben qu'oui, ptêt' ben qu'non !

En effet, cette librairie existe, mais pour deux raisons particulières je ne tiens pas à l'utiliser et à vous l'apprendre :

1. Cette librairie utilise à peu près les mêmes concepts que je veux vous apprendre, mais les appels sont faits à un niveau plus bas (programmation système au lieu d'une classe claire et facile à utiliser). De plus, elle fonctionne en utilisant un timer (un évènement est reçu tous les x temps) et qu'il faut pouvoir traiter de manière très intelligente afin de tirer profit au maximum de la machine (entre 2 timers, on fait quoi?).

2. Je ne rentrerai pas dans les détails, sinon le tutoriel risquerait d'être très très long ( :-° ), mais pour faire simple je dirais que cette librairie peut être utile pour faire des écrans de veilles très basiques, et si vous avez envie de vous mettre à la programmation système. Je n'ai rien contre, je le précise, et vous pouvez bien entendu si vous le souhaitez rechercher toutes les infos que vous voulez la-dessus sur le web, c'est juste une technique que je n'utiliserai pas ici.

Ok, est-ce qu'il y a d'autres questions avant de commencer ?

Oui, moi ! Quand c'est qu'on mange ?

*soupir*
Allez c'est parti ^^

Mise en place du projet et squelette de baseSquelette de base

Nous allons avant de faire une librairie commencer par faire un projet d'application Win32 tout simple. Créez donc un projet vide de type application Win32 (pas en console, nous n'en avons pas besoin). Pour ceux qui utilisent VS, il n'est pas la peine d'utiliser l'en-tête précompilé, car nous n'aurons qu'un seul header et une seule classe à faire. Décochez également l'option ATL.

Avant de commencer, il va falloir configurer le projet. En effet, nous souhaitons avoir un fichier .scr en sortie, et non pas un fichier .exe !

Pour les utilisateurs de VS, cette option de configuration se trouve dans la page de configuration du projet, outil "éditeur de liens", onglet "général" et champ "sortie". Remplacez seulement ".exe" par ".scr". Pensez à appliquer cette modification aux deux configurations debug et release du projet.

Maintenant que notre projet est créé et configuré, nous allons écrire la classe qui constituera le coeur de notre application. Cette classe servira de base à chacun des projets d'écran de veille que vous réaliserez, et sera celle qui sera placée dans la bibliothèque statique que nous créerons à la fin du tutoriel. Nous allons ainsi utiliser le même principe qui est utilisé dans Qt pour la création d'une application, et qui est appliqué encore dans bien d'autres bibliothèques. Je m'explique :

La classe de base est une classe qui contient la structure basique permettant la mise en route de l'application visée (ici notre écran de veille). Elle contient un certain nombre de fonctions virtuelles que l'utilisateur va pouvoir dériver pour ajouter le code nécessaire à la réalisation précise de son application, sans avoir à se soucier de la base, déjà construite. Je vous fais un petit schéma (comme demandé) pour que vous y voyiez plus clair :

Comme on peut le voir sur ce schéma, chaque application d'écran de veille utilisera deux classes. Celle d'en haut, "ScreenSaver", la classe que nous allons écrire ici servira de base à tous les écrans de veille que vous écrirez. Une fois cette classe écrite, vous n'y toucherez plus jamais. Cette classe aura pour rôle définitif de déterminer ce que l'on demande à l'écran de veille (aperçu, configuration, ou plein écran ?), et d'appeler certaines méthodes en fonction afin de faire l'écran de veille souhaité par héritage.

Celle d'en bas, par contre, sera spécifique à chacun de vos écrans de veille. Elle redéfinit les fonctions déclarées virtuelles dans la classe parente et possède un corps qui permet d'avoir le comportement voulu pour l'écran de veille en question. Par exemple, elle peut redéfinir une fonction de rendu (voir un peu plus loin) à chaque passage dans la boucle principale de la classe mère.

Créez donc un fichier "ScreenSaver.h" qui contiendra le code suivant :

#ifndef _SCREEN_SAVER_H_ #define _SCREEN_SAVER_H_ #include <SFML/Window.hpp> #include <Windows.h> #ifdef _DEBUG #pragma comment (lib, "sfml-window-s-d.lib") #pragma comment (lib, "sfml-system-s-d.lib") #else #pragma comment (lib, "sfml-window-s.lib") #pragma comment (lib, "sfml-system-s.lib") #endif // notre classe point d'entrée class ScreenSaver { public: // CONSTRUCTEUR /!\ DESTRUCTEUR // toujours écrire les 2, sans aucune exception, même si les corps sont vides // cela permet de rappeller que faire une allocation dynamique implique la libération mémoire dans le destructeur ScreenSaver(); ~ScreenSaver(); // La fonction run. Cette fonction est lancée par le main de l'application // retourne le code de retour que le main doit rendre // si debug est à true, alors on lance l'écran de veille en mode fenêtré, pour permettre le déboguage // si debug est à true, il empêche également la fenêtre de se détruire sur un évènement de mouvement de souris int run(HINSTANCE hInstance, LPSTR lpCmdLine, const sf::VideoMode & videoMode, const bool debug); protected: // La fonction config est appelée depuis la fonction run, et permet de configurer l'écran de veille // son comportement par défaut est d'afficher une boîte de dialogue indiquant que rien n'est configurable // elle retourne 0 si tout s'est bien passé, sinon un code d'erreur...