# API extension

## set_charset

Prototype : `void set_charset (t_weechat_plugin *plugin, char *charset)`

Change le jeu de caractères de l'extension.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `charset` : nouveau jeu de caractères à utiliser

Exemple :

    plugin->set_charset (plugin, "ISO-8859-1");

## iconv_to_internal

Prototype : `void iconv_to_internal (t_weechat_plugin *plugin, char *charset, char *string)`

Convertit une chaîne de caractères vers le jeu de caractères interne WeeChat (UTF-8).

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `charset` : le jeu de caractères de départ

- `string` : la chaîne à convertir

Valeur renvoyée : la chaîne convertie.

Note : le résultat doit être libéré par un appel à la fonction "free" après utilisation.

Exemple :

    char *str = plugin->iconv_to_internal (plugin, "ISO-8859-1", "chaine iso: é à");

## iconv_from_internal

Prototype : `void iconv_from_internal (t_weechat_plugin *plugin, char *charset, char *string)`

Convertit une chaîne de caractères depuis le jeu de caractères interne WeeChat (UTF-8) vers un autre.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `charset` : le jeu de caractères voulu

- `string` : la chaîne à convertir

Valeur renvoyée : la chaîne convertie.

Note : le résultat doit être libéré par un appel à la fonction "free" après utilisation.

Exemple :

    char *str = plugin->iconv_from_internal (plugin, "ISO-8859-1", "chaine utf-8: é à");

## ascii_strcasecmp

Prototype : `int ascii_strcasecmp (t_weechat_plugin *plugin, char *chaine1, char *chaine2)`

Effectue une comparaison entre deux chaînes, sans tenir compte des majuscules/minuscules ni de la locale.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `chaine1` : la première chaîne à comparer

- `chaine2` : la deuxième chaîne à comparer

Valeur renvoyée : la différence entre les deux chaînes : négatif si chaine1 < chaine2, zéro si chaine1 == chaine2, positif si chaine1 > chaine2

Exemple :

    if (plugin->ascii_strcasecmp (plugin, "abc", "def") != 0) ...

## ascii_strncasecmp

Prototype : `int ascii_strncasecmp (t_weechat_plugin *plugin, char *chaine1, char *chaine2, int max)`

Effectue une comparaison entre deux chaînes, sans tenir compte des majuscules/minuscules ni de la locale, en comparant au plus "max" caractères.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `chaine1` : la première chaîne à comparer

- `chaine2` : la deuxième chaîne à comparer

- `max` : nombre de caractères max à comparer

Valeur renvoyée : la différence entre les deux chaînes : négatif si chaine1 < chaine2, zéro si chaine1 == chaine 2, positif si chaine1 > chaine2

Exemple :

    if (plugin->ascii_strncasecmp (plugin, "abc", "def", 2) != 0) ...

## explode_string

Prototype : `char **explode_string (t_weechat_plugin *plugin, char *chaine, char *separateurs, int num_items_max, int *num_items)`

Explose une chaîne en plusieurs selon un/des délimiteur(s).

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `chaine` : la chaîne à exploser

- `separateurs` : les délimiteurs utilisés pour exploser la chaîne

- `num_items_max` : nombre maximum de sous-chaînes créées (0 = pas de limite)

- `num_items` : pointeur vers un entier qui contiendra le nombre de sous-chaînes créées en retour

Valeur renvoyée : un tableau de chaînes, ou NULL si un problème a été rencontré.

Note : le résultat doit être libéré par un appel à la fonction "free_exploded_string" après utilisation.

Exemple :

    char **argv;
    int argc;
    argv = plugin->explode_string (plugin, chaine, " ", 0, &argc);
    ...
    if (argv != NULL)
        plugin->free_exploded_string (plugin, argv);

## free_exploded_string

Prototype : `char **free_exploded_string (t_weechat_plugin *plugin, char **chaine)`

Libère la mémoire utilisée pour une explosion de chaîne.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `chaine` : la chaîne explosée par la fonction "explode_string"

Valeur renvoyée : aucune.

Exemple :

    char *argv;
    int argc;
    argv = plugin->explode_string (plugin, chaine, " ", 0, &argc);
    ...
    if (argv != NULL)
        plugin->free_exploded_string (plugin, argv);

## mkdir_home

Prototype : `int mkdir_home (t_weechat_plugin *plugin, char *repertoire)`

Créé un répertoire dans le répertoire de base de WeeChat.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `repertoire` : répertoire à créer

Valeur renvoyée : 1 si le répertoire a été créé avec succès, 0 si une erreur s'est produite.

Example:

    if (!plugin->mkdir_home (plugin, "temp"))
        plugin->print_server(plugin, "Impossible de créer le répertoire 'temp' dans la base WeeChat.");

## exec_on_files

Prototype : `void exec_on_files (t_weechat_plugin *plugin, char *repertoire, int (*callback)(t_weechat_plugin *, char *))`

Exécute une fonction sur tous les fichiers d'un répertoire.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `repertoire` : le répertoire où les fichiers sont recherchés

- `callback` : une fonction appelée pour chaque fichier trouvé

Valeur renvoyée : aucune.

Exemple :

    int callback (t_weechat_plugin *plugin, char *fichier)
    {
        plugin->print_server (plugin, "fichier: %s", fichier);
        return 1;
    }
    ...
    plugin->exec_on_files (plugin, "/tmp", &callback);

## print

Prototype : `void print (t_weechat_plugin *plugin, char *serveur, char *canal, char *message, ...)`

Affiche un message sur un tampon WeeChat, identifié par le serveur et le canal (tous deux pouvant être NULL pour le tampon courant).

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `serveur` : nom interne du serveur pour trouver le tampon dans lequel afficher (peut être NULL)

- `canal` : nom du canal pour trouver le tampon dans lequel afficher (peut être NULL)

- `message` : message à afficher

Pour afficher du texte en couleur, il faut utiliser les codes suivants :

Code | Description
--- | ---
0x02 | texte gras
0x03 + "xx" | couleur du texte "`xx`" (voir pour les couleurs)
0x03 + "xx,yy" | couleur du texte "`xx`" et du fond "`yy`" (voir pour les couleurs)
0x0F | désactiver la couleur et tous les attributs
0x12 | vidéo inverse (inversion de la couleur d'écriture et du fond)
0x1F | texte souligné

NB: le même code (sans le numéro pour 0x03) peut être utilisé pour stopper l'attribut défini.

Valeur renvoyée : aucune.

Exemples :

    plugin->print (plugin, NULL, NULL, "hello");
    plugin->print (plugin, NULL, "#weechat", "hello");
    plugin->print (plugin, "freenode", "#weechat", "hello");
    plugin->print (plugin, "freenode", "#weechat", "hello");
    plugin->print (plugin, NULL, NULL,
                   "test: \x02 gras \x0F\x03%02d bleu \x03%02d vert",
                   plugin->get_irc_color (plugin, "blue"),
                   plugin->get_irc_color (plugin, "green"));

## print_server

Prototype : `void print_server (t_weechat_plugin *plugin, char *message, ...)`

Affiche un message sur le tampon du serveur courant.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `message` : message à afficher

Pour afficher du texte en couleur, voir .

Valeur renvoyée : aucune.

Exemple :

    plugin->print_server (plugin, "hello");

## log

Prototype : `void log (t_weechat_plugin *plugin, char *serveur, char *canal, char *message, ...)`

Ecrit un message dans le fichier de log pour un serveur ou un canal.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `serveur` : nom interne du serveur pour trouver le log du tampon (peut être NULL)

- `canal` : nom du canal pour trouver le tampon le log du tampon (peut être NULL)

- `message` : message

Valeur renvoyée : aucune.

Exemple :

    plugin->log (plugin, "freenode", "#weechat", "test");

## msg_handler_add

Prototype : `t_plugin_handler *msg_handler_add (t_weechat_plugin *plugin, char *message, t_plugin_handler_func *fonction, char *handler_args, void *handler_pointer)`

Ajoute un gestionnaire de messages IRC, appelé dès qu'un message IRC est reçu.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `message` : nom du message IRC pour lequel la fonction est appelée ("*" pour tous les messages). Pour connaître la liste des messages IRC disponibles, merci de consulter les RFCs 1459 et 2812. De plus, vous pouvez utiliser un nom spécial, préfixé par "weechat_" pour capturer des évènements spéciaux, comme décrit dans le tableau ci-dessous :

  Nom | Description
  --- | ---
  `weechat_pv` | message privé reçu
  `weechat_highlight` | message avec highlight (sur un canal ou en privé)
  `weechat_ctcp` | message CTCP reçu (VERSION, PING, etc...)
  `weechat_dcc` | message DCC reçu (discussion ou fichier)

- `fonction` : fonction appelée lorsque le message est reçu

  Elle a le prototype suivant : `int ma_fonction (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Le paramètre argc vaut 3 et les arguments suivants sont passés dans le tableau argv :

  - argv[0] = nom du serveur

  - argv[1] = message IRC

  - argv[2] = arguments de la commande

- `handler_args` : paramètres passés à la fonction appelée

- `handler_pointer` : pointeur passé à la fonction appelée

Valeur renvoyée : le pointeur vers le nouveau gestionnaire de messages.

Note : la fonction appelée lorsque le message est reçu doit renvoyer une des valeurs suivantes :

- `PLUGIN_RC_KO` : la fonction a échoué

- `PLUGIN_RC_OK` : la fonction a réussi

- `PLUGIN_RC_OK_IGNORE_WEECHAT` : le message ne sera pas transmis à WeeChat

- `PLUGIN_RC_OK_IGNORE_PLUGINS` : le message ne sera pas transmis à d'autres extensions

- `PLUGIN_RC_OK_IGNORE_ALL` : le message ne sera ni transmis à WeeChat ni à d'autres extensions

- `PLUGIN_RC_OK_WITH_HIGHLIGHT` : la fonction a réussi et provoque un "highlight" sur le message reçu

Exemple :

    int msg_kick (t_weechat_plugin *plugin, int argc, char **argv,
                  char *handler_args, void *handler_pointer)
    {
        plugin->print (plugin, argv[0], NULL, "KICK reçu");
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *msg_handler;
    msg_handler = plugin->msg_handler_add (plugin, "KICK",
                                           &msg_kick, NULL, NULL);

## cmd_handler_add

Prototype : `t_plugin_handler *cmd_handler_add (t_weechat_plugin *plugin, char *commande, char *description, char *arguments, char *arguments_description, char *modele_completion, t_plugin_handler_func *fonction, char *handler_args, void *handler_pointer)`

Ajoute un gestionnaire de commande WeeChat, appelé dès que l'utilisateur utilise la commande (par exemple /commande).

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `commande` : nom de la nouvelle commande, qui peut être une commande déjà existante (attention la commande remplacée ne sera plus disponible jusqu'à ce que l'extension soit déchargée)

- `description` : brève description de la commande (affichée par /help commande)

- `arguments` : brève description des paramètres de la commande (affichée par /help commande)

- `arguments_description` : longue description des paramètres de la commande (affichée par /help commande)

- `modele_completion` : modèle pour la complétion sous la forme "`abc|%w def|%i`" qui signifie "abc" ou une commande WeeChat pour le premier paramètre, et "def" ou une commande IRC pour le deuxième. Une chaîne vide indique à WeeChat de compléter tout paramètre avec un pseudo du canal courant, une valeur NULL ou égale à "-" désactive toute complétion pour tous les paramètres de la commande.

  Les codes suivants peuvent être utilisés :

  Code | Description
  --- | ---
  `%-` | aucune complétion pour le paramètre
  `%*` | répétition de la dernière complétion pour tous les paramètres suivants (ce code doit être à la fin du modèle de complétion, précédé d'un "|")
  `%a` | alias
  `%A` | alias et commandes (WeeChat, IRC et extensions)
  `%c` | canal courant
  `%C` | tous les canaux (y compris les privés)
  `%f` | nom de fichier
  `%h` | commandes définies par des extensions
  `%i` | commandes IRC (envoyées)
  `%I` | commandes IRC (reçues)
  `%k` | fonctions associées aux touches
  `%m` | pseudo sur le serveur courant
  `%M` | pseudos sur le serveur courant (tous les canaux ouverts)
  `%n` | pseudos du canal courant
  `%N` | pseudos et noms de machines du canal courant
  `%o` | options de configuration
  `%O` | options des extensions
  `%p` | message de "part" par défaut
  `%q` | message de "quit" par défaut
  `%s` | nom du serveur courant
  `%S` | tous les serveurs
  `%t` | titre du canal courant
  `%v` | valeur d'une option de configuration
  `%V` | valeur d'une option d'extension
  `%w` | commandes WeeChat

- `fonction` : fonction appelée lorsque la commande est exécutée.

  Elle a le prototype suivant : `int ma_fonction (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Le paramètre argc vaut 3 et les arguments suivants sont passés dans le tableau argv :

  - argv[0] = nom du serveur

  - argv[1] = commande

  - argv[2] = arguments de la commande

- `handler_args` : paramètres passés à la fonction appelée

- `handler_pointer` : pointeur passé à la fonction appelée

Valeur renvoyée : le pointeur vers le nouveau gestionnaire de commande.

Note : la fonction appelée lorsque la commande est exécutée doit renvoyer une des valeurs suivantes :

- `PLUGIN_RC_KO` : la fonction a échoué

- `PLUGIN_RC_OK` : la fonction a réussi

Exemple :

    int cmd_test (t_weechat_plugin *plugin, int argc, char **argv,
                  char *handler_args, void *handler_pointer)
    {
        plugin->print (plugin, argv[0], NULL,
                       "commande test, pseudo: %s",
                       (argv[2]) ? argv[2] : "aucun");
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *cmd_handler;
    cmd_handler = plugin->cmd_handler_add (plugin, "test", "Commande test",
                                           "[pesudo]", "pseudo: un pseudo du canal",
                                           "%n", &cmd_test, NULL, NULL);

## timer_handler_add

Prototype : `t_plugin_handler *timer_handler_add (t_weechat_plugin *plugin, int intervalle, t_plugin_handler_func *fonction, char *handler_args, void *handler_pointer)`

Ajoute un gestionnaire de temps, qui appelle périodiquement une fonction.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `intervalle` : intervalle (en secondes) entre deux appels de la fonction.

- `fonction` : fonction appelée

  Elle a le prototype suivant : `int ma_fonction (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Le paramètre argc vaut 0 et argv vaut NULL.

- `handler_args` : paramètres passés à la fonction appelée

- `handler_pointer` : pointeur passé à la fonction appelée

Valeur renvoyée : le pointeur vers le nouveau gestionnaire de temps.

Note : la fonction appelée doit renvoyer une des valeurs suivantes :

- `PLUGIN_RC_KO` : la fonction a échoué

- `PLUGIN_RC_OK` : la fonction a réussi

Exemple :

    int mon_timer (t_weechat_plugin *plugin, int argc, char **argv,
                   char *handler_args, void *handler_pointer)
    {
        plugin->print (plugin, NULL, NULL, "mon timer");
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *timer_handler;
    timer_handler = plugin->timer_handler_add (plugin, 60, &mon_timer);

## keyboard_handler_add

Prototype : `t_plugin_handler *keyboard_handler_add (t_weechat_plugin *plugin, t_plugin_handler_func *fonction, char *handler_args, void *handler_pointer)`

Ajoute un gestionnaire de clavier, appelé dès qu'une touche est pressée.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `fonction` : fonction appelée

  Elle a le prototype suivant : `int ma_fonction (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Le paramètre argc vaut 3 et les arguments suivants sont passés dans le tableau argv :

  - argv[0] = touche appuyée (nom d'une fonction interne ou bien '*' suivi du code d'une touche)

  - argv[1] = la ligne de commande avant l'action de la touche

  - argv[2] = la ligne de commande après l'action de la touche

- `handler_args` : paramètres passés à la fonction appelée

- `handler_pointer` : pointeur passé à la fonction appelée

Valeur renvoyée : le pointeur vers le nouveau gestionnaire de clavier.

Note : la fonction appelée doit renvoyer une des valeurs suivantes :

- `PLUGIN_RC_KO` : la fonction a échoué

- `PLUGIN_RC_OK` : la fonction a réussi

Exemple :

    int mon_keyb (t_weechat_plugin *plugin, int argc, char **argv,
                  char *handler_args, void *handler_pointer)
    {
        if (argc == 2)
        {
            plugin->print (plugin, NULL, NULL, "touche appuyée: %s", argv[0]);
            if (argv[1] && (argv[1][0] == '1'))
                plugin->print (plugin, NULL, NULL, "le texte d'entrée a changé");
            else
                plugin->print (plugin, NULL, NULL, "le texte d'entrée n'a pas changé");
        }
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *keyb_handler;
    keyb_handler = plugin->keyboard_handler_add (plugin, &mon_keyb);

## event_handler_add

Prototype : `t_plugin_handler *event_handler_add (t_weechat_plugin *plugin, char *evenement, t_plugin_handler_func *fonction, char *handler_args, void *handler_pointer)`

Ajoute un gestionnaire d'évènement, appelé dès qu'un évènement se produit.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `évènement` : évènement (voir le tableau ci-dessous)

- `fonction` : fonction appelée

  Elle a le prototype suivant : `int ma_fonction (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Les paramètres passés à la fonction dépendent de l'évènement (voir le tableau ci-dessous).

- `handler_args` : paramètres passés à la fonction appelée

- `handler_pointer` : pointeur passé à la fonction appelée

Liste des évènements :

Evènement | Description | Paramètres
--- | --- | ---
`buffer_open` | un tampon a été ouvert | argc = 1, argv = { numéro de tampon }
`buffer_close` | un tampon a été fermé | argc = 1, argv = { numéro de tampon }
`buffer_move` | un tampon a été déplacé | argc = 2, argv = { nouveau numéro de tampon, ancien numéro }

Valeur renvoyée : le pointeur vers le nouveau gestionnaire d'évènement.

Note : la fonction appelée doit renvoyer une des valeurs suivantes :

- `PLUGIN_RC_KO` : la fonction a échoué

- `PLUGIN_RC_OK` : la fonction a réussi

Exemple :

    int mon_evenement (t_weechat_plugin *plugin, int argc, char **argv,
                       char *handler_args, void *handler_pointer)
    {
        plugin->print (plugin, NULL, NULL, "mon_evenement");
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *event_handler;
    event_handler = plugin->event_handler_add (plugin, "buffer_open",
                                               &mon_evenement);

## handler_remove

Prototype : `void handler_remove (t_weechat_plugin *plugin, t_plugin_handler *handler)`

Supprime un gestionnaire de commande ou message.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `handler` : le gestionnaire à supprimer

Valeur renvoyée : aucune.

Exemple :

    plugin->handler_remove (plugin, mon_handler);

## handler_remove_all

Prototype : `void handler_remove_all (t_weechat_plugin *plugin)`

Supprime tous les gestionnaires d'une extension.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

Valeur renvoyée : aucune.

Exemple :

    plugin->handler_remove_all (plugin);

## modifier_add

Prototype : `t_plugin_modifier *modifier_add (t_weechat_plugin *plugin, char *type, char *message, t_plugin_modifier_func *fonction, char *modifier_args, void *modifier_pointer)`

Ajoute un modifieur de message.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `type` : type de modifieur :

  Type | Description
  --- | ---
  `irc_in` | appelé pour chaque message IRC reçu
  `irc_user` | appelé pour chaque message (ou commande) envoyé par l'utilisateur (avant traitement et affichage par WeeChat)
  `irc_out` | appelé pour chaque message sortant juste avant envoi au serveur IRC (y compris pour les messages envoyés automatiquement et de manière transparente par WeeChat)

- `message` : nom du message IRC pour lequel la fonction est appelée (utilisé uniquement pour les types "irc_in" et "irc_out"). Pour connaître la liste des messages IRC disponibles, merci de consulter les RFCs 1459 et 2812. La valeur spéciale "*" signifie tous les messages (pas de filtre).

- `fonction` : fonction appelée

  Elle a le prototype suivant : `char *ma_fonction (t_weechat_plugin *plugin, int argc, char **argv, char *modifier_args, void *modifier_pointer)`

  Le paramètre argc vaut 2 et les arguments suivants sont passés dans le tableau argv :

  - argv[0] = nom du serveur

  - argv[1] = message

- `modifier_args` : paramètres passés à la fonction appelée

- `modifier_pointer` : pointeur passé à la fonction appelée

Valeur renvoyée : le pointeur vers le nouveau modifieur de message.

Note : la fonction doit retourner une chaîne modifiée, ou NULL si elle ne souhaite pas modifier le message. Si elle retourne une chaine vide, alors le message est supprimé et ne sera pas traité du tout par WeeChat (soyez prudent en supprimant des messages !). La chaîne renvoyée doit avoir été allouée par malloc() et sera libérée (par appel à free()) automatiquement par WeeChat après utilisation.

Exemple :

    char *adder (t_weechat_plugin *plugin, int argc, char **argv,
                 char *modifier_args, void *modifier_pointer)
    {
        char *string;
        string = malloc (strlen (argv[1]) + 16);
        strcpy (string, argv[1]);
        strcat (string, "test");
        return string;
    }
    ...
    t_plugin_modifier *modifier;
    modifier = plugin->modifier_add (plugin, "irc_in", "privmsg",
                                     &adder, NULL, NULL);

## modifier_remove

Prototype : `void modifier_remove (t_weechat_plugin *plugin, t_plugin_modifier *modifier)`

Supprime un modifieur de message.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `modifier` : le modifieur à supprimer

Valeur renvoyée : aucune.

Exemple :

    plugin->modifier_remove (plugin, mon_modifier);

## modifier_remove_all

Prototype : `void modifier_remove_all (t_weechat_plugin *plugin)`

Supprime tous les modifieurs d'une extension.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

Valeur renvoyée : aucune.

Exemple :

    plugin->modifier_remove_all (plugin);

## exec_command

Prototype : `void exec_command (t_weechat_plugin *plugin, char *serveur, char *canal, char *commande)`

Execute une commande WeeChat ou envoie un message à un canal.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `serveur` : nom interne du serveur où exécuter la commande (peut être NULL)

- `canal` : nom du canal où exécuter la commande (peut être NULL)

- `commande` : la commande à exécuter

Valeur renvoyée : aucune.

Exemples :

    plugin->exec_command (plugin, NULL, NULL, "/help nick");
    plugin->exec_command (plugin, "freenode", "#weechat", "bonjour");

## get_info

Prototype : `char *get_info (t_weechat_plugin *plugin, char *info, char *serveur)`

Renvoie une information sur WeeChat ou un canal.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `info` : nom de l'info à obtenir :

  Info | Description
  --- | ---
  `version` | version de WeeChat
  `nick` | pesudo
  `channel` | nom du canal (NULL pour un serveur ou un privé)
  `server` | nom du serveur
  `type` | type de tampon: 0=standard, 1=DCC, 2=données IRC brutes
  `away` | drapeau "away"
  `inactivity` | nombre de secondes écoulées depuis que la dernière touche a été appuyée
  `input` | contenu de la ligne de commande de la fenêtre courante
  `input_mask` | contenu du masque de couleur de la ligne de commande
  `input_pos` | position du curseur dans la ligne de commande
  `weechat_dir` | répertoire de base de WeeChat (par défaut: ~/.weechat/)
  `weechat_libdir` | répertoire "lib" système de WeeChat
  `weechat_sharedir` | répertoire "share" système de WeeChat

- `serveur` : nom interne du serveur où récupérer l'information (si nécessaire)

Valeur renvoyée : l'information recherchée, NULL si non trouvée.

Note : le résultat doit être libéré par un appel à la fonction "free" après utilisation.

Exemples :

    char *version = plugin->get_info (plugin, "version", NULL);
    char *nick = plugin->get_info (plugin, "nick", "freenode");
    char *inactivity = plugin->get_info (plugin, "inactivity", NULL);

    plugin->print (plugin, NULL, NULL,
                   "WeeChat version %s, vous êtes %s sur freenode "
                   "(inactif depuis %s secondes)",
                   version, nick, inactivity);

    if (version)
        free (version);
    if (nick)
        free (nick);
    if (inactivity)
        free (inactivity);

## get_dcc_info

Prototype : `t_plugin_info_dcc *get_dcc_info (t_weechat_plugin *plugin)`

Renvoie la liste des DCC en cours ou terminés.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

Valeur renvoyée : la liste chaînée des DCC.

Type | Champ | Description
--- | --- | ---
char * | `server` | le serveur IRC
char * | `channel` | le canal IRC
int | `type` | le type de DCC : 0 = discussion reçue, 1 = discussion envoyée, 2 = fichier reçu, 3 = fichier envoyé
int | `status` | le statut du DCC : 0 = en attente, 1 = en cours de connexion, 2 = actif, 3 = terminé, 4 = échoué, 5 = interrompu par l'utilisateur
time_t | `start_time` | la date et heure de création du DCC
time_t | `start_transfer` | la date et heure de démarrage du transfert
unsigned long | `addr` | adresse IP de l'utilisateur distant
int | `port` | port utilisé pour le DCC
char * | `nick` | pseudo de l'utilisateur distant
char * | `filename` | nom de fichier
char * | `local_filename` | nom de fichier local
int | `filename_suffix` | suffixe si renommage de fichier
unsigned long | `size` | taille du fichier
unsigned long | `pos` | position actuelle dans le fichier
unsigned long | `start_resume` | position de démarrage après une interruption
unsigned long | `bytes_per_sec` | nombre d'octets transmis par seconde depuis le début du transfert
t_plugin_dcc_info * | `prev_dcc` | pointeur vers l'info DCC précédente
t_plugin_dcc_info * | `next_dcc` | pointeur vers l'info DCC suivante

Note : le résultat doit être libéré par un appel à la fonction "free_dcc_info" après utilisation.

Exemples :

    t_plugin_dcc_info *dcc_info = plugin->get_dcc_info (plugin);
    for (ptr_dcc = dcc_info; ptr_dcc; ptr_dcc = ptr_dcc->next_dcc)
    {
        plugin->print_server (plugin, "DCC type=%d, avec: %s",
                              ptr_dcc->type, ptr_dcc->nick);
    }
    if (dcc_info)
        plugin->free_dcc_info (plugin, dcc_info);

## free_dcc_info

Prototype : `void free_dcc_info (t_weechat_plugin *plugin, t_plugin_dcc_info *dcc_info)`

Libère la mémoire utilisée par une liste de DCC.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `dcc_info` : pointeur vers la liste DCC renvoyée par la fonction "get_dcc_info"

Valeur renvoyée : aucune.

Exemple :

    plugin->free_dcc_info (plugin, dcc_info);

## get_server_info

Prototype : `t_plugin_server_info *get_server_info (t_weechat_plugin *plugin)`

Renvoie la liste des serveurs IRC (connectés ou non).

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

Valeur retournée : la liste chaînée des serveurs IRC.

Type | Champ | Description
--- | --- | ---
char * | `name` | nom interne du serveur
int | `autoconnect` | 1 si auto-connexion au démarrage, 0 sinon
int | `autoreconnect` | 1 si auto-reconnexion quand déconnecté, 0 sinon
int | `autoreconnect_delay` | délai avant de tenter une reconnexion
int | `command_line` | 1 si le serveur vient de la ligne de commande (donc temporaire), 0 sinon
char * | `address` | adresse du serveur (nom ou IP)
int | `port` | port
int | `ipv6` | connexion IPv6
int | `ssl` | connexion SSL
char * | `password` | mot de passe pour le serveur
char * | `nick1` | premier pseudo
char * | `nick2` | pseudo alternatif
char * | `nick3` | second pseudo alternatif
char * | `username` | nom d'utilisateur
char * | `real name` | nom réel
char * | `command` | commande exécutée une fois connecté
int | `command_delay` | délai après exécution de la commande
char * | `autojoin` | canaux joints automatiquement
int | `autorejoin` | 1 si les canaux sont rejoints après un "kick", 0 sinon
char * | `notify_levels` | niveaux de notification des canaux
char * | `charset_decode_iso` | jeux de caractères de décodage ISO pour les canaux
char * | `charset_decode_utf` | jeux de caractères de décodage UTF pour les canaux
char * | `charset_encode` | jeux de caractères d'encodage pour les canaux
int | `is_connected` | 1 si connecté au serveur, 0 sinon
int | `ssl_connected` | 1 si connecté via SSL, 0 sinon
char * | `nick` | pseudo courant
int | `is_away` | 1 si absent, 0 sinon
time_t | `away_time` | date/heure à laquelle l'utilisateur a été marqué absent
int | `lag` | lag (en millisecondes)
t_plugin_server_info * | `prev_server` | pointeur vers les infos du serveur précédent
t_plugin_server_info * | `next_server` | pointeur vers les infos du serveur suivant

Note : le résultat doit être libéré par un appel à la fonction "free_server_info" après utilisation.

Exemple :

    t_plugin_server_info *server_info, *ptr_server_info;
    server_info = plugin->get_server_info (plugin);
    if (server_info)
    {
        for (ptr_server_info = server_info; ptr_server_info;
             ptr_server_info = ptr_server_info->next_server)
        {
            plugin->print (plugin, NULL, NULL,
                           "serveur: %s, addresse: %s, port: %d %s",
                           ptr_server_info->name,
                           ptr_server_info->address,
                           ptr_server_info->port,
                           (ptr_server_info->is_connected) ? "(connecté)" : "");
        }
        plugin->free_server_info (plugin, server_info);
    }

## free_server_info

Prototype : `void free_server_info (t_weechat_plugin *plugin, t_plugin_server_info *server_info)`

Libère la mémoire utilisée par une liste de serveurs.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `server_info` : pointeur vers la liste de serveurs retournée par la fonction "get_server_info"

Valeur renvoyée : aucune.

Exemple :

    plugin->free_server_info (plugin, server_info);

## get_channel_info

Prototype : `t_plugin_channel_info *get_channel_info (t_weechat_plugin *plugin, char *serveur)`

Renvoie la liste des canaux IRC pour un serveur.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `serveur` : nom interne du serveur

Valeur renvoyée : la liste chaînée des canaux IRC du serveur.

Type | Field | Description
--- | --- | ---
int | `type` | 0 pour un canal, 1 pour un privé
char * | `name` | nom du canal
char * | `topic` | titre du canal
char * | `modes` | modes du canal
int | `limit` | limite d'utilisateurs
char * | `key` | clé du canal
int | `nicks_count` | nombre de pseudos présents sur le canal
t_plugin_channel_info * | `prev_channel` | pointeur vers les infos du canal précédent
t_plugin_channel_info * | `next_channel` | pointeur vers les infos du canal suivant

Note : le résultat doit être libéré par un appel à la fonction "free_channel_info" après utilisation.

Exemple :

    t_plugin_channel_info *channel_info, *ptr_chan_info;
    channel_info = plugin->get_channel_info (plugin, "freenode");
    if (channel_info)
    {
        for (ptr_chan_info = channel_info; ptr_chan_info;
             ptr_chan_info = ptr_chan_info->next_channel)
        {
            plugin->print (plugin, NULL, NULL,
                           "  %s (type %d)",
                           ptr_chan_info->name,
                           ptr_chan_info->type);
        }
        plugin->free_channel_info (plugin, channel_info);
    }

## free_channel_info

Prototype : `void free_channel_info (t_weechat_plugin *plugin, t_plugin_channel_info *channel_info)`

Libère la mémoire utilisée par une liste de canaux.

Arguments:

- `plugin` : pointeur vers la structure de l'extension

- `channel_info` : pointeur vers la liste de canaux retournée par la fonction "get_channel_info"

Valeur renvoyée : aucune.

Exemple :

    plugin->free_channel_info (plugin, channel_info);

## get_nick_info

Prototype : `t_plugin_nick_info *get_nick_info (t_weechat_plugin *plugin, char *serveur, char *canal)`

Renvoie la liste des pseudos pour un canal.

Arguments:

- `plugin` : pointeur vers la structure de l'extension

- `serveur` : nom interne du serveur

- `canal` : nom du canal

Valeur renvoyée : la liste chaînée des pseudos présents sur le canal.

Type | Champ | Description
--- | --- | ---
char * | `nick` | pseudo
char * | `host` | nom de machine
int | `flags` | propriétés du pseudo, "ou" binaire entre plusieurs valeurs (1 =propriétaire du canal, 2 = administrateur du canal, 4 = op, 8 = demi-op, 16 = voix, 32 = absent)
t_plugin_nick_info * | `prev_nick` | pointeur vers les infos du pseudo précédent
t_plugin_nick_info * | `next_nick` | pointeur vers les infos du pseudo précédent

Note : le résultat doit être libéré par un appel à la fonction "free_nick_info" après utilisation.

Exemple :

    t_plugin_nick_info *nick_info, *ptr_nick_info;
    nick_info = plugin->get_nick_info (plugin, "freenode", "#weechat");
    if (nick_info)
    {
        for (ptr_nick_info = nick_info; ptr_nick_info;
             ptr_nick_info = ptr_nick_info->next_nick)
        {
            plugin->print (plugin, NULL, NULL,
                           "  %s (flags: %d)",
                           ptr_nick_info->nick,
                           ptr_nick_info->flags);
        }
        plugin->free_nick_info (plugin, nick_info);
    }

## free_nick_info

Prototype : `void free_nick_info (t_weechat_plugin *plugin, t_plugin_nick_info *nick_info)`

Libère la mémoire utilisée par une liste de pseudos.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `nick_info` : pointeur vers la liste de pseudos retournée par la fonction "get_nick_info"

Valeur renvoyée : aucune.

Exemple :

    plugin->free_nick_info (plugin, nick_info);

## get_config

Prototype : `char *get_config (t_weechat_plugin *plugin, char *option)`

Renvoie la valeur d'une option de configuration WeeChat.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `option` : nom de l'option à lire

Valeur renvoyée : la valeur de l'option, NULL si non trouvée.

Note : le résultat doit être libéré par un appel à la fonction "free" après utilisation.

Exemples :

    char *value1 = plugin->get_config (plugin, "look_set_title");
    char *value2 = plugin->get_config (plugin, "freenode.server_autojoin");

## set_config

Prototype : `int set_config (t_weechat_plugin *plugin, char *option, char *valeur)`

Modifie la valeur d'une option de configuration WeeChat.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `option` : nom de l'option à mettre à jour

- `valeur` : nouvelle valeur pour l'option

Valeur renvoyée : 1 si l'option a été modifiée avec succès, 0 si une erreur s'est produite.

Exemple :

    plugin->set_config (plugin, "look_nicklist", "off");

## get_plugin_config

Prototype : `char *get_plugin_config (t_weechat_plugin *plugin, char *option)`

Renvoie la valeur d'une option de l'extension. L'option est lue depuis le fichier "`~/.weechat/plugins.rc`" et est sous cette forme : "`extension.option=valeur`" (NB : le nom de l'extension est ajouté automatiquement).

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `option` : nom de l'option à lire

Valeur renvoyée : la valeur de l'option, NULL si non trouvée.

Note : le résultat doit être libéré par un appel à la fonction "free" après utilisation.

Exemple :

    char *value = plugin->get_plugin_config (plugin, "ma_variable");

## set_plugin_config

Prototype : `int set_plugin_config (t_weechat_plugin *plugin, char *option, char *valeur)`

Modifie la valeur d'une option de l'extension. L'option est écrite dans le fichier "`~/.weechat/plugins.rc`" et est sous cette forme : "`extension.option=valeur`" (NB : le nom de l'extension est ajouté automatiquement).

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `option` : nom de l'option à mettre à jour

- `valeur` : nouvelle valeur pour l'option

Valeur renvoyée : 1 si l'option a été modifiée avec succès, 0 si une erreur s'est produite.

Exemple :

    plugin->set_plugin_config (plugin, "ma_variable", "valeur");

## get_irc_color

Prototype : `int get_irc_color (t_weechat_plugin *plugin, char *nom_couleur)`

Renvoie le numéro d'une couleur IRC avec son nom.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `nom_couleur` : nom de la couleur Les couleure autorisées sont :

  Nom couleur | Valeur
  --- | ---
  white | 0
  black | 1
  blue | 2
  green | 3
  lightred | 4
  red | 5
  magenta | 6
  brown | 7
  yellow | 8
  lightgreen | 9
  cyan | 10
  lightcyan | 11
  lightblue | 12
  lightmagenta | 13
  gray | 14
  lightgray | 15

Valeur renvoyée : numéro de la couleur IRC, -1 si la couleur n'est pas trouvée.

Exemple :

    int color_blue = plugin->get_irc_color (plugin, "blue"); /* retourne 2 */

## input_color

Prototype : `void input_color (t_weechat_plugin *plugin, int couleur, int debut, int longueur)`

Ajoute de la couleur dans la zone de saisie.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `couleur` : couleur pour le texte (si < 0, alors la zone de saisie est rafraichie, et il n'y a aucun changement dans son contenu)

- `debut` : position de début pour la coloration (si < 0, alors le masque est réinitialisé)

- `longueur` : longueur pour la coloration (si <= 0, alors le masque est réinitialisé)

Valeur renvoyée : aucune.

Exemple :

    plugin->input_color (plugin, plugin->get_irc_color (plugin, "blue"), 10, 5);

## get_window_info

Prototype : `t_plugin_window_info *get_window_info (t_weechat_plugin *plugin)`

Retourne la liste des fenêtres WeeChat.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

Valeur renvoyée : liste chaînée des fenêtres WeeChat.

Type | Champ | Description
--- | --- | ---
int | `win_x` | position horizontale de la fenêtre
int | `win_y` | position verticale de la fenêtre
int | `win_width` | largeur de la fenêtre
int | `win_height` | hauteur de la fenêtre
int | `win_width_pct` | largeur en % (comparé à la fenêtre parent)
int | `win_height_pct` | hauteur en % (comparé à la fenêtre parent)
int | `num_buffer` | numéro du tampon affiché
t_plugin_window_info * | `prev_window` | pointeur vers les infos de la fenêtre précédente
t_plugin_window_info * | `next_window` | pointeur vers les infos de la fenêtre suivante

Note : le résultat doit être libéré par un appel à la fonction "free_window_info" après utilisation.

Exemple :

    t_plugin_window_info *window_info, *ptr_window;

    window_info = plugin->get_window_info (plugin);
    if (window_info)
    {
        for (ptr_window = window_info; ptr_window; ptr_window = ptr_window->next_window)
        {
            plugin->print (plugin, NULL, NULL, "--- info fenêtre ---");
            plugin->print (plugin, NULL, NULL, "(%d,%d), size: %dx%d, %%size: %d%%x%d%%",
                           ptr_window->win_x, ptr_window->win_y,
                           ptr_window->win_width, ptr_window->win_height,
                           ptr_window->win_width_pct, ptr_window->win_height_pct);
            plugin->print (plugin, NULL, NULL, "num_buffer: %d", ptr_window->num_buffer);
        }
        plugin->free_window_info (plugin, window_info);
    }
    else
        plugin->print (plugin, NULL, NULL, "pas d'info fenêtre !");

## free_window_info

Prototype : `void free_window_info (t_weechat_plugin *plugin, t_plugin_window_info *window_info)`

Libère la mémoire utilisée par une liste de fenêtres.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `window_info` : pointeur vers la liste des infos fenêtres retournée par la fonction "get_window_info"

Valeur renvoyée : aucune.

Exemple :

    plugin->free_window_info (plugin, window_info);

## get_buffer_info

Prototype : `t_plugin_buffer_info *get_buffer_info (t_weechat_plugin *plugin)`

Retourne la liste des tampons WeeChat.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

Valeur renvoyée : liste chaînée des tampons WeeChat.

Type | Champ | Description
--- | --- | ---
int | `type` | type de tampon: 0=standard, 1=DCC, 2=données IRC brutes
int | `number` | numéro de tampon
int | `num_displayed` | nombre de fenêtres affichant ce tampon
char * | `server_name` | nom du serveur pour le tampon (peut être NULL)
char * | `channel_name` | nom du canal pout le tampon (peut être NULL)
int | `notify_level` | niveau de notification du tampon
char * | `log_filename` | nom du fichier de log (NULL signifie qu'il n'y a pas de log)
t_plugin_buffer_info * | `prev_buffer` | pointeur vers les infos du tampon précédent
t_plugin_buffer_info * | `next_buffer` | pointeur vers les infos du tampon suivant

Note : le résultat doit être libéré par un appel à la fonction "free_buffer_info" après utilisation.

Exemple :

    t_plugin_buffer_info *buffer_info, *ptr_buffer;

    buffer_info = plugin->get_buffer_info (plugin);
    if (buffer_info)
    {
        for (ptr_buffer = buffer_info; ptr_buffer; ptr_buffer = ptr_buffer->next_buffer)
        {
            plugin->print (plugin, NULL, NULL, "--- info tampon ---");
            plugin->print (plugin, NULL, NULL, "type: %d", ptr_buffer->type);
            plugin->print (plugin, NULL, NULL, "number: %d", ptr_buffer->number);
            plugin->print (plugin, NULL, NULL, "num_displayed: %d", ptr_buffer->num_displayed);
            plugin->print (plugin, NULL, NULL, "server: %s", ptr_buffer->server_name);
            plugin->print (plugin, NULL, NULL, "channel: %s", ptr_buffer->channel_name);
            plugin->print (plugin, NULL, NULL, "notify level: %d", ptr_buffer->notify_level);
            plugin->print (plugin, NULL, NULL, "log filename: %s", ptr_buffer->log_filename);
        }
        plugin->free_buffer_info (plugin, buffer_info);
    }
    else
        plugin->print (plugin, NULL, NULL, "pas d'info tampon !");

## free_buffer_info

Prototype: `void free_buffer_info (t_weechat_plugin *plugin, t_plugin_buffer_info *buffer_info)`

Libère la mémoire utilisée par une liste de tampons.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `buffer_info` : pointeur vers la liste des infos tampons retournée par la fonction "get_buffer_info"

Valeur renvoyée : aucune.

Exemple :

    plugin->free_buffer_info (plugin, buffer_info);

## get_buffer_data

Prototype: `t_plugin_buffer_data *get_buffer_info (t_weechat_plugin *plugin, char *serveur, char *canal)`

Renvoie le contenu du tampon.

Paramètres :

- `plugin` : pointeur vers la structure de l'extension

- `serveur` : nom interne du serveur

- `canal` : nom du canal

Valeur renvoyée : contenu du tampon (liste chaînée de lignes).

Type | Champ | Description
--- | --- | ---
time_t | `date` | date et heure
char * | `nick` | pseudo
char * | `data` | contenu de la ligne (les codes couleur sont retirés)
t_plugin_buffer_line * | `prev_line` | pointeur vers la ligne précédente
t_plugin_buffer_line * | `next_line` | pointeur vers la ligne suivante

Note : le résultat doit être libéré par un appel à la fonction "free_buffer_data" après utilisation.

Exemple :

    t_plugin_buffer_line *buffer_line, *ptr_line;
    char text_time[256];

    buffer_line = plugin->get_buffer_data (plugin);
    if (buffer_line)
    {
        for (ptr_line = buffer_line; ptr_line; ptr_line = ptr_line->next_line)
        {
            strftime (text_time, sizeof (text_time), "%x %X", localtime (&(ptr_line->date)));
            plugin->print (plugin, NULL, NULL, "date: %s, pseudo: %s, données: %s",
                           text_time, ptr_line->nick, ptr_line->data);
        }
        plugin->free_buffer_data (plugin, buffer_line);
    }

## free_buffer_data

Prototype: `void free_buffer_data (t_weechat_plugin *plugin, t_plugin_buffer_line *buffer_line)`

Libère la mémoire utilisée par les lignes d'un tampon.

Arguments:

- `plugin` : pointeur vers la structure de l'extension

- `buffer_line` : pointeur vers la liste des lignes du tampon retournée par la fonction "get_buffer_data"

Valeur renvoyée : aucune.

Exemple :

    plugin->free_buffer_data (plugin, buffer_line);