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 :
/luaSyntaxe par langagePerl
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 / scriptsregister
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 unique pour identifier le script
(chaque script doit avoir un nom différent)
: version du script
: 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)
: brève description du script
: 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 :
: 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 à afficher
: nom du canal pour trouver le
tampon dans lequel afficher
: 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 à 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
: nom du canal pour trouver le
log du tampon
: 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 :
: 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 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 :
: 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 appelée lorsque la
commande est exécutée
: brève description des
paramètres de la commande (affichée par /help commande)
: longue description
des paramètres de la commande (affichée par /help commande)
: 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 (en secondes)
entre deux appels de la 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 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
(voir )
: 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 du message IRC ou de la commande
: 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
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
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
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 de modifieur :
TypeDescriptionirc_inappelé pour chaque message IRC reçuirc_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)
: 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 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 de modifieur
: message traité par le modifieur
: 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 :
: la commande à exécuter
: nom du canal où exécuter la
commande
: 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 de l'info à obtenir
(voir )
: 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 :
: 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 :
: nom de l'option
: 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 :
: 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 :
: nom de l'option
: 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