|
L'écran de pré-visualisation de ScreenSaversne fonctionnera pas correctement à moins que vous n'effectuiez votre dessin dans la fonction Draw()
|
| Table des matières Economiseurs d'écran | Index Economiseurs d'écran |
Derivée de : néant
Declarée dans : be/add-ons/screen_saver/ScreenSaver.h
Librairie : ???
BScreenSaver propose une interface pour les développeurs qui veulent créer leurs propres modules économiseurs d'écran. Les classes dérivées de BScreenSaver implémentent les fonctions définies ici afin de dessiner à l'écran pendant que l'économiseur est en train de tourner, et de dessiner dans l'écran de pré-visualisation de ScreenSaver (voir "Dialogue avec ScreenSaver" pour une présentation de l'écran de pré-visualisation).
La classe BScreenSaver est une classe abstraite ; on doit en utiliser une sous-classe. De plus, vous ne créerez jamais d'objet d'une sous-classe de BScreenSaver vous-même; ils sont crées automatiquement en fonction des besoins par ScreenSaver.
Quand ScreenSaver veut utiliser votre économiseur d'écran, il crée une instance de votre sous-classe de BScreenSaver (à l'aide de la fonction instantiate_screen_saver(), comme expliqué dans "Les Add-ons économiseur d'écran"), puis appelle les fonctions de l'objet dans cet ordre :
Quand le panneau de préférences de ScreenSavers charge votre module, les appels successifs sont similaires, à ces quelques différences :
Les fonctions suivantes peuvent être appelées à tout moment :
Vous n'êtes pas obligé d'utiliser les fonctions Draw()/DirectDraw() ; elles sont proposées comme une facilité pour réaliser des économiseurs d'écran simples.
Une approche pour réaliser votre propre méthode de dessin est de lancer un thread de dessin dans StartSaver() et de le détruire dans StopSaver(). Vous devriez implémenter la fonction Draw() pour indiquer au thread de dessin quand l'écran est disponible (frame = 0). Après cela, vous pouvez dessiner de la manière qui vous plait.
|
Si vous voulez un accès direct au buffer d'écran, vous devrez gérer la synchronisation avec DirectConnected() vous-même, car à ce moment l'économiseur d'écran verrouille l'affichage (ce verrou est géré automatiquement si vous utilisez DirectDraw()).
InitCheck()
Peut être implémentée pour indiquer à Screen Saver que votre add-on a été initialisé correctement.
StartSaver()
Peut être implémentée pour faire ce qui doit être fait juste avant que l'économiseur d'écran ne commence à dessiner.
StopSaver()
Peut être implémentée pour faire ce qui doit être fait quand l'économiseur d'écran cesse de dessiner.
Draw()
Peut être implémentée pour que l'économiseur d'écran dessine (à l'écran, ou bien dans l'écran de pré-visualisation du panneau de préférences de ScreenSaver).
DirectConnected()
Appelée quand la connexion à l'écran a été effectuée, quand la taille ou le format du buffer d'écran change, quand la position, taille ou forme de la partie visible du contenu de la fenêtre change, ou quand la connexion à l'écran est terminée.
DirectDraw()
Peut être implémentée pour que l'économiseur d'écran dessine en accédant directement aux pixels (comme dans une BDirectWindow).
StartConfig()
Peut être implémentée pour afficher le copyright et les informations de configuration de l'économiseur d'écran dans le panneau des préférences de ScreenSaver.
StopConfig()
Peut être implémentée pour s'occuper de ce qui doit être modifié juste avant que la vue de configuration de ScreenSaver ne se ferme.
SupplyInfo()
Peut être implémentée pour fournir des informations au Screen Saver à propos de l'add-on. Le Screen Saver envoie alors ces informations aux autres add-ons économiseurs d'écran (en invoquant leur fonction ModulesChanged()).
ModulesChanged()
Peut être implémentée pour obtenir des informations à propos des autres add-ons économiseurs d'écran.
SaveState()
Peut être implémentée pour sauvegarder l'état actuel de l'économiseur d'écran, permettant de le restaurer plus tard.
|
Construit un objet de type BScreenSaver à partir de l'information d'état stockée dans state (si elle existe, comme expliqué plus loin). Après construction, votre économiseur d'écran n'est pas immédiatement connecté à une BView, donc vous ne pouvez rien faire qui en nécessite une. Vous aurez tout le temps pour cela plus tard, comme indiqué dans StartSaver() et StartConfig(). Pour déterminier si la construction s'est bien passeé, Screen Saver appelle InitCheck().
L'argument state contient tout ce que vous y avez stocké quand SaveState() a été invoqué lors d'une instanciation précédente de votre objet —en d'autres termes, state est l'état de votre objet la dernière fois qu'il a été lancé. Au cas où vous lancez votre économiseur d'écran pour la toute première fois, state sera vide, et vous devrez prévoir des valeurs par défaut. Le format de state est à votre convenance —vous écrivez et lisez sa valeur, personne d'autre ne le modifiera.
L'argument image est l'image (au sens du Kit noyau) de l'add-on lui-même. Ceci est particulièrement utile si votre économiseur d'écran a besoin de retrouver certaines données stockées dans l'add-on. Par exemple, imaginez que votre sous-classe de BScreenSaver (SpiffySaver) a une BResources *my_rsrc ; Voici comment récupérer cette ressource :
#include <kernel/OS.h>
#include <storage/Resources.h>
SpiffySaver::SpiffySaver( BMessage *info, image_id id )
{
/* Initialisation... */
...
/* Récupérer les ressources de SpiffySaver pour pouvoir les réutiliser. */
image_info the_info;
status_t retval = get_image_info( id, &the_info );
if( retval != B_OK ) {
/* gripe at the user or bail out. */
}
my_rsrc = new BResources;
retval = my_rsrc->SetTo( new BFile( the_info.name, O_RDONLY ) );
if( retval != B_OK ) {
/* gripe at the user or bail out. */
}
/*
* Anything else you need in the constructor, such as
* finding strings in your resources.
*/
...
}
|
Détruit votre économiseur d'écran ; c'est ce qui se produit quand l'utilisateur veut quitter l'économiseur. A ce moment, le destructeur est appelé, vous ne dessinez plus à l'écran , et StopConfig() et StopSaver() ont déjà été appelées.
|
Ce sont les fonctions qui permettent de dessiner à l'écran. Pour un dessin "normal", vous surchargez Draw(); pour afficher les bits directement (comme vous le feriez dans une BDirectWindow), vous devez utiliser DirectDraw(). En général, vous ne devez implémenter qu'une des deux fonctions. Si vous implémentez les deux fonctions, les deux seront appelées. DirectDraw() sera toujours appelée avant Draw() si vous implémentez les deux.
Draw() est appelée une fois tous les TickSize() microsecondes. view est la vues dans laquelle vous dessinez; frame est un compteur d'images qui commence à 0 et est incrémenté chaque fois que Draw() est appelé. L'affichage démarre avec une couleur B_TRANSPARENT_32_BIT, ce qui signifie qu'on verra le bureau à travers. Si vous ne voulez pas voir le bureau (votre add-on rend peut-être mieux sur fond noir), vous devez effacer l'écran dès la première image (frame == 0).
Le fonctionnement de DirectDraw() (et sa fréquence d'appel par le système) est identique que pour Draw(), mais dans la mesure où il dessine directement à l'écran, DirectDraw() n'a pas de paramètre view. voir DirectConnected() pour plus d'informations à propos du dessin direct vers l'écran.
Plus l'add-on passe de temps dans les fonctions Draw()/DirectDraw(), plus l'utilisateur devra attendre de temps pour revenir à l'écran normal en quittant l'add-on, et cela ennuie tout le monde. Effectuez votre dessin et sortez de la fonction aussi vite que possible.
|
Fonction appelée quand l'accès direct à la fenêtre est autorisé ou suspendu, ou quand l'état de l'écran sur lequel vous dessinez (directement) chaange. L'argument info décrit l'état de l'affichage; voir la classe BDirectWindow (dans le Kit de jeu) pour plus d'informations sur la structure direct_buffer_info.
|
Le code de DirectConnected() doit être aussi court que possible, car ce qu'il fait peut agir sur les performances générales du système. DirectConnected() devrait simplement s'occuper des changements relatifs à l'affichage direct vers l'écran, et ne devrait par effectuer de dessin—c'est ce que DirectDraw() est censée faire.
DirectConnected() ne devrait se terminer que lorsqu'elle peut garantir que la requête spécifiée par info sera respectée strictement.
La structure sur laquelle pointe info est effacée dès que DirectConnected() se termine, donc vous devez sauvegarder les informations qui vous intéressent.
|
Fonction utilisée par Screen Saver pour s'assurer que la construction de votre objet a réussi. Votre version de InitCheck() doit renvoyer B_OK si l'objet s'est créé correctement, et B_ERROR en cas de problème. Par défaut InitCheck() renvoie B_OK.
InitCheck() est appelé après le constructeur, mais avant que l'on demande quoi que ce soit à l'objet. A utiliser pour examiner l'environnement d'exécution, et indiquer à Screen Saver si ce qui se passe ne vous convient pas. Par exemple si votre économiseur d'écran a besoin d'une carte OpenGL, c'est ici qu'il faut renvoyer une erreur si vous ne trouvez pas la carte nécessaire.
|
Implémentez cette fonction pour sauvegarder l'état de votre économiseur d'écran de façon à le récupérer la prochaine fois que vous l'objet sera construit. Vous sauvegardez l'état dans le message state, qui sera passé au constructeur de votre objet.
Si votre version de SaveState() renvoie autre chose que B_OK, Screen Saver ignorera tout ce qui se trouve dans le message state.
SaveState() peut être appelée à tout moment, et ne sera pas systématiquement appelée par StopSaver(); votre économiseur ne doit pas en dépendre pour appliquer les modifications au variables modifiées depuis la vue de configuration. Vous devez vous en occuper directement (et immediatement) de façon à ce que l'utilisateur puisse suivre en direct ses modifications.
|
Ces fonctions sont utilisées pour contrôler les cycles d'animation. Pour certains économiseurs d'écran, on peut être amené à dessiner de manière répétitive, puis marquer une pause. Par exemple, un économiseur dessinant des taches d'encre pourrait dessiner des pixels à chaque image jusqu'à ce qu'il y en ait un certain nombre à l'écran, puis passer un certain temps à attendre avant d'effacer l'écran et de recommencer.
Utilisez SetLoop() pour implémenter un économiseur d'écran qui utilise un tel cycle. Votre méthode Draw() et/ou DirectDraw() sera appelée pour on_count images (et le compteur d'images sera toujours compris entre 0 et on_count - 1), puis Screen Saver va attendre (pendantTickSize() microsecondes) pendant off_count fois.
Par exemple, si vous utilisez SetLoop( 10, 5 ), votre économiseur va dessiner les images de 0 à 9, puis va attendre pendant TickSize() microsecondes 5 fois.
La fonction LoopOnCount() renvoie le nombre d'images à afficher (c'est-à-dire on_count).
La fonction LoopOffCount() renvoie le nombre d'images pendant lequel l'économiseur attend (c'est-à-dire off_count).
|
SetTickSize() met la fréquence de dessin de l'économiseur à size microsecondes. Cela vous permet de déterminer la fréquence d'appel à la fonction Draw() et/ou DirectDraw(). La valeur par défaut est 50000 (50 millisecondes).
Si l'on met ticksize à 0, la fonction Draw()/DirectDraw() sera appelée pratiquement sans délai; en réalité, il y aura un délai déterminé par l'ordonnanceur de tāches. C'est une bonne chose car cela laisse du temps d'exécution aux autres threads, et l'économiseur continue de répondre rapidement quand l'utilisateur l'interromp.
Si vous choisissez une valeur de ticksize de 0, n'appelez pas snooze(), snooze_until(), sleep() ou n'importe quelle fonction qui peut se bloquer indéfiniment. Les utilisateurs effaceront rapidement votre économiseur si ce genre de blague se produit car personne n'aime voir son système bloqué. Si vous n'avez pas besoin de délai, invoquez SetTickSize() avant d'avoir fini de dessiner et remettez le à 0 ensuite.
TickSize() renvoie la fréquence de dessin en microsecondes.
|
La fonction StartConfig() est appelée quand le panneau de préférences de Screen Saver est sur le point d'afficher la vue de configuration de votre module. Tout les éléments de contrôle que vous voulez créer afin de permettre à l'utilisateur de régler les paramètres de votre module doit être ajouté dans configView. N'oubliez pas d'indiquer à quoi sert chaque élément de contrôle que vous ajoutez ; pour cela vous pouvez par exemple ajouter une BView et une SetTarget() à vos contrôles dans cette vue dans la fonction AttachedToWindow().
Ne faites pas dessiner votre économiseur à l'intérieur de configView ; cela sert à afficher des informations à propos de votre module, et vérifie si l'économiseur prend bien en compte sa configuration. StartSaver() sera appelée (avec son argument preview à true) pour pre-visualiser votreœuvre.
StopConfig() est appelée quand la vue de configuration des préférences de ScreenSaver est en cours de fermeture.
|
L'invocation de StartSaver() signifie que Screen Saver va lancer l'économiseur (si preview est à false), ou que ScreenSavers va afficher le module dans son écran de pré-visualisation (si preview est à true).
Dans votre implémentation de StartSaver(), vous ne pouvez pas ajouter de vue fille, et vous ne pouvez pas encore dessiner à l'écran. Attendez l'appel à Draw() ou DirectDraw() pour cela. La vue deviendra visible après la fin de StartSaver().
StartSaver() vous donne l'occasion de préparer votre économiseur car elle vous dit quelle quantité de données vous pouvez sauvegarder via l'argument view. Vous pouvez également utiliser view pour calculer votre palette de couleurs (indirectement, en créant un BScreen avec view–>Window() dans le constructeur).
Renvoyez B_OK si tout va bien, ou B_ERROR si vous n'êtes pas prêt à dessiner à l'écran. Les économiseurs sans pré-visualisation doivent renvoyer B_ERROR quand on leur demande une preview :
status_t SpiffySaver::StartSaver( BView *view, bool preview )
{
/* SpiffySaver has no preview... it>s not THAT spiffy. */
if( preview ) return B_ERROR;
...
return B_OK;
}
StopSaver() est appelée quand l'économiseur ne doit plus afficher. Elle est appelée après le tout dernier appel à Draw() ou DirectDraw().
|
|
Ces fonctions servent à la communication entre les modules économiseurs d'écran.
Screen Saver appelle SupplyInfo() quand il veut que vous lui fournissiez des informations à propos de l'économiseur. Stockez toute information que vous souhaitez communiquer aux autres modules dans le message info. Ce message est alors envoyé aux autres modules économiseurs via leur fonction ModulesChanged().
La fonction ModulesChanged() est appelée que la liste des économiseurs d'écran disponibles change. Le BMessage info contient un BMessage pour chaque module valide. Chaque BMessage est nommé selon l'add-on auquel il se rapporte, et contient les informations renvoyées par l'implémentation de SupplyInfo() de chaque module.
Comme exemple —un peu inutile certes—nous allons afficher le nom et le contenu de chaque BMessage :
void SpiffySaver::ModulesChanged( const BMessage *info )
{
int32 num_addons = info->CountNames( B_MESSAGE_TYPE );
for( int idx = 0; idx < num_addons; idx ++ ) {
status_t retval;
type_code found_type;
char *name;
retval = info->GetInfo( B_MESSAGE_TYPE, idx,
&name, &found_type );
if( retval == B_OK ) {
BMessage msg;
retval = info->GetMessage( name, &msg );
if( retval == B_OK ) {
printf( "A module named "%s" sent this info:n", name );
msg.PrintToStream();
}
}
}
}
| Table des Matières Economiseurs d'écran | Index Economiseurs d'écran |
Copyright © 2000 Be, Inc. All rights reserved..