# Extensions pour scripts

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

## Charger / décharger des scripts

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``

## Syntaxe par langage

### Perl

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

### Python

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

### Ruby

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::`".

### Lua

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

## Interface WeeChat / scripts

### register

Prototype Perl : `weechat::register(nom, version, fonction_de_fin, description, [charset]);`

Prototype Python : `weechat.register(nom, version, fonction_de_fin, description, [charset])`

Prototype Ruby : `Weechat.register(nom, version, fonction_de_fin, description, [charset])`

Prototype Lua : `weechat.register(nom, version, fonction_de_fin, description, [charset])`

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

- `charset` : jeu de caractères du script, à préciser si le script n'est pas écrit en UTF-8

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 !", "ISO-8859-1");

    # python
    weechat.register("essai", "1.0", "fin_essai", "Script d'essai !", "ISO-8859-1")

    # ruby
    Weechat.register("essai", "1.0", "fin_essai", "Script d'essai !", "ISO-8859-1")

    -- lua
    weechat.register("essai", "1.0", "fin_essai", "Script d'essai !", "ISO-8859-1")

### set_charset

Prototype Perl : `weechat::set_charset(charset);`

Prototype Python : `weechat.set_charset(charset)`

Prototype Ruby : `Weechat.set_charsetr(charset)`

Prototype Lua : `weechat.set_charset(charset)`

Change le jeu de caractères du script.

Paramètres :

- `charset` : nouveau jeu de caractères

Valeur renvoyée : 1 si le nouveau jeu de caractères a été mis en place, 0 si une erreur s'est produite.

Exemples :

    # perl
    weechat::set_charset("ISO-8859-1");

    # python
    weechat.set_charset("ISO-8859-1")

    # ruby
    Weechat.set_charset("ISO-8859-1")

    -- lua
    weechat.set_charset("ISO-8859-1")

### print

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

Pour afficher du texte en couleur, voir .

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");
    weechat::print("test: \x0305 rouge \x0F normal");

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

### print_server

Prototype Perl : `weechat::print_server(message)`

Prototype Python : `weechat.print_server(message)`

Prototype Ruby : `Weechat.print_server(message)`

Prototype Lua : `weechat.print_server(message)`

Affiche un message sur le tampon serveur.

Paramètres :

- `message` : message à afficher

Pour afficher du texte en couleur, voir .

Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite.

Exemples :

    # perl
    weechat::print_server("message");
    weechat::print_server("test: \x0305 rouge \x0F normal");

    # python
    weechat.print_server("message")

    # ruby
    Weechat.print_server("message")

    -- lua
    weechat.print_server("message")

### log

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

### add_message_handler

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

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

### add_command_handler

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

### add_timer_handler

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

### add_keyboard_handler

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(key, 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(key, 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

### add_event_handler

Prototype Perl : `weechat::add_event_handler(évènement, fonction);`

Prototype Python : `weechat.add_event_handler(évènement, fonction)`

Prototype Ruby : `Weechat.add_event_handler(évènement, fonction)`

Prototype Lua : `weechat.add_event_handler(évènement, fonction)`

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

Paramètres :

- `évènement` : évènement (voir )

- `fonction` : fonction appelée

Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite.

Exemples :

    # perl
    weechat::add_event_handler("buffer_open", "mon_evenement");
    sub mon_evenement
    {
        weechat::print("buffer open");
        return weechat::PLUGIN_RC_OK;
    }

    # python
    weechat.add_event_handler("buffer_open", "mon_evenement")
    def mon_evenement():
        weechat.prnt("buffer open")
        return weechat.PLUGIN_RC_OK

    # ruby
    Weechat.add_event_handler("buffer_open", "mon_evenement")
    def mon_evenement()
        Weechat.print("buffer open")
        return Weechat::PLUGIN_RC_OK
    end

    -- lua
    weechat.add_event_handler("buffer_open", "mon_evenement")
    function mon_evenement()
        weechat.print("buffer open")
        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

### remove_handler

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

### remove_timer_handler

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

### remove_keyboard_handler

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

### remove_event_handler

Prototype Perl : `weechat::remove_event_handler(fonction);`

Prototype Python : `weechat.remove_event_handler(fonction)`

Prototype Ruby : `Weechat.remove_event_handler(fonction)`

Prototype Lua : `weechat.remove_event_handler(fonction)`

Supprime un gestionnaire d'évènement.

Paramètres :

- `fonction` : fonction

Valeur renvoyée : 1 si succès, 0 si une erreur s'est produite.

Exemples :

    # perl
    weechat::remove_event_handler("mon_evenement");

    # python
    weechat.remove_event_handler("mon_evenement")

    # ruby
    Weechat.remove_event_handler("mon_evenement")

    -- lua
    weechat.remove_event_handler("mon_evenement")

### add_modifier

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", "mod_in");
    weechat::add_modifier("irc_out", "privmsg", "mod_out");
    sub mod_in
    {
        return "$_[1] [modifier IN]";
    }
    sub mod_out
    {
        return "$_[1] [modifier OUT]";
    }

    # python
    weechat.add_modifier("irc_in", "privmsg", "mod_in")
    weechat.add_modifier("irc_out", "privmsg", "mod_out")
    def mod_in(serveur, args):
        return args + " [modifier IN]"
    def mod_out(serveur, args):
        return args + " [modifier OUT]"

    # ruby
    Weechat.add_modifier("irc_in", "privmsg", "mod_in")
    Weechat.add_modifier("irc_out", "privmsg", "mod_out")
    def mod_in(server, args)
        return args + " [modifier IN]"
    end
    def mod_out(server, args)
        return args + " [modifier OUT]"
    end

    -- lua
    weechat.add_modifier("irc_in", "privmsg", "mod_in")
    weechat.add_modifier("irc_out", "privmsg", "mod_out")
    function mod_in(server, args)
        return args .. " [modifier IN]"
    end
    function mod_out(server, args)
        return args .. " [modifier OUT]"
    end

### remove_modifier

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

    # python
    weechat.remove_modifier("irc_in", "privmsg", "mod_in")

    # ruby
    Weechat.remove_modifier("irc_in", "privmsg", "mod_in")

    -- lua
    weechat.remove_modifier("irc_in", "privmsg", "mod_in")

### command

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

### get_info

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

### get_dcc_info

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

### get_server_info

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

### get_channel_info

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

### get_nick_info

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

### get_config

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

### set_config

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

### get_plugin_config

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

### set_plugin_config

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

### get_irc_color

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

### input_color

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)

### get_window_info

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

### get_buffer_info

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

### get_buffer_data

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