]> Client IRC rapide, léger et extensible Sébastien Helleu flashcode AT flashtux.org &date.xml; 2006 Sébastien Helleu This manual is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Ce manuel documente le client IRC WeeChat, il fait partie de WeeChat. La dernière version de ce document peut être téléchargée sur cette page : http://weechat.flashtux.org/doc.php Ce chapitre décrit WeeChat et les pré-requis pour son installation.

WeeChat (Wee Enhanced Environment for Chat) est un client IRC libre, rapide et léger, conçu pour différents systèmes d'exploitation. Ses principales caractéristiques sont les suivantes : connexion multi-serveurs (avec SSL, IPv6, proxy) plusieurs interfaces : Curses, wxWidgets, Gtk et Qt petit, rapide et léger paramétrable et extensible avec des extensions et des scripts conforme aux RFCs 1459, 2810, 2811, 2812 et 2813 multi plates-formes (GNU/L'index, *BSD, MacOS X, Windows et d'autres systèmes) 100% GPL, logiciel libre La page d'accueil de WeeChat est ici : http://weechat.flashtux.org

Pour installer WeeChat, vous devez avoir : un système GNU/Linux (avec le compilateur et les outils associés pour le paquet des sources) droits "root" (pour installer WeeChat) selon l'interface, une des bibliothèques suivantes : Curses : la bibliothèque ncurses Gtk : *** interface non développée *** WxWidgets : *** interface non développée *** Qt : *** interface non développée ***

Ce chapitre explique comment installer WeeChat.

Les paquets binaires sont disponibles pour les distributions suivantes : Debian (ou toute distribution compatible Debian) : apt-get install weechat Mandriva/RedHat (ou toute distribution compatible avec les RPM) : rpm -i /chemin/weechat-x.y.z-1.i386.rpm Gentoo : emerge weechat Pour les autres distributions supportées, merci de vous référer au manuel de la distribution pour la méthode d'installation.

Tapez simplement dans une console ou un terminal : $ ./configure $ make Obtenez les droits root et installez WeeChat : $ su (entrez le mot de passe root) # make install

Attention : les sources CVS sont réservés aux utilisateurs avancés : il se peut que WeeChat ne compile pas et qu'il soit très instable. Vous êtes prévenus ! Pour récupérer les sources CVS, tapez cette commande : $ cvs -z3 -d:pserver:anonymous@cvs.savannah.nongnu.org:/sources/weechat co weechat Exécutez ce script : ./autogen.sh Suivez alors les instructions du paquet source (voir )

Ce chapitre explique comment lancer WeeChat, les touches utilisées par défaut, les commandes internes et IRC, le fichier de configuration et l'utilisation du tube FIFO.

Paramètres de ligne de commande : Paramètre Description -a, --no-connect Supprimer la connexion automatique aux serveurs lors du démarrage -c, --config Afficher l'aide sur le fichier de config (liste des options) -d, --dir <répertoire> Définir le répertoire comme étant la base de WeeChat (utilisé pour les fichiers de configuration, logs, extensions et scripts de l'utilisateur). La valeur par défaut est "~/.weechat". NB: le répertoire est créé s'il n'est pas trouvé par WeeChat. -f, --key-functions Afficher la liste des fonctions internes WeeChat pour les touches -h, --help Afficher l'aide -i, --irc-commands Afficher la liste des commandes IRC -k, --keys Afficher les touches par défaut de WeeChat -l, --license Afficher la licence de WeeChat -p, --no-plugin Supprimer le chargement automatique des extensions au démarrage -v, --version Afficher la version de WeeChat -w, --weechat-commands Afficher la liste des commandes WeeChat Il est également possible de passer une URL pour un ou plusieurs serveurs IRC, de la forme : irc[6][s]://[pseudo[:mot_passe]@]irc.exemple.org[:port][/canal][,canal[...] Exemple pour rejoindre #weechat et #toto sur le serveur "irc.freenode.net", port par défaut (6667), sous le pseudo "nono" : $ weechat-curses irc://nono@irc.freenode.net/#weechat,#toto Pour lancer WeeChat, tapez cette commande : pour l'interface Curses : weechat-curses pour l'interface Gtk : weechat-gtk pour l'interface wxWidgets : weechat-wxwidgets pour l'interface Qt : weechat-qt Lorsque vous lancez WeeChat pour la première fois, un fichier de configuration par défaut est créé, avec les options par défaut. Le fichier de configuration par défaut est : "~/.weechat/weechat.rc" Vous pouvez éditer ce fichier pour configurer WeeChat à votre convenance (SEULEMENT si WeeChat ne tourne pas), ou vous pouvez modifier les paramètres dans WeeChat avec la commande "/set" (voir )

Touche Action Flèche gauche Aller au caractère précédent sur la ligne de commande Flèche droite Aller au caractère suivant sur la ligne de commande Ctrl + flèche gauche Aller au mot précédent sur la ligne de commande Ctrl + flèche droite Aller au mot suivant sur la ligne de commande Home / Ctrl + A Aller au début de la ligne de commande End / Ctrl + E Aller à la fin de la ligne de commande Ctrl + K Effacer du curseur jusqu'à la fin de la ligne de commande Ctrl + L Réafficher toute la fenêtre Ctrl + U Effacer du curseur jusqu'au début de la ligne de commande Ctrl + W Effacer le mot précédent sur la ligne de commande Backspace Effacer le caractère précédent sur la ligne de commande Delete Effacer le caractère suivant sur la ligne de commande Tab Compléter la commande ou le pseudo (Tab de nouveau: trouver la complétion suivante) Tout caractère Insérer le caractère à la position du curseur sur la ligne de commande Entrée Exécuter la commande ou envoyer le message Flèche haut / flèche bas Rappeler les dernières commandes ou messages Ctrl + flèche haut / Ctrl + flèche bas Rappeler les dernières commandes ou messages dans l'historique global (commun à tous les tampons) PageUp / PageDown Monter / descendre d'une page dans l'historique du tampon Alt + PageUp / Alt + PageDown Monter / descendre de quelques lignes dans l'historique du tampon Alt + Home / Alt + End Aller au début / à la fin du tampon F5 / Alt + flèche gauche Aller au tampon précédent F6 / Alt + flèche droite Aller au tampon suivant F7 Aller à la fenêtre précédente F8 Aller à la fenêtre suivante F10 Effacer le dernier message de la barre d'informations F11 / F12 Faire défiler la liste des pseudos Alt + F11 / Alt + F12 Aller au début / à la fin de la liste des pseudos Alt + A Sauter au prochain tampon avec activité (avec priorité : highlight, message, autre) Alt + B Aller au mot précédent Alt + D Effacer le mot suivant Alt + F Aller au mot suivant Alt + H Vider la hotlist (notification d'activité sur les autres tampons) Alt + J puis Alt + D Afficher le tampon des DCC Alt + J puis Alt + L Sauter au dernier tampon Alt + J puis Alt + R Sauter au tampon de données brutes IRC Alt + J puis Alt + S Sauter au tampon du serveur Alt + J puis Alt + X Sauter au premier canal du serveur suivant (ou tampon du serveur si aucun canal n'est ouvert) Alt + chiffre (0-9) Sauter au tampon qui porte ce numéro (0 = 10) Alt + J puis nombre (01-99) Sauter au tampon qui porte ce numéro Alt + K Capturer une touche et insérer son code sur la ligne de commande Alt + N Se positionner sur le highlight suivant Alt + P Se positionner sur le highlight précédent Alt + R Effacer entièrement la ligne de commande Alt + S Changer de serveur sur le tampon des serveurs (si l'option "look_one_server_buffer" est activée) Alt + U Se positionner sur la première ligne non lue du tampon Alt + W puis Alt + flèche Sauter à une fenêtre avec une direction

La ligne de commande WeeChat (située en bas de la fenêtre) permet d'envoyer du texte sur les canaux et d'exécuter des commandes WeeChat ou IRC (voir ). Les commandes débutent par un caractère "/", suivi du nom de la commande. Par exemple pour initier une conversation privée avec "toto" : /query toto Le texte envoyé à un canal est tout texte ne commençant pas par le caractère "/", par exemple pour envoyer "bonjour" sur le canal courant : bonjour Il est cependant possible de faire débuter un texte par "/" en le doublant. Par exemple pour envoyer le texte "/query toto" sur le canal courant : //query toto Si l'option d'envoi des couleurs IRC ("irc_colors_send") est activée, il est possible d'utiliser des codes couleur et attributs comme suit : Code Description %B texte gras %Cxx couleur du texte "xx" (voir le tableau des couleurs ci-dessous) %Cxx,yy couleur du texte "xx" et du fond "yy" (voir le tableau des couleurs ci-dessous) %O désactiver la couleur et tous les attributs %R vidéo inverse (inversion de la couleur d'écriture et du fond) %U texte souligné %% afficher un seul "%" NB: le même code (sans le numéro pour %C) peut être utilisé pour stopper l'attribut défini. Les codes couleur pour %C sont : Code Couleur 00 blanc 01 noir 02 bleu foncé 03 vert foncé 04 rouge clair 05 rouge foncé 06 magenta 07 orange 08 jaune 09 vert clair 10 cyan 11 cyan clair 12 bleu clair 13 magenta clair 14 gris 15 gris clair (blanc) Exemple : affichage de "bonjour tout le monde !" avec "bonjour" en bleu clair gras, et "tout le monde" en rouge clair souligné : %C12%Bbonjour%B%C04%U tout le monde%U%C !

Ce chapitre liste toutes les commandes WeeChat et IRC.

&weechat_commands.xml;

Fonction Description &key_functions.xml;

&irc_commands.xml;

Liste des options du fichier de configuration : Option Type Valeurs Défaut Description &config.xml; Les couleurs pour l'interface Curses sont : Mot clé Couleur default couleur par défaut (transparent pour le fond) black noir red rouge foncé lightred rouge clair green vert foncé lightgreen vert clair brown marron yellow jaune blue bleu foncé lightblue bleu clair magenta violet foncé lightmagenta violet clair cyan cyan foncé lightcyan cyan clair white blanc

Vous pouvez contrôler WeeChat à distance, en envoyant des commandes ou du texte dans un tube FIFO (l'option "irc_fifo_pipe" doit être activée, elle est désactivée par défaut). Le tube FIFO est dans le répertoire "~/.weechat/" et s'appelle "weechat_fifo_xxxxx" (où xxxxx est l'ID du processus (PID) du WeeChat qui tourne). Donc si plusieurs WeeChat tournent, il y a plusieurs tubes FIFO, un pour chaque session. La syntaxe pour envoyer des commandes ou du texte dans le tube FIFO est la suivante : serveur,canal *texte ou commande ici où le serveur et le canal sont facultatifs, mais si le canal est là, le serveur doit l'être aussi. Quelques exemples : changement du pseudo sur freenode en "pseudo|absent" : $ echo 'freenode */nick pseudo|absent' >~/.weechat/weechat_fifo_12345 affichage de texte sur le canal #weechat : $ echo 'freenode,#weechat *bonjour tout le monde !' >~/.weechat/weechat_fifo_12345 affichage de texte sur le canal courant (le tampon affiché par WeeChat) : $ echo '*bonjour !' >~/.weechat/weechat_fifo_12345 Attention : ceci est dangereux et vous ne devriez pas le faire sauf si vous savez ce que vous faites ! envoyer deux commandes pour décharger/recharger les scripts Perl (vous devez les séparer par "\n") : $ echo -e "freenode */perl unload\nfreenode */perl autoload" >~/.weechat/weechat_fifo_12345 Vous pouvez écrire un script qui envoie les commandes à tous les WeeChat qui tournent en même temps, par exemple : #!/bin/sh if [ $# -eq 1 ]; then for fifo in $(/bin/ls ~/.weechat/weechat_fifo_* 2>/dev/null); do echo -e "$1" >$fifo done fi Si le script s'appelle "auto_weechat_command", vous pouvez le lancer ainsi : $ ./auto_weechat_command "freenode,#weechat *bonjour"

Ce chapitre décrit l'interface des extensions (API) et les extensions pour scripts (Perl, Python, Ruby, Lua), fournies avec WeeChat.

Une extension ("plugin" en anglais) est un programme écrit en C qui peut appeler des fonctions de WeeChat définies dans une interface. Ce programme C n'a pas besoin des sources WeeChat pour être compilé et peut être chargé/déchargé dynamiquement dans WeeChat via la commande /plugin. L'extension doit être au format bibliothèque, chargeable dynamiquement par le système d'exploitation. Sous GNU/Linux, il s'agit d'un fichier ayant pour extension ".so", sous Windows ".dll".

L'extension doit inclure le fichier "weechat-plugin.h" (disponible dans les sources de WeeChat). Ce fichier définit les structures et types dont l'extension aura besoin pour communiquer avec WeeChat. L'extension doit comporter certaines variables et fonctions obligatoires (sans quoi l'extension ne peut être chargée) : Variable Description char plugin_name[] le nom de l'extension char plugin_version[] la version de l'extension char plugin_description[] une courte description de l'extension Fonction Description int weechat_plugin_init (t_weechat_plugin *plugin) fonction appelée au chargement de l'extension qui doit renvoyer PLUGIN_RC_OK en cas de succès, PLUGIN_RC_KO en cas d'erreur (si erreur, l'extension ne sera PAS chargée) void weechat_plugin_end (t_weechat_plugin *plugin) fonction appelée au déchargement de l'extension

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) ...

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) ...

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);

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);

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.");

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);

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 Valeur renvoyée : aucune. Exemples : plugin->print (plugin, NULL, NULL, "hello"); plugin->print (plugin, NULL, "#weechat", "hello"); plugin->print (plugin, "freenode", "#weechat", "hello");

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 Valeur renvoyée : aucune. Exemple : plugin->print_server (plugin, "hello");

Prototype : void print_infobar (t_weechat_plugin *plugin, int temps, char *message, ...) Affiche un message sur la barre d'infos pour un temps déterminé. Paramètres : plugin : pointeur vers la structure de l'extension temps : temps (en secondes) pendant lequel le message est affiché (0 = jamais effacé) Valeur renvoyée : aucune. Exemple : plugin->print_infobar (plugin, 5, "hello");

Prototype : void infobar_remove (t_weechat_plugin *plugin, int nombre) Efface un ou plusieurs messages dans la pile de la barre d'infos. Paramètres : plugin : pointeur vers la structure de l'extension nombre : nombre de messages à supprimer (si paramètre non présent ou <= 0, alors tous les messages sont effacés) Valeur renvoyée : aucune. Exemple : plugin->infobar_remove (1);

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");

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 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 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);

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 %a alias %A alias et commandes (WeeChat, IRC et extensions) %c canal courant %C canaux du serveur courant %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 %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);

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);

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);

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);

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);

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 = (char *)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);

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);

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);

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");

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 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);

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);

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);

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); }

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);

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); }

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);

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); }

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);

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");

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");

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");

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");

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 */

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);

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 !");

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);

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 !");

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);

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); }

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);

La compilation ne nécessite pas les sources WeeChat, mais seulement le fichier "weechat-plugin.h". Pour compiler une extension composée d'un fichier "toto.c" (sous GNU/Linux) : $ gcc -fPIC -Wall -c toto.c $ gcc -shared -fPIC -o libtoto.so toto.o

Copier le fichier "libtoto.so" dans le répertoire système des extensions (par exemple "/usr/local/lib/weechat/plugins)" ou bien dans celui de l'utilisateur (par exemple "/home/xxxxx/.weechat/plugins"). Sous WeeChat : /plugin load toto

Un exemple complet d'extension, qui ajoute une commande /double affichant deux fois les paramètres passés sur le canal courant (d'accord ce n'est pas très utile mais ceci est un exemple !) : #include <stdlib.h> #include "weechat-plugin.h" char plugin_name[] = "Double"; char plugin_version[] = "0.1"; char plugin_description[] = "Plugin de test pour WeeChat"; /* gestionnaire de commande "/double" */ int double_cmd (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) { if (argv[2] && (argv[2][0] != '/')) { plugin->exec_command (plugin, NULL, NULL, argv[2]); plugin->exec_command (plugin, NULL, NULL, argv[2]); } return PLUGIN_RC_OK; } int weechat_plugin_init (t_weechat_plugin *plugin) { plugin->cmd_handler_add (plugin, "double", "Affiche deux fois un message", "msg", "msg: message a afficher deux fois", NULL, &double_cmd, NULL, NULL); return PLUGIN_RC_OK; } void weechat_plugin_end (t_weechat_plugin *plugin) { /* on ne fait rien ici */ }

Quatre extensions sont fournies en standard avec WeeChat pour utiliser des langages de script : Perl, Python, Ruby et Lua.

Les scripts sont chargés et déchargés avec les commandes /perl, /python, /ruby et /lua (tapez /help dans WeeChat pour obtenir de l'aide sur les commandes). Exemples : Charger un script Perl : /perl load /tmp/essai.pl Lister les scripts Perl chargés : /perl Charger un script Python : /python load /tmp/essai.py Lister les scripts Python chargés : /python Charger un script Ruby : /ruby load /tmp/essai.rb Lister les scripts Ruby chargés : /ruby Charger un script Lua : /lua load /tmp/essai.lua Lister les scripts Lua chargés : /lua

Dans un script Perl WeeChat, toutes les fonctions et variables de l'interface sont préfixées par "weechat::". Exemple : weechat::register("test", "1.0", "end_test", "Script perl WeeChat");

Un script Python WeeChat doit commencer par importer weechat : import weechat Toutes les fonctions et variables de l'interface sont préfixées par "weechat.". Exemple : weechat.register("test", "1.0", "end_test", "Script python WeeChat")

Dans un script Ruby WeeChat, tout le code doit être dans des fonctions. Pour le code principal, vous devez définir une fonction "weechat_init", qui est appelée automatiquement quand le script est chargé par WeeChat. Exemple : def weechat_init Weechat.register("test", "1.0", "end_test", "Script ruby WeeChat") Weechat.add_command_handler("commande", "ma_commande") return Weechat::PLUGIN_RC_OK end def ma_commande(server, args) Weechat.print("ma commande") return Weechat::PLUGIN_RC_OK end Toutes les fonctions de l'interface sont préfixées par "Weechat." et les variables par "Weechat::".

Dans un script Lua WeeChat, toutes les fonctions de l'interface sont préfixées par "weechat.". Les variables sont préfixées par "weechat." et suffixées par "()". Exemple : function message_handler(server, args) weechat.print("Je suis un message handler") return weechat.PLUGIN_RC_OK() end

Prototype Perl : weechat::register(nom, version, fonction_de_fin, description); Prototype Python : weechat.register(nom, version, fonction_de_fin, description) Prototype Ruby : Weechat.register(nom, version, fonction_de_fin, description) Prototype Lua : weechat.register(nom, version, fonction_de_fin, description) C'est la première fonction à appeler dans le script. Tout script pour WeeChat doit appeler cette fonction. Paramètres : nom : nom unique pour identifier le script (chaque script doit avoir un nom différent) version : version du script fonction_de_fin : fonction appelée quand le script est déchargé (paramètre facultatif, une chaîne vide signifiant qu'il n'y a pas de fonction à appeler) description : brève description du script Valeur renvoyée : 1 si le script a été enregistré, 0 si une erreur s'est produite. Exemples : # perl weechat::register("essai", "1.0", "fin_essai", "Script d'essai !"); # python weechat.register("essai", "1.0", "fin_essai", "Script d'essai !") # ruby Weechat.register("essai", "1.0", "fin_essai", "Script d'essai !") -- lua weechat.register("essai", "1.0", "fin_essai", "Script d'essai !")

Prototype Perl : weechat::print(message, [canal, [serveur]]) Prototype Python : weechat.prnt(message, [canal, [serveur]]) Prototype Ruby : Weechat.print(message, [canal, [serveur]]) Prototype Lua : weechat.print(message, [canal, [serveur]]) Affiche un message sur un tampon WeeChat, identifié par le serveur et le canal. Paramètres : message : message à afficher canal : nom du canal pour trouver le tampon dans lequel afficher serveur : nom interne du serveur pour trouver le tampon dans lequel afficher Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::print("message"); weechat::print("message", "#weechat"); weechat::print("message", "#weechat", "freenode"); # python weechat.prnt("message") weechat.prnt("message", "#weechat") weechat.prnt("message", "#weechat", "freenode") # ruby Weechat.print("message") Weechat.print("message", "#weechat") Weechat.print("message", "#weechat", "freenode") -- lua weechat.print("message") weechat.print("message", "#weechat") weechat.print("message", "#weechat", "freenode")

Prototype Perl : weechat::print_infobar(temps, message); Prototype Python : weechat.print_infobar(temps, message) Prototype Ruby : Weechat.print_infobar(temps, message) Prototype Lua : weechat.print_infobar(temps, message) Affiche un message sur la barre d'infos pour un temps déterminé. Paramètres : temps : temps (en secondes) pendant lequel le message est affiché (0 = jamais effacé) message : message à afficher Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::print_infobar(5, "message"); # python weechat.print_infobar(5, "message") # ruby Weechat.print_infobar(5, "message") -- lua weechat.print_infobar(5, "message")

Prototype Perl : weechat::remove_infobar([nombre]); Prototype Python : weechat.remove_infobar([nombre]) Prototype Ruby : Weechat.remove_infobar([nombre]) Prototype Lua : weechat.remove_infobar([nombre]) Efface un ou plusieurs messages dans la pile de la barre d'infos. Paramètres : nombre : nombre de messages à supprimer (si paramètre non présent ou <= 0, alors tous les messages sont effacés) Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::remove_infobar(1); # python weechat.remove_infobar(1) # ruby Weechat.remove_infobar(1) -- lua weechat.remove_infobar(1)

Prototype Perl : weechat::log(message, [canal, [serveur]]); Prototype Python : weechat.log(message, [canal, [serveur]]) Prototype Ruby : Weechat.log(message, [canal, [serveur]]) Prototype Lua : weechat.log(message, [canal, [serveur]]) Ecrit un message dans le fichier de log pour un serveur ou un canal. Paramètres : message : message canal : nom du canal pour trouver le log du tampon serveur : nom interne du serveur pour trouver le log du tampon Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::log("message", "#weechat", "freenode"); # python weechat.log("message", "#weechat", "freenode") # ruby Weechat.log("message", "#weechat", "freenode") -- lua weechat.log("message", "#weechat", "freenode")

Prototype Perl : weechat::add_message_handler(message, fonction); Prototype Python : weechat.add_message_handler(message, fonction) Prototype Ruby : Weechat.add_message_handler(message, fonction) Prototype Lua : weechat.add_message_handler(message, fonction) Ajoute un gestionnaire de messages IRC, appelé dès qu'un message IRC est reçu. Paramètres : message : nom du message IRC pour lequel la fonction est appelée. 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 (voir ). fonction : fonction appelée lorsque le message est reçu Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::add_message_handler("privmsg", "ma_fonction"); sub ma_fonction { weechat::print("serveur=$_[0]"); ($null, $canal, $message) = split ":",$_[1],3; ($masque, $null, $canal) = split " ", $canal; weechat::print("masque=$masque, canal=$canal, msg=$message"); return weechat::PLUGIN_RC_OK; } # python weechat.add_message_handler("privmsg", "ma_fonction") def ma_fonction(serveur, args): weechat.prnt("serveur="+serveur) null, canal, message = string.split(args, ":", 2) masque, null, canal = string.split(string.strip(canal), " ", 2) weechat.prnt("masque="+masque+", canal="+canal+", message="+message) return weechat.PLUGIN_RC_OK # ruby Weechat.add_message_handler("privmsg", "ma_fonction") def ma_fonction(server, args) Weechat.print("serveur=#{server}, args=#{args}") return Weechat::PLUGIN_RC_OK end -- lua weechat.add_message_handler("privmsg", "ma_fonction") function ma_fonction(server, args) weechat.print("serveur=" .. server .. ", args=" .. args) return weechat.PLUGIN_RC_OK() end 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

Prototype Perl : weechat::add_command_handler(commande, fonction, [description, arguments, arguments_description, modele_completion]); Prototype Python : weechat.add_command_handler(commande, fonction, [description, arguments, arguments_description, modele_completion]) Prototype Ruby : Weechat.add_command_handler(commande, fonction, [description, arguments, arguments_description, modele_completion]) Prototype Lua : weechat.add_command_handler(commande, fonction, [description, arguments, arguments_description, modele_completion]) Ajoute un gestionnaire de commande WeeChat, appelé dès que l'utilisateur utilise la commande (par exemple /commande). Paramètres : 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 le script soit déchargé) fonction : fonction appelée lorsque la commande est exécutée 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. (voir ) Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::add_command_handler("commande", "ma_commande"); sub ma_commande { weechat::print("serveur=$_[0], args=$_[1]"); return weechat::PLUGIN_RC_OK; } # python weechat.add_command_handler("commande", "ma_commande") def ma_commande(serveur, args): weechat.prnt("serveur="+serveur+", args="+args) return weechat.PLUGIN_RC_OK # ruby Weechat.add_command_handler("commande", "ma_commande") def ma_commande(server, args) Weechat.print("serveur=#{server} args=#{args}") return Weechat::PLUGIN_RC_OK end -- lua weechat.add_command_handler("commande", "ma_commande") def my_command(server, args) weechat.print("serveur="..server..", args="..args) return weechat.PLUGIN_RC_OK() end Notes : 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

Prototype Perl : weechat::add_timer_handler(intervalle, fonction); Prototype Python : weechat.add_timer_handler(intervalle, fonction) Prototype Ruby : Weechat.add_timer_handler(intervalle, fonction) Prototype Lua : weechat.add_timer_handler(intervalle, fonction) Ajoute un gestionnaire de temps, qui appelle périodiquement une fonction. Paramètres : intervalle : intervalle (en secondes) entre deux appels de la fonction. fonction : fonction appelée Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::add_timer_handler(60, "mon_timer"); sub mon_timer { weechat::print("ceci est le timer handler"); return weechat::PLUGIN_RC_OK; } # python weechat.add_timer_handler(60, "mon_timer") def mon_timer(): weechat.prnt("ceci est le timer handler") return weechat.PLUGIN_RC_OK # ruby Weechat.add_timer_handler(60, "mon_timer") def mon_timer() Weechat.print("ceci est le timer handler") return Weechat::PLUGIN_RC_OK end -- lua weechat.add_timer_handler(60, "mon_timer") function mon_timer() weechat.print("ceci est le timer handler") return weechat.PLUGIN_RC_OK() end 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

Prototype Perl : weechat::add_keyboard_handler(fonction); Prototype Python : weechat.add_keyboard_handler(fonction) Prototype Ruby : Weechat.add_keyboard_handler(fonction) Prototype Lua : weechat.add_keyboard_handler(fonction) Ajoute un gestionnaire de clavier, appelé dès qu'une touche est pressée. Paramètres : fonction : fonction appelée Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::add_keyboard_handler("mon_clavier"); sub mon_clavier { my $key = shift; my $input_before = shift; my $input_after = shift; weechat::print("gestionnaire clavier: key = '$key', " ."entrée avant = '$input_before' " ."après = '$input_after'"); return weechat::PLUGIN_RC_OK; } # python weechat.add_keyboard_handler("mon_clavier") def mon_clavier(key, input_before, input_after): weechat.prnt("gestionnaire clavier: touche = '%s', " \ "entrée avant = '%s' après = '%s'" %(key, input_before, input_after)) return weechat.PLUGIN_RC_OK # ruby Weechat.add_keyboard_handler("mon_clavier") def mon_clavier(server, input_before, input_after) Weechat.print("gestionnaire clavier: touche = '#{key}', " \ "entrée avant = '#{input_before}' " \ "après = '#{input_after}'") return Weechat::PLUGIN_RC_OK end -- lua weechat.add_keyboard_handler("mon_clavier") function mon_clavier(server, input_before, input_after) weechat.print("gestionnaire clavier: touche = '"..key.. "', entrée avant = '"..input_before.. "' après = '"..input_after.."'") return weechat.PLUGIN_RC_OK() end 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

Prototype Perl : weechat::remove_handler(nom, fonction); Prototype Python : weechat.remove_handler(nom, fonction) Prototype Ruby : Weechat.remove_handler(nom, fonction) Prototype Lua : weechat.remove_handler(nom, fonction) Supprime un gestionnaire de message ou de commande. Paramètres : nom : nom du message IRC ou de la commande fonction : fonction associée Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::remove_handler("commande", "ma_commande"); # python weechat.remove_handler("commande", "ma_commande") # ruby Weechat.remove_handler("commande", "ma_commande") -- lua weechat.remove_handler("commande", "ma_commande")

Prototype Perl : weechat::remove_timer_handler(fonction); Prototype Python : weechat.remove_timer_handler(fonction) Prototype Ruby : Weechat.remove_timer_handler(fonction) Prototype Lua : weechat.remove_timer_handler(fonction) Supprime un gestionnaire de temps. Paramètres : fonction : fonction Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::remove_timer_handler("mon_timer"); # python weechat.remove_timer_handler("mon_timer") # ruby Weechat.remove_timer_handler("mon_timer") -- lua weechat.remove_timer_handler("mon_timer")

Prototype Perl : weechat::remove_keyboard_handler(fonction); Prototype Python : weechat.remove_keyboard_handler(fonction) Prototype Ruby : Weechat.remove_keyboard_handler(fonction) Prototype Lua : weechat.remove_keyboard_handler(fonction) Supprime un gestionnaire de clavier. Paramètres : fonction : fonction Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::remove_keyboard_handler("mon_clavier"); # python weechat.remove_keyboard_handler("mon_clavier") # ruby Weechat.remove_keyboard_handler("mon_clavier") -- lua weechat.remove_keyboard_handler("mon_clavier")

Prototype Perl : weechat::add_modifier(type, message, fonction); Prototype Python : weechat.add_modifier(type, message, fonction) Prototype Ruby : Weechat.add_modifier(type, message, fonction) Prototype Lua : weechat.add_modifier(type, message, fonction) Ajoute un modifieur de messages. Paramètres : 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 Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::add_modifier("irc_in", "privmsg", "ma_fonction"); sub ma_fonction { # TODO } # python weechat.add_modifier("irc_in", "privmsg", "ma_fonction") def ma_fonction(serveur, args): # TODO # ruby Weechat.add_modifier("irc_in", "privmsg", "ma_fonction") def ma_fonction(server, args) # TODO end -- lua weechat.add_modifier("irc_in", "privmsg", "ma_fonction") function ma_fonction(server, args) -- TODO end

Prototype Perl : weechat::remove_modifier(type, message, fonction); Prototype Python : weechat.remove_handler(type, message, fonction) Prototype Ruby : Weechat.remove_handler(type, message, fonction) Prototype Lua : weechat.remove_handler(type, message, fonction) Supprime un modifieur de messages. Paramètres : type : type de modifieur message : message traité par le modifieur fonction : fonction associée Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::remove_modifier("irc_in", "privmsg", "ma_fonction"); # python weechat.remove_modifier("irc_in", "privmsg", "ma_fonction") # ruby Weechat.remove_modifier("irc_in", "privmsg", "ma_fonction") -- lua weechat.remove_modifier("irc_in", "privmsg", "ma_fonction")

Prototype Perl : weechat::command(commande, [canal, [serveur]]); Prototype Python : weechat.command(commande, [canal, [serveur]]) Prototype Ruby : Weechat.command(commande, [canal, [serveur]]) Prototype Lua : weechat.command(commande, [canal, [serveur]]) Exécute une commande ou envoie un message à un canal. Paramètres : commande : la commande à exécuter canal : nom du canal où exécuter la commande serveur : nom interne du serveur où exécuter la commande Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::command("bonjour tout le monde !"); weechat::command("/kick toto merci de quitter ce canal", "#weechat"); weechat::command("/nick newnick", "", "freenode"); # python weechat.command("bonjour tout le monde !") weechat.command("/kick toto merci de quitter ce canal", "#weechat") weechat.command("/nick newnick", "", "freenode") # ruby Weechat.command("bonjour tout le monde !") Weechat.command("/kick toto merci de quitter ce canal", "#weechat") Weechat.command("/nick newnick", "", "freenode") -- lua weechat.command("bonjour tout le monde !") weechat.command("/kick toto merci de quitter ce canal", "#weechat") weechat.command("/nick newnick", "", "freenode")

Prototype Perl : weechat::get_info(nom, [serveur]); Prototype Python : weechat.get_info(nom, [serveur]) Prototype Ruby : Weechat.get_info(nom, [serveur]) Prototype Lua : weechat.get_info(nom, [serveur]) Renvoie une information sur WeeChat ou un canal. Paramètres : nom : nom de l'info à obtenir (voir ) serveur : nom interne du serveur où récupérer l'information (si nécessaire) Valeur renvoyée : l'information demandée, chaîne vide si une erreur s'est produite ou que l'information n'a pas été trouvée. Exemples : # perl $version = get_info("version"); $nick = get_info("nick", "freenode"); # python version = weechat.get_info("version") nick = weechat.get_info("nick", "freenode") # ruby version = Weechat.get_info("version") nick = Weechat.get_info("nick", "freenode") -- lua version = weechat.get_info("version") nick = weechat.get_info("nick", "freenode")

Prototype Perl : weechat::get_dcc_info(); Prototype Python : weechat.get_dcc_info() Prototype Ruby : Weechat.get_dcc_info() Prototype Lua : weechat.get_dcc_info() Renvoie la liste des DCC en cours ou terminés. Valeur renvoyée : la liste des DCC (voir ). Exemples : # perl my @dccs = weechat::get_dcc_info(); if (@dccs) { foreach my $dcc (@dccs) { while (my ($key, $value) = each %$dcc) { weechat::print("$key = '$value'"); } } } else { weechat::print("pas de DCC"); } # python dccs = weechat.get_dcc_info() if dccs != None: if dccs == []: weechat.prnt("pas de DCC") else: for d in dccs: for b in d.keys(): weechat.prnt("%s = '%s'" %(b, d[b])) else: weechat.prnt("erreur de lecture des DCC") # ruby dccs = Weechat.get_dcc_info() if dccs != nil if dccs == [] Weechat.print("pas de DCC") else dccs.each do |m| m.each do |key, value| Weechat.print("#{key} = '#{value}'") end end end else Weechat.print("erreur de lecture des DCC") end -- lua dccs = weechat.get_dcc_info() if dccs ~= nil then if dccs then dcc, dccinfos = next (dccs, nil) while (dcc) do key, value = next (dccinfos, nil) while (key) do weechat.print(key.." = '"..value.."'") key, value = next (dccinfos, key) end dcc, dccinfos = next (dccs, dcc) end else weechat.print("pas de DCC") end else weechat.print("erreur de lecture des DCC") end

Prototype Perl : weechat::get_server_info(); Prototype Python : weechat.get_server_info() Prototype Ruby : Weechat.get_server_info() Prototype Lua : weechat.get_server_info() Renvoie la liste des serveurs IRC (connectés ou non). Valeur renvoyée : la liste des serveurs IRC (connectés ou non) (voir ). Exemples : # perl my $servers = weechat::get_server_info(); if ($servers) { while (my ($srvname, $srvinfos) = each %$servers) { while (my ($key, $value) = each %$srvinfos) { weechat::print("$srvname -> $key = '$value'"); } } } else { weechat::print("pas de serveur"); } # python servers = weechat.get_server_info() if servers != None: if servers == {}: weechat.prnt("pas de serveur") else: for s in servers: for i in servers[s]: weechat.prnt("%s -> %s = '%s'" % (s, i, str(servers[s][i]))) else: weechat.prnt("erreur de lecture des serveurs") # ruby servers = Weechat.get_server_info() if servers != nil if servers == [] Weechat.print("pas de serveur") else servers.each do |n, s| s.each do |key, value| Weechat.print("#{n} -> #{key} = '#{value}'") end end end else Weechat.print("erreur de lecture des serveurs") end -- lua servers = weechat.get_server_info() if servers ~= nil then if servers then srv, srvinfos = next (servers, nil) while (srv) do key, value = next (srvinfos, nil) while (key) do weechat.print(srv.." -> "..key.." = '"..value.."'") key, value = next (srvinfos, key) end srv, srvinfos = next (servers, srv) end else weechat.print("pas de serveur") end else weechat.print("erreur de lecture des serveurs") end

Prototype Perl : weechat::get_channel_info(serveur); Prototype Python : weechat.get_channel_info(serveur) Prototype Ruby : Weechat.get_channel_info(serveur) Prototype Lua : weechat.get_channel_info(serveur) Renvoie la liste des canaux IRC pour un serveur. Valeur renvoyée : la liste des canaux IRC du serveur (voir ). Exemples : # perl my $channels = weechat::get_channel_info(weechat::get_info("server")); if ($channels) { while (my ($channame, $chaninfos) = each %$channels) { while (my ($key, $value) = each %$chaninfos) { weechat::print("$channame -> $key = '$value'"); } } } else { weechat::print("pas de canal"); } # python chans = weechat.get_channel_info(weechat.get_info("server")) if chans != None: if chans == {}: weechat.prnt("pas de canal") else: for s in chans: for i in chans[s]: weechat.prnt("%s -> %s = '%s'" % (s, i, str(chans[s][i]))) else: weechat.prnt("erreur de lecture des canaux") # ruby channels = Weechat.get_channel_info(Weechat.get_info("server")) if channels != nil if channels == {} Weechat.print("pas de canal") else channels.each do |n, c| c.each do |key, value| Weechat.print("#{n} -> #{key} = '#{value}'") end end end else Weechat.print("erreur de lecture des canaux") end -- lua chans = weechat.get_channel_info(weechat.get_info("server")) if chans ~= nil then if chans then chan, chaninfos = next (chans, nil) while (chan) do key, value = next (chaninfos, nil) while (key) do weechat.print(chan.." -> "..key.." = '"..value.."'") key, value = next (chaninfos, key) end chan, chaninfos = next (chans, chan) end else weechat.print("pas de canal") end else weechat.print("erreur de lecture des canaux") end

Prototype Perl : weechat::get_nick_info(serveur, canal); Prototype Python : weechat.get_nick_info(serveur, canal) Prototype Ruby : Weechat.get_nick_info(serveur, canal) Prototype Lua : weechat.get_nick_info(serveur, canal) Renvoie la liste des pseudos pour un canal. Valeur renvoyée : la liste des pseudos présents sur le canal (voir ). Exemples : # perl my $nicks = weechat::get_nick_info("freenode", "#weechat"); if ($nicks) { while (my ($nickname, $nickinfos) = each %$nicks) { while ( my ($key, $value) = each %$nickinfos) { weechat::print("$nickname -> $key = '$value'"); } } } else { weechat::print("pas de pseudo"); } # python nicks = weechat.get_nick_info("freenode", "#weechat") if nicks != None: if nicks == {}: weechat.prnt("pas de pseudo") else: for n in nicks: for f in nicks[n]: weechat.prnt("%s -> %s = '%s'" % (n, f, str(nicks[n][f]))) else: weechat.prnt("erreur de lecture des pseudos") # ruby nicks = Weechat.get_nick_info("freenode", "#weechat") if nicks != nil if nicks == {} Weechat.print("pas de pseudo") else nicks.each do |nk, nattr| nattr.each do |key, value| Weechat.print("#{nk} -> #{key} = '#{value}'") end end end else Weechat.print("erreur de lecture des pseudos") end -- lua nicks = weechat.get_nick_info("freenode", "#weechat") if nicks ~= nil then if nicks then nick, nickinfos = next (nicks, nil) while (nick) do key, value = next (nickinfos, nil) while (key) do weechat.print(nick.." -> "..key.." = '"..value.."'") key, value = next (nickinfos, key) end nick, nickinfos = next (nicks, nick) end else weechat.print("pas de pseudo") end else weechat.print("erreur de lecture des pseudos") end

Prototype Perl : weechat::get_config(option); Prototype Python : weechat.get_config(option) Prototype Ruby : Weechat.get_config(option) Prototype Lua : weechat.get_config(option) Renvoie la valeur d'une option de configuration WeeChat. Paramètres : option : nom de l'option Valeur renvoyée : la valeur de l'option, chaîne vide si l'option n'a pas été trouvée. Exemples : # perl $valeur1 = weechat::get_config("look_nicklist"); $valeur2 = weechat::get_config("freenode.server_autojoin"); # python valeur1 = weechat.get_config("look_nicklist") valeur2 = weechat.get_config("freenode.server_autojoin") # ruby valeur1 = Weechat.get_config("look_nicklist") valeur2 = Weechat.get_config("freenode.server_autojoin") -- lua valeur1 = weechat.get_config("look_nicklist") valeur2 = weechat.get_config("freenode.server_autojoin")

Prototype Perl : weechat::set_config(option, valeur); Prototype Python : weechat.set_config(option, valeur) Prototype Ruby : Weechat.set_config(option, valeur) Prototype Lua : weechat.set_config(option, valeur) Modifie la valeur d'une option de configuration WeeChat. Paramètres : option : nom de l'option valeur : la nouvelle valeur pour l'option Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::set_config("look_nicklist", "off"); weechat::set_config("freenode.server_autojoin, "#weechat"); # python weechat.set_config("look_nicklist", "off") weechat.set_config("freenode.server_autojoin, "#weechat") # ruby Weechat.set_config("look_nicklist", "off") Weechat.set_config("freenode.server_autojoin, "#weechat") -- lua weechat.set_config("look_nicklist", "off") weechat.set_config("freenode.server_autojoin, "#weechat")

Prototype Perl : weechat::get_plugin_config(option); Prototype Python : weechat.get_plugin_config(option) Prototype Ruby : Weechat.get_plugin_config(option) Prototype Lua : weechat.get_plugin_config(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.script.option=valeur" (NB : le nom de l'extension et du script sont ajoutés automatiquement). Paramètres : option : nom de l'option Valeur renvoyée : la valeur de l'option, chaîne vide si l'option n'a pas été trouvée. Exemples : # perl $valeur = weechat::get_plugin_config("ma_variable"); # python valeur = weechat.get_plugin_config("ma_variable") # ruby valeur = Weechat.get_plugin_config("ma_variable") -- lua valeur = weechat.get_plugin_config("ma_variable")

Prototype Perl : weechat::set_plugin_config(option, valeur); Prototype Python : weechat.set_plugin_config(option, valeur) Prototype Ruby : Weechat.set_plugin_config(option, valeur) Prototype Lua : weechat.set_plugin_config(option, 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.script.option=valeur" (NB : le nom de l'extension et du script sont rajoutés automatiquement). Paramètres : option : nom de l'option valeur : la nouvelle valeur pour l'option Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite. Exemples : # perl weechat::set_plugin_config("ma_variable", "valeur"); # python weechat.set_plugin_config("ma_variable", "valeur") # ruby Weechat.set_plugin_config("ma_variable", "valeur") -- lua weechat.set_plugin_config("ma_variable", "valeur")

Prototype Perl : weechat::get_irc_color(color); Prototype Python : weechat.get_irc_color(color) Prototype Ruby : Weechat.get_irc_color(color) Prototype Lua : weechat.get_irc_color(color) Renvoie le numéro d'une couleur IRC avec son nom. Valeur renvoyée : numéro de la couleur IRC, -1 si la couleur n'est pas trouvée (voir ). Exemples : # perl my $color_blue = weechat::get_irc_color("blue"); # python color_blue = weechat.get_irc_color("blue") # ruby color_blue = Weechat.get_irc_color("blue") -- lua color_blue = weechat.get_irc_color("blue")

Prototype Perl : weechat::input_color(color); Prototype Python : weechat.input_color(color) Prototype Ruby : Weechat.input_color(color) Prototype Lua : weechat.input_color(color) Ajoute de la couleur dans la zone de saisie. Valeur renvoyée : aucune. Exemples : # perl weechat::input_color(weechat::get_irc_color("blue"), 10, 5); # python weechat.input_color(weechat.get_irc_color("blue"), 10, 5) # ruby Weechat.input_color(Weechat.get_irc_color("blue"), 10, 5) -- lua weechat.input_color(weechat.get_irc_color("blue"), 10, 5)

Prototype Perl : weechat::get_window_info(); Prototype Python : weechat.get_window_info() Prototype Ruby : Weechat.get_window_info() Prototype Lua : weechat.get_window_info() Renvoie la liste des fenêtres WeeChat. Valeur renvoyée : liste des fenêtres WeeChat (voir ). Exemples : # perl my @wf = weechat::get_window_info(); if (@wf) { weechat::print("**** infos fenêtres ****"); foreach my $w (@wf) { while ( my ($key, $value) = each %$w) { weechat::print(" > $key => $value"); } weechat::print("----------------------"); } } else { weechat::print("**** pas d'info fenêtre ****"); } # python wf = weechat.get_window_info() if wf != None and wf != []: weechat.prnt ("**** infos fenêtres ****") for w in wf: for i in w: weechat.prnt (" > %s => %s" % (i, w[i])) weechat.prnt ("----------------------") else: weechat.prnt ("**** pas d'info sur les fenêtres ****") # ruby wf = Weechat.get_window_info() if wf != nil and wf != [] Weechat.print("**** infos fenêtres ****") wf.each do |w| w.each do |key, value| Weechat.print(" > #{key} => #{value}") end Weechat.print("----------------------") end else Weechat.print("**** pas d'info sur les fenêtres ****") end -- lua wf = weechat.get_window_info() if wf then weechat.print ("**** infos fenêtres ****") w, winfos = next (wf, nil) while (w) do key, value = next (winfos, nil) while (key) do weechat.print(" > " .. key .. " => " .. value) key, value = next (winfos, key) end weechat.print ("----------------------") w, winfos = next (wf, w) end else weechat.print("**** pas d'info sur les fenêtres ****") end

Prototype Perl : weechat::get_buffer_info(); Prototype Python : weechat.get_buffer_info() Prototype Ruby : Weechat.get_buffer_info() Prototype Lua : weechat.get_buffer_info() Renvoie la liste des tampons WeeChat. Valeur renvoyée : liste des tampons WeeChat (voir ). Exemples : # perl my $bf = weechat::get_buffer_info(); if ($bf) { while ( my ($nobuf, $binfos) = each %$bf) { while ( my ($key, $value) = each %$binfos) { weechat::print(" > $key => $value"); } weechat::print("----------------------"); } } else { weechat::print("**** pas d'info sur les tampons ****"); } # python bf = weechat.get_buffer_info() if bf != None and bf != {}: for b in bf: weechat.prnt ("**** info pour tampon buffer no %d ****" % b) for c in bf[b]: weechat.prnt (" > %s => %s" % (c, bf[b][c])) weechat.prnt ("----------------------") else: weechat.prnt ("**** pas d'info sur les tampons ****") # ruby bf = Weechat.get_buffer_info() if bf != nil and bf != {} bf.each do |n, c| Weechat.print("**** info pour tampon no #{n} ****") c.each do |key, value| Weechat.print(" > #{key} => #{value}") end Weechat.print("----------------------") end else Weechat.print("**** pas d'info sur les tampons ****") end -- lua bf = weechat.get_buffer_info() if bf then b, binfos = next (bf, nil) while (b) do weechat.print("**** info pour tampon no " .. b .. " ****") key, value = next (binfos, nil) while (key) do weechat.print(" > " .. key .. " => " .. value) key, value = next (binfos, key) end weechat.print ("----------------------") b, infos = next (bf, b) end else weechat.print("**** pas d'info sur les tampons ****") end

Perl prototype: weechat::get_buffer_data(server, channel); Python prototype: weechat.get_buffer_data(server, channel) Ruby prototype: Weechat.get_buffer_data(server, channel) Lua prototype: weechat.get_buffer_data(server, channel) Return content of buffer. Return value: list of lines for buffer (see ). Examples: # perl my $server = weechat::get_info("server"); my $channel = weechat::get_info("channel"); my @bc = weechat::get_buffer_data($server, $channel); if (@bc) { weechat::print("**** buffer data for '$channel'\@'$server' ****"); foreach my $l (@bc) { while ( my ($key, $value) = each %$l) { weechat::print(" > $key => $value"); } weechat::print("----------------------"); } } else { weechat::print("**** no buffer data ****"); } # python server = weechat.get_info("server") channel = weechat.get_info("channel") bc = weechat.get_buffer_data(server, channel) if bc != None and bc != []: weechat.prnt ("**** buffer data for '%s'@'%s' ****" % (channel, server)) for l in bc: for i in l: weechat.prnt (" > %s => %s" % (i, l[i])) weechat.prnt ("----------------------") else: weechat.prnt ("**** no buffer data ****") # ruby server = Weechat.get_info("server") channel = Weechat.get_info("channel") bc = Weechat.get_buffer_data(server, channel) if bc != nil and bc != [] Weechat.print("**** buffer data for '#{channel}'@'#{server}' ****") bc.each do |l| l.each do |key, value| Weechat.print(" > #{key} => #{value}") end Weechat.print("----------------------") end else Weechat.print("**** no buffer data ****") end -- lua server = weechat.get_info("server") channel = weechat.get_info("channel") bc = weechat.get_buffer_data(server, channel) if bc then b, bdatas = next (bc, nil) weechat.print("**** buffer data for '" .. channel .. "'@'" .. server .. "' ****") while (b) do key, value = next (bdatas, nil) while (key) do weechat.print(" > " .. key .. " => " .. value) key, value = next (bdatas, key) end weechat.print ("----------------------") b, bdatas = next (bc, b) end else weechat.print("**** no buffer data ****") end

Ce chapitre liste les auteurs et contributeurs pour WeeChat, et indique les moyens d'obtenir du support.

WeeChat est développé par : FlashCode (Sébastien Helleu) flashcode AT flashtux.org - développeur principal Kolter kolter AT free.fr - développeur Ptitlouis ptitlouis AT sysif.net - empaqueteur Debian

Les personnes suivantes ont contribué à WeeChat : Jiri Golembiovsky - traduction en tchèque, patchs Rudolf Polzer - patchs Jim Ramsay - patchs Odin - RPM pour SuSE Pistos - patchs Gwenn - patchs voroskoi - traduction en hongrois Frank Zacharias - traduction en allemand Pavel Shevchuk - traduction en russe

Avant de faire appel au support, merci de lire la documentation et la FAQ de WeeChat (la documentation est le document que vous êtes en train de lire, si vous n'avez pas tout lu jusqu'ici, il est encore temps de recommencer !) IRC : serveur "irc.freenode.net", canal "#weechat" Forum WeeChat : http://forums.flashtux.org Liste de diffusion : Pour souscrire : http://mail.nongnu.org/mailman/listinfo/weechat-support Pour envoyer un mail à la liste de diffusion : weechat-support@nongnu.org Les archives de la liste de diffusion sont ici : http://mail.nongnu.org/archive/html/weechat-support