L'objet de traitement

Chargez un greffon simple tel que le gain pour voir à quoi ressemble cet objet. L'objet de traitement doit hériter du dérivé prévu de PluginClient“. Son constructeur doit avoir un paramètre PluginServer.

     MyPlugin(PluginServer *server);

Dans l'implémentation, le greffon doit comporter une ligne d'enregistrement avec le nom de l'objet traitement telle que :

     REGISTER_PLUGIN(MyPlugin)

Le cosntructeur doit contenir :

     PLUGIN_CONSTRUCTOR_MACRO

pour initialiser les variables les plus courantes.

L'objet traitement doit avoir un destructeur comportant :

     PLUGIN_DESTRUCTOR_MACRO

pour supprimer les variables les plus courantes.

Une autre fonction utile mais non nécessaire est :

     int is_multichannel();

Elle doit retourner 1 si une instance du greffon gère simultanément plusieurs pistes et 0 si une instance du greffon ne gère qu'une piste. La valeur est de 0 par défaut si elle est omise.

Les greffons multicanaux doivent, dans leur fonction de traitement, se référer à une fonction appelée PluginClient”“::get_total_buffers() pour déterminer le nombre de canaux.

Pour simplifier l'implémentation des greffons temps réel, une macro pour les membres habituellement utilisés a été créée pour les en-têtes de classes. Elle prend comme paramètres l'objet de configuration et le processus objet de l'interface utilisateur. Les définitions de macro s'adressent principalement aux greffons temps réel et ne sont pas utiles pour les greffons non temps réel. Heureusement, les greffons non temps réel sont plus simples.

     PLUGIN_CLASS_MEMBERS(config_name, thread_name)

Les membres de PLUGIN_CLASS_MEMBERS couramment utilisés sont décrits ci-dessous.

int load_configuration();

Charge la configuration en se basant sur les images-clés qui se trouvent à proximité et sur la position actuelle. La définition de classe pour load_configuration doit contenir :

          LOAD_CONFIGURATION_MACRO(plugin_class, config_class)

pour implémenter le comportement par défaut de load_configuration. Ceci enregistre ce qui se trouve dans la configuration actuelle dans l'objet de configuration du greffon et retourne 1 si la nouvelle configuration est différente de la précédente. La valeur de retour de load_configurationest utilisée par une autre fonction couramment utilisée, update_gui pour déterminer si l'interface graphique a vraiment besoin d'être mise à jour.

L'objet de configuration du greffon est toujours appelé config dans PLUGIN_CLASS_MEMBERS.

VFrame* new_picon();

Crée une miniature à afficher dans la fenêtre des ressources. Utilisez :

          #include "picon_png.h"
          NEW_PICON_MACRO(plugin_class)

pour implémenter une nouvelle miniature. De plus, l'utilisateur doit créer le fichier d'en-tête picon_png.h à partir d'une image PNG en utilisant pngtoh. pngtoh est construit dans le répertoire guicast/ARCH.

L'image png soit s'appeler picon.png et peut être de n'importe quel format géré par PNG.

char* plugin_title();

Retourne une chaîne de texte identifiant le greffon dans la fenêtre des ressources. Cette chaîne doit être unique.

void update_gui();

Doit d'abord charger la configuration, teste un code de retour égal à 1 et redessine ensuite l'interface graphique avec les nouveaux paramètres. Tous les greffons qui utilisent GuiCast ont un format semblable à celui-ci :

          void MyPlugin::update_gui()
          {
          	if(thread)
          	{
          		if(load_configuration())
          		{
          			thread->window->lock_window();
          // update widgets here
          			thread->window->unlock_window();
          		}
          	}
          }

pour gérer les accès concurrents et les conditions dans lesquelles il n'y a pas d'interface graphique.

int show_gui();

Instancie l'interface graphique et bascule le greffon en mode interface graphique (GUI mode). C'est implémenté par :

          SHOW_GUI_MACRO(plugin_class, thread_class)

int set_string();

Change le titre de la fenêtre de l'interface graphique en utilisant une certaine chaîne de caractères. C'est impélémenté par :

          SET_STRING_MACRO(plugin_class)

void raise_window();

Affiche la fenêtre de l'interface graphique sur le dessus de la pile. C'est implémenté par :

          RAISE_WINDOW_MACRO(plugin_class)

Des fonctions importantes que doit définir l'objet de traitement sont les fonctions qui chargent et enregistrent les données de configuration depuis les images-clés. Ces fonctions sont appelées par les macros et vous n'avez donc pas à vous préoccuper de l'accès aux données des images-clés.

     void save_data(KeyFrame *keyframe);
     void read_data(KeyFrame *keyframe);

les fonctions read_data sont utilisées dans les greffons temps réel. Les fonctions data_functions convertissent la configuration du greffon depuis le paramètre KeyFrame vers l'objet de configuration du greffon. Les images-clés sont enregistrées sur la timeline et peuvent changer pour chaque projet.

Utilisez un objet appelé FileXML pour effectuer la translation et certaines commandes spécifiques pour obtenir les données à partir du paramètre KeyFrame. Vous trouverez des exemples d'utilisation de KeyFrame et FileXML dans les greffons existants.

     int load_defaults();
     int save_defaults();

Les fonctions load_defaults sont utilisées dans les greffons temps réel et les greffons non temps réel. Les fonctions load_defaults convertissent la configuration du greffon depuis un objet Defaults vers la configuration du greffon. L'objet Default enregistre les configurations dans des fichiers individuels sur disque pour chacun des greffons mais il n'isole pas les configurations entre les différents projets.

La fonction qui surcharge load_defaults doit aussi créer l'objet Defaults. Vous pouvez consulter un greffon existant pour des exemples d'utilisation de Defaults.

D'autres objets standards peuvent être définis dans l'objet de traitement, en fonction du type de greffon.