916 lines
29 KiB
Plaintext
916 lines
29 KiB
Plaintext
WeeChat Guide pour Scripts
|
|
==========================
|
|
Sébastien Helleu <flashcode@flashtux.org>
|
|
|
|
|
|
Ce manuel documente le client de messagerie instantanée WeeChat, il fait
|
|
partie de WeeChat.
|
|
|
|
La dernière version de ce document peut être téléchargée sur cette page :
|
|
http://www.weechat.org/doc
|
|
|
|
|
|
[[introduction]]
|
|
Introduction
|
|
------------
|
|
|
|
WeeChat (Wee Enhanced Environment for Chat) est un client de discussion libre,
|
|
rapide et léger, conçu pour différents systèmes d'exploitation.
|
|
|
|
Ce manuel documente la façon d'écrire des scripts pour WeeChat, en utilisant
|
|
l'un des langages de script supportés :
|
|
|
|
* python
|
|
* perl
|
|
* ruby
|
|
* lua
|
|
* tcl
|
|
* guile (scheme)
|
|
|
|
[NOTE]
|
|
La majorité des exemples de cette documentation sont écrits en Python, mais
|
|
l'API est la même pour les autres langages.
|
|
|
|
[[scripts_in_weechat]]
|
|
Scripts dans WeeChat
|
|
--------------------
|
|
|
|
[[languages_specifities]]
|
|
Spécificités des langages
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
Python
|
|
^^^^^^
|
|
|
|
* Vous devez utiliser `import weechat`
|
|
* Les fonctions `print*` se nomment `prnt*` en python (car 'print' est un mot
|
|
clé réservé)
|
|
* Les fonctions sont appelées par `weechat.xxx(arg1, arg2, ...)`
|
|
|
|
Perl
|
|
^^^^
|
|
|
|
* Les fonctions sont appelées par `weechat::xxx(arg1, arg2, ...);`
|
|
|
|
Ruby
|
|
^^^^
|
|
|
|
* Vous devez définir 'weechat_init' et appeler 'register' dedans
|
|
* Les fonctions sont appelées par `Weechat.xxx(arg1, arg2, ...)`
|
|
|
|
Lua
|
|
^^^
|
|
|
|
* Les fonctions sont appelées par `weechat.xxx(arg1, arg2, ...)`
|
|
|
|
Tcl
|
|
^^^
|
|
|
|
* Les fonctions sont appelées par `weechat::xxx arg1 arg2 ...`
|
|
|
|
Guile (scheme)
|
|
^^^^^^^^^^^^^^
|
|
|
|
* Les fonctions sont appelées par `(weechat:xxx arg1 arg2 ...)`
|
|
* Les fonctions suivantes prennent une liste de paramètres en entrée (au lieu
|
|
de plusieurs paramètres pour les autres fonctions), car le nombre de
|
|
paramètres excède la limite de Guile :
|
|
** config_new_section
|
|
** config_new_option
|
|
** bar_new
|
|
|
|
[[register_function]]
|
|
Fonction register
|
|
~~~~~~~~~~~~~~~~~
|
|
|
|
Tous les scripts WeeChat doivent s'enregistrer ("register") auprès de WeeChat,
|
|
et cela doit être la première fonction WeeChat appelée dans le script.
|
|
|
|
Prototype :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
weechat.register(name, author, version, license, description, shutdown_function, charset)
|
|
----------------------------------------
|
|
|
|
Paramètres :
|
|
|
|
* 'name' : chaîne, nom interne du script
|
|
* 'author' : chaîne, nom de l'auteur
|
|
* 'version' : chaîne, version du script
|
|
* 'license' : chaîne, licence du script
|
|
* 'description' : chaîne, description courte du script
|
|
* 'shutdown_function' : chaîne, nom de la fonction appelée lorsque le script
|
|
est déchargé
|
|
* 'charset' : chaîne, jeu de caractères du script (optionnel, si votre script
|
|
est UTF-8, vous pouvez utiliser une valeur vide ici, car UTF-8 est le jeu de
|
|
caractères par défaut)
|
|
|
|
Exemple, pour chaque langage :
|
|
|
|
* python :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
import weechat
|
|
|
|
weechat.register("test_python", "FlashCode", "1.0", "GPL3", "Script de test", "", "")
|
|
weechat.prnt("", "Bonjour, du script python !")
|
|
----------------------------------------
|
|
|
|
* perl :
|
|
|
|
[source,perl]
|
|
----------------------------------------
|
|
weechat::register("test_perl", "FlashCode", "1.0", "GPL3", "Script de test", "", "");
|
|
weechat::print("", "Bonjour, du script perl !");
|
|
----------------------------------------
|
|
|
|
* ruby :
|
|
|
|
[source,ruby]
|
|
----------------------------------------
|
|
def weechat_init
|
|
Weechat.register("test_ruby", "FlashCode", "1.0", "GPL3", "Script de test", "", "")
|
|
Weechat.print("", "Bonjour, du script ruby !")
|
|
return Weechat::WEECHAT_RC_OK
|
|
end
|
|
----------------------------------------
|
|
|
|
* lua :
|
|
|
|
[source,lua]
|
|
----------------------------------------
|
|
weechat.register("test_lua", "FlashCode", "1.0", "GPL3", "Script de test", "", "")
|
|
weechat.print("", "Bonjour, du script lua !")
|
|
----------------------------------------
|
|
|
|
* tcl :
|
|
|
|
[source,tcl]
|
|
----------------------------------------
|
|
weechat::register "test_tcl" "FlashCode" "1.0" "GPL3" "Script de test" "" ""
|
|
weechat::print "" "Bonjour, du script tcl !"
|
|
----------------------------------------
|
|
|
|
* guile (scheme):
|
|
|
|
[source,lisp]
|
|
----------------------------------------
|
|
(weechat:register "test_scheme" "FlashCode" "1.0" "GPL3" "Script de test" "" "")
|
|
(weechat:print "" "Bonjour, du script scheme !")
|
|
----------------------------------------
|
|
|
|
[[load_script]]
|
|
Chargement du script
|
|
~~~~~~~~~~~~~~~~~~~~
|
|
|
|
Vous devez utiliser la commande, dépendant du langage :
|
|
|
|
----------------------------------------
|
|
/python load python/script.py
|
|
/perl load perl/script.pl
|
|
/ruby load ruby/script.rb
|
|
/lua load lua/script.lua
|
|
/tcl load tcl/script.tcl
|
|
/guile load guile/script.scm
|
|
----------------------------------------
|
|
|
|
Vous pouvez faire un lien dans le répertoire 'langage/autoload' pour charger
|
|
automatiquement le script quand WeeChat démarre.
|
|
|
|
Par exemple en Python :
|
|
|
|
----------------------------------------
|
|
$ cd ~/.weechat/python/autoload
|
|
$ ln -s ../script.py
|
|
----------------------------------------
|
|
|
|
[[differences_with_c_api]]
|
|
Différences avec l'API C
|
|
------------------------
|
|
|
|
L'API script est quasiment identique à l'API C.
|
|
Vous pouvez consulter la 'Référence API Extension WeeChat' pour le détail de
|
|
chaque fonction de l'API : prototype, paramètres, valeurs de retour, exemples.
|
|
|
|
Il est important de bien faire la différence entre une 'extension' et un
|
|
'script' : une 'extension' est un fichier binaire compilé et chargé avec la
|
|
commande `/plugin`, tandis qu'un 'script' est un fichier texte chargé par une
|
|
extension comme 'python' par la commande `/python`.
|
|
|
|
Quand votre script 'test.py' appelle une fonction de l'API WeeChat, le chemin
|
|
est le suivant :
|
|
|
|
........................................
|
|
(API script) (API C)
|
|
\/ \/
|
|
test.py -------> extension python (python.so) -------> WeeChat core
|
|
........................................
|
|
|
|
Quand WeeChat appelle un "callback" dans votre script 'test.py', le chemin
|
|
est inversé :
|
|
|
|
........................................
|
|
(API C) (API script)
|
|
\/ \/
|
|
WeeChat core -------> extension plugin (python.so) -------> test.py
|
|
........................................
|
|
|
|
[[pointers]]
|
|
Pointeurs
|
|
~~~~~~~~~
|
|
|
|
Comme vous le savez probablement, il n'y a pas vraiment de "pointeurs" dans les
|
|
scripts. Donc quand les fonctions de l'API retournent un pointeur, il est
|
|
converti en chaîne pour le script.
|
|
|
|
Par exemple, si une fonction retourne le pointeur 0x1234ab56, le script recevra
|
|
la chaîne "0x1234ab56".
|
|
|
|
Et quand une fonction de l'API attend un pointeur dans ses paramètres, le
|
|
script doit envoyer cette valeur sous forme de chaîne. L'extension C la
|
|
convertira en pointeur réel avant d'appeler la fonction de l'API C.
|
|
|
|
Une chaîne vide ou "0x0" sont autorisées, cela signifie le pointeur NULL en C.
|
|
Par exemple, pour afficher un message sur le tampon core (tampon principal
|
|
WeeChat), vous pouvez faire :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
weechat.prnt("", "bonjour !")
|
|
----------------------------------------
|
|
|
|
[WARNING]
|
|
Dans beaucoup de fonctions, pour des raisons de vitesse, WeeChat ne vérifie pas
|
|
si votre pointeur est correct ou pas. Il est de votre responsabilité de
|
|
vérifier que vous donnez un pointeur valide, sinon vous pourriez voir un joli
|
|
rapport de crash ;)
|
|
|
|
[[callbacks]]
|
|
Callbacks
|
|
~~~~~~~~~
|
|
|
|
Tous les "callbacks" WeeChat doivent retourner WEECHAT_RC_OK ou
|
|
WEECHAT_RC_ERROR (l'exception est le callback du "modifier", qui retourne une
|
|
chaîne de caractères).
|
|
|
|
Les "callbacks" C utilisent un paramètre "data", qui est un pointeur. Dans
|
|
l'API script, ce "data" est une chaîne de caractères avec n'importe quelle
|
|
valeur (ce n'est pas un pointeur).
|
|
|
|
Par exemple :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
weechat.hook_timer(1000, 0, 1, "mon_timer_cb", "mes données")
|
|
|
|
def mon_timer_cb(data, remaining_calls):
|
|
# cela affichera : "mes données"
|
|
weechat.prnt("", data)
|
|
return weechat.WEECHAT_RC_OK
|
|
----------------------------------------
|
|
|
|
[[script_api]]
|
|
API script
|
|
----------
|
|
|
|
Pour plus d'informations sur les fonctions de l'API, merci de consulter la
|
|
'Référence API Extension WeeChat'.
|
|
|
|
[[script_api_functions]]
|
|
Fonctions
|
|
~~~~~~~~~
|
|
|
|
Liste des fonctions de l'API script :
|
|
|
|
[width="100%",cols="^1,10",options="header"]
|
|
|========================================
|
|
| Catégorie | Fonctions
|
|
| général |
|
|
register
|
|
| extensions |
|
|
plugin_get_name
|
|
| chaînes |
|
|
charset_set, iconv_to_internal, iconv_from_internal, gettext, ngettext, +
|
|
string_match, string_has_highlight, string_has_highlight_regex,
|
|
string_mask_to_regex, string_remove_color, string_is_command_char,
|
|
string_input_for_buffer
|
|
| répertoires |
|
|
mkdir_home, mkdir, mkdir_parents
|
|
| listes triées |
|
|
list_new, list_add, list_search, list_search_pos, list_casesearch,
|
|
list_casesearch_pos, list_get, list_set, list_next, list_prev, list_string,
|
|
list_size, list_remove, list_remove_all, list_free
|
|
| fichiers de configuration |
|
|
config_new, config_new_section, config_search_section, config_new_option,
|
|
config_search_option, +
|
|
config_string_to_boolean, config_option_reset, config_option_set,
|
|
config_option_set_null, config_option_unset, config_option_rename,
|
|
config_option_is_null, config_option_default_is_null, +
|
|
config_boolean, config_boolean_default, config_integer, config_integer_default,
|
|
config_string, config_string_default, config_color, config_color_default, +
|
|
config_write_option, config_write_line, config_write, config_read,
|
|
config_reload, +
|
|
config_option_free, config_section_free_options, config_section_free,
|
|
config_free, +
|
|
config_get, config_get_plugin, config_is_set_plugin, config_set_plugin,
|
|
config_set_desc_plugin, config_unset_plugin
|
|
| associations de touches |
|
|
key_bind, key_unbind
|
|
| affichage |
|
|
prefix, color, print (for python: prnt), print_date_tags (for python:
|
|
prnt_date_tags), print_y (for python: prnt_y), log_print
|
|
| hooks |
|
|
hook_command, hook_command_run, hook_timer, hook_fd, hook_process,
|
|
hook_process_hashtable, hook_connect, hook_print, hook_signal,
|
|
hook_signal_send, hook_hsignal, hook_hsignal_send, hook_config,
|
|
hook_completion, hook_completion_list_add, hook_modifier, hook_modifier_exec,
|
|
hook_info, hook_info_hashtable, hook_infolist, hook_focus, unhook, unhook_all
|
|
| tampons |
|
|
buffer_new, current_buffer, buffer_search, buffer_search_main, buffer_clear,
|
|
buffer_close, buffer_merge, buffer_unmerge, buffer_get_integer,
|
|
buffer_get_string, buffer_get_pointer, buffer_set,
|
|
buffer_string_replace_local_var, buffer_match_list
|
|
| fenêtres |
|
|
current_window, window_search_with_buffer, window_get_integer,
|
|
window_get_string, window_get_pointer, window_set_title
|
|
| liste des pseudos |
|
|
nicklist_add_group, nicklist_search_group, nicklist_add_nick,
|
|
nicklist_search_nick, nicklist_remove_group, nicklist_remove_nick,
|
|
nicklist_remove_all, nicklist_group_get_integer, nicklist_group_get_string,
|
|
nicklist_group_get_pointer, nicklist_group_set, nicklist_nick_get_integer,
|
|
nicklist_nick_get_string, nicklist_nick_get_pointer, nicklist_nick_set
|
|
| barres |
|
|
bar_item_search, bar_item_new, bar_item_update, bar_item_remove, bar_search,
|
|
bar_new, bar_set, bar_update, bar_remove
|
|
| commandes |
|
|
command
|
|
| infos |
|
|
info_get, info_get_hashtable
|
|
| infolists |
|
|
infolist_new, infolist_new_item, infolist_new_var_integer,
|
|
infolist_new_var_string, infolist_new_var_pointer, infolist_new_var_time, +
|
|
infolist_get, infolist_next, infolist_prev, infolist_reset_item_cursor, +
|
|
infolist_fields, infolist_integer, infolist_string, infolist_pointer, +
|
|
infolist_time, infolist_free
|
|
| hdata |
|
|
hdata_get, hdata_get_var_offset, hdata_get_var_type_string,
|
|
hdata_get_var_hdata, hdata_get_list, hdata_check_pointer, hdata_move,
|
|
hdata_char, hdata_integer, hdata_long, hdata_string, hdata_pointer,
|
|
hdata_time, hdata_hashtable, hdata_get_string
|
|
| mise à jour |
|
|
upgrade_new, upgrade_write_object, upgrade_read, upgrade_close
|
|
|========================================
|
|
|
|
[[script_api_constants]]
|
|
Constantes
|
|
~~~~~~~~~~
|
|
|
|
Liste des constantes de l'API script :
|
|
|
|
[width="100%",cols="^1,10",options="header"]
|
|
|========================================
|
|
| Catégorie | Constantes
|
|
| codes retour |
|
|
WEECHAT_RC_OK, WEECHAT_RC_OK_EAT, WEECHAT_RC_ERROR
|
|
| fichiers de configuration |
|
|
WEECHAT_CONFIG_READ_OK, WEECHAT_CONFIG_READ_MEMORY_ERROR,
|
|
WEECHAT_CONFIG_READ_FILE_NOT_FOUND, WEECHAT_CONFIG_WRITE_OK,
|
|
WEECHAT_CONFIG_WRITE_ERROR, WEECHAT_CONFIG_WRITE_MEMORY_ERROR, +
|
|
WEECHAT_CONFIG_OPTION_SET_OK_CHANGED, WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE,
|
|
WEECHAT_CONFIG_OPTION_SET_ERROR, WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND,
|
|
WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET, WEECHAT_CONFIG_OPTION_UNSET_OK_RESET,
|
|
WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED, WEECHAT_CONFIG_OPTION_UNSET_ERROR
|
|
| listes triées |
|
|
WEECHAT_LIST_POS_SORT, WEECHAT_LIST_POS_BEGINNING, WEECHAT_LIST_POS_END
|
|
| hotlist |
|
|
WEECHAT_HOTLIST_LOW, WEECHAT_HOTLIST_MESSAGE, WEECHAT_HOTLIST_PRIVATE,
|
|
WEECHAT_HOTLIST_HIGHLIGHT
|
|
| hook process |
|
|
WEECHAT_HOOK_PROCESS_RUNNING, WEECHAT_HOOK_PROCESS_ERROR
|
|
| hook connect |
|
|
WEECHAT_HOOK_CONNECT_OK, WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND,
|
|
WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND, WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED,
|
|
WEECHAT_HOOK_CONNECT_PROXY_ERROR, WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR,
|
|
WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR, WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR,
|
|
WEECHAT_HOOK_CONNECT_MEMORY_ERROR
|
|
| hook signal |
|
|
WEECHAT_HOOK_SIGNAL_STRING, WEECHAT_HOOK_SIGNAL_INT, WEECHAT_HOOK_SIGNAL_POINTER
|
|
|========================================
|
|
|
|
[[common_tasks]]
|
|
Tâches courantes
|
|
----------------
|
|
|
|
Ce chapitre montre quelques tâches courantes, avec des exemples.
|
|
Seule une partie de l'API est utilisée ici, pour une référence complète, voir la
|
|
'Référence API Extension WeeChat'.
|
|
|
|
[[buffers]]
|
|
Tampons
|
|
~~~~~~~
|
|
|
|
[[buffers_display_messages]]
|
|
Afficher des messages
|
|
^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
Une chaîne vide est souvent utilisée pour travailler avec le tampon core WeeChat.
|
|
Pour les autres tampons, vous devez passer un pointeur (sous forme de chaîne,
|
|
voir <<pointers,pointeurs>>).
|
|
|
|
Exemples :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
# afficher "bonjour" sur le tampon core
|
|
weechat.prnt("", "bonjour")
|
|
|
|
# afficher "bonjour" sur le tampon core, mais ne pas l'écrire dans le fichier de log
|
|
# (version >= 0.3.3 seulement)
|
|
weechat.prnt_date_tags("", 0, "no_log", "bonjour")
|
|
|
|
# afficher le préfixe "==>" et le message "bonjour" sur le tampon courant
|
|
# (le préfixe et le message doivent être séparés par une tabulation)
|
|
weechat.prnt(weechat.current_buffer(), "==>\tbonjour")
|
|
|
|
# afficher un message d'erreur sur le tampon core (avec le préfixe d'erreur)
|
|
weechat.prnt("", "%smauvais paramètres" % weechat.prefix("error"))
|
|
|
|
# afficher un message avec de la couleur sur le tampon core
|
|
weechat.prnt("", "texte %sjaune sur bleu" % weechat.color("yellow,blue"))
|
|
|
|
# chercher un tampon et afficher un message
|
|
# (le nom complet d'un tampon est extension.nom, par exemple : "irc.freenode.#weechat")
|
|
buffer = weechat.buffer_search("irc", "freenode.#weechat")
|
|
weechat.prnt(buffer, "message sur le canal #weechat")
|
|
|
|
# autre solution pour chercher un tampon IRC (meilleure)
|
|
# (notez que le serveur et le canal sont séparés par une virgule)
|
|
buffer = weechat.info_get("irc_buffer", "freenode,#weechat")
|
|
weechat.prnt(buffer, "message sur le canal #weechat")
|
|
----------------------------------------
|
|
|
|
[NOTE]
|
|
La fonction d'affichage est appelée `print` en Perl/Ruby/Lua/Tcl et `prnt` en
|
|
Python.
|
|
|
|
[[buffers_send_text]]
|
|
Envoyer du texte au tampon
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
Vous pouvez envoyer du texte ou une commande à un tampon. C'est exactement comme
|
|
si vous tapiez le texte sur la ligne de commande et que vous pressiez [Enter].
|
|
|
|
Exemples :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
# exécuter la commande "/help" sur le tampon core
|
|
weechat.command("", "/help")
|
|
|
|
# envoyer "bonjour" au canal IRC #weechat (les utilisateurs sur le canal verront le message)
|
|
buffer = weechat.info_get("irc_buffer", "freenode,#weechat")
|
|
weechat.command(buffer, "bonjour")
|
|
----------------------------------------
|
|
|
|
[[buffers_new]]
|
|
Créer un nouveau tampon
|
|
^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
Vous pouvez créer un nouveau tampon dans votre script, et l'utiliser pour
|
|
afficher des messages.
|
|
|
|
Deux "callbacks" peuvent être appelés (ils sont optionnels) : un pour les données
|
|
en entrée (quand vous tapez du texte et pressez [Enter] sur le tampon), l'autre
|
|
est appelé lorsque le tampon est fermé (par exemple avec `/buffer close`).
|
|
|
|
Exemple :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
# callback pour les données reçues en entrée
|
|
def buffer_input_cb(data, buffer, input_data):
|
|
# ...
|
|
return weechat.WEECHAT_RC_OK
|
|
|
|
# callback appelé lorsque le tampon est fermé
|
|
def buffer_close_cb(data, buffer):
|
|
# ...
|
|
return weechat.WEECHAT_RC_OK
|
|
|
|
# créer le tampon
|
|
buffer = weechat.buffer_new("montampon", "buffer_input_cb", "", "buffer_close_cb", "")
|
|
|
|
# définir le titre
|
|
weechat.buffer_set(buffer, "title", "Ceci est le titre du tampon.")
|
|
|
|
# désactiver l'enregistrement (log), en définissant la variable locale "no_log" à "1"
|
|
weechat.buffer_set(buffer, "localvar_set_no_log", "1")
|
|
----------------------------------------
|
|
|
|
[[buffers_properties]]
|
|
Propriétés du tampon
|
|
^^^^^^^^^^^^^^^^^^^^
|
|
|
|
Vous pouvez lire des propriétés du tampon, sous forme de chaîne, entier ou
|
|
pointeur.
|
|
|
|
Exemples :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
buffer = weechat.current_buffer()
|
|
|
|
number = weechat.buffer_get_integer(buffer, "number")
|
|
name = weechat.buffer_get_string(buffer, "name")
|
|
short_name = weechat.buffer_get_string(buffer, "short_name")
|
|
----------------------------------------
|
|
|
|
Il est possible d'ajouter, lire ou supprimer des variables locales dans le
|
|
tampon :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
# ajouter une variable locale
|
|
weechat.buffer_set(buffer, "localvar_set_myvar", "my_value")
|
|
|
|
# lire une variable locale
|
|
myvar = weechat.buffer_get_string(buffer, "localvar_myvar")
|
|
|
|
# supprimer une variable locale
|
|
weechat.buffer_set(buffer, "localvar_del_myvar", "")
|
|
----------------------------------------
|
|
|
|
Pour voir les variables locales d'un tampon, exécutez cette commande dans
|
|
WeeChat :
|
|
|
|
----------------------------------------
|
|
/buffer localvar
|
|
----------------------------------------
|
|
|
|
[[hooks]]
|
|
Hooks
|
|
~~~~~
|
|
|
|
[[hook_command]]
|
|
Ajouter une nouvelle commande
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
Ajoutez une nouvelle commande avec `hook_command`. Vous pouvez utiliser une
|
|
complétion personnalisée pour compléter les paramètres de votre commande.
|
|
|
|
Exemple :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
def my_command_cb(data, buffer, args):
|
|
# ...
|
|
return weechat.WEECHAT_RC_OK
|
|
|
|
hook = weechat.hook_command("monfiltre", "description de mon filtre",
|
|
"[list] | [enable|disable|toggle [name]] | [add name plugin.buffer tags regex] | [del name|-all]",
|
|
"description des paramètres...",
|
|
"list"
|
|
" || enable %(filters_names)"
|
|
" || disable %(filters_names)"
|
|
" || toggle %(filters_names)"
|
|
" || add %(filters_names) %(buffers_plugins_names)|*"
|
|
" || del %(filters_names)|-all",
|
|
"my_command_cb", "")
|
|
----------------------------------------
|
|
|
|
Puis sous WeeChat :
|
|
|
|
----------------------------------------
|
|
/help monfiltre
|
|
|
|
/monfiltre paramètres...
|
|
----------------------------------------
|
|
|
|
[[hook_timer]]
|
|
Ajouter un timer
|
|
^^^^^^^^^^^^^^^^
|
|
|
|
Ajoutez un timer avec `hook_timer`.
|
|
|
|
Exemple :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
def timer_cb(data, remaining_calls):
|
|
# ...
|
|
return weechat.WEECHAT_RC_OK
|
|
|
|
# timer appelé chaque minute quand la seconde est 00
|
|
weechat.hook_timer(60 * 1000, 60, 0, "timer_cb", "")
|
|
----------------------------------------
|
|
|
|
[[hook_process]]
|
|
Lancer un processus en tâche de fond
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
Vous pouvez lancer un processus en tâche de fond avec `hook_process`. Votre
|
|
"callback" sera appelé quand des données seront prêtes. Il peut être appelé
|
|
plusieurs fois.
|
|
|
|
Pour le dernier appel à votre "callback", 'rc' est positionné à 0 ou une valeur
|
|
positive, c'est le code retour de la commande.
|
|
|
|
Exemple :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
process_output = ""
|
|
|
|
def my_process_cb(data, command, rc, out, err):
|
|
global process_output
|
|
if out != "":
|
|
process_output += out
|
|
if int(rc) >= 0:
|
|
weechat.prnt("", process_output)
|
|
return weechat.WEECHAT_RC_OK
|
|
|
|
weechat.hook_process("/bin/ls -l /etc", 10 * 1000, "my_process_cb", "")
|
|
----------------------------------------
|
|
|
|
[[url_transfer]]
|
|
Transfert d'URL
|
|
^^^^^^^^^^^^^^^
|
|
|
|
_Nouveau dans la version 0.3.7._
|
|
|
|
Pour télécharger une URL (ou poster vers une URL), vous devez utiliser la
|
|
fonction `hook_process`, ou `hook_process_hashtable` si vous avez besoin
|
|
d'options pour le transfert d'URL.
|
|
|
|
Exemple de transfert d'URL sans option : la page HTML sera reçue comme "out"
|
|
dans le "callback" (sortie standard du processus) :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
# Afficher la version des noyaux Linux.
|
|
kernel_txt = ""
|
|
|
|
def kernel_process_cb(data, command, rc, out, err):
|
|
global kernel_txt
|
|
if out != "":
|
|
kernel_txt += out
|
|
if int(rc) >= 0:
|
|
weechat.prnt("", kernel_txt)
|
|
return weechat.WEECHAT_RC_OK
|
|
|
|
weechat.hook_process("url:http://www.kernel.org/kdist/finger_banner",
|
|
30 * 1000, "kernel_process_cb", "")
|
|
----------------------------------------
|
|
|
|
Exemple de transfert d'URL avec une option : télécharger le dernier paquet de
|
|
développement WeeChat dans le fichier '/tmp/weechat-devel.tar.gz' :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
def my_process_cb(data, command, rc, out, err):
|
|
if int(rc) >= 0:
|
|
weechat.prnt("", "Fin du transfert (rc=%s)" % rc)
|
|
return weechat.WEECHAT_RC_OK
|
|
|
|
weechat.hook_process_hashtable("url:http://weechat.org/files/src/weechat-devel.tar.gz",
|
|
{ "file_out": "/tmp/weechat-devel.tar.gz" },
|
|
30 * 1000, "my_process_cb", "")
|
|
----------------------------------------
|
|
|
|
Pour plus d'information sur le transfert d'URL et les options disponibles, voir
|
|
les fonctions `hook_process` et `hook_process_hashtable` dans la
|
|
'Référence API Extension WeeChat'.
|
|
|
|
[[config_options]]
|
|
Config / options
|
|
~~~~~~~~~~~~~~~~
|
|
|
|
[[config_options_set_script]]
|
|
Définir des options pour le script
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
La fonction `config_is_set_plugin` est utilisée pour vérifier si une option est
|
|
définie ou pas, et `config_set_plugin` pour définir une option.
|
|
|
|
Exemple :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
script_options = {
|
|
"option1" : "valeur1",
|
|
"option2" : "valeur2",
|
|
"option3" : "valeur3",
|
|
}
|
|
for option, default_value in script_options.iteritems():
|
|
if not weechat.config_is_set_plugin(option):
|
|
weechat.config_set_plugin(option, default_value)
|
|
----------------------------------------
|
|
|
|
[[config_options_detect_changes]]
|
|
Détecter des changements
|
|
^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
Vous devez utiliser `hook_config` pour être notifié si l'utilisateur modifie
|
|
certaines options du script.
|
|
|
|
Exemple :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
SCRIPT_NAME = "monscript"
|
|
|
|
# ...
|
|
|
|
def config_cb(data, option, value):
|
|
"""Callback appelé lorsqu'une option du script est modifiée."""
|
|
# par exemple, relire toutes les options du script dans des variables du script...
|
|
# ...
|
|
return weechat.WEECHAT_RC_OK
|
|
|
|
# ...
|
|
|
|
weechat.hook_config("plugins.var.python." + SCRIPT_NAME + ".*", "config_cb", "")
|
|
# pour les autres languages, remplacez "python" par le language ("perl", "ruby", "lua" ou "tcl")
|
|
----------------------------------------
|
|
|
|
[[config_options_weechat]]
|
|
Lire les options WeeChat
|
|
^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
La fonction `config_get` retourne un pointeur vers une option. Ensuite, en
|
|
fonction du type de l'option, il faut appeler `config_string`, `config_boolean`,
|
|
`config_integer` ou `config_color`.
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
# chaîne
|
|
weechat.prnt("", "la valeur de l'option weechat.look.item_time_format est : %s"
|
|
% (weechat.config_string(weechat.config_get("weechat.look.item_time_format"))))
|
|
|
|
# booléen
|
|
weechat.prnt("", "la valeur de l'option weechat.look.day_change est : %d"
|
|
% (weechat.config_boolean(weechat.config_get("weechat.look.day_change"))))
|
|
|
|
# entier
|
|
weechat.prnt("", "la valeur de l'option weechat.look.scroll_page_percent est : %d"
|
|
% (weechat.config_integer(weechat.config_get("weechat.look.scroll_page_percent"))))
|
|
|
|
# couleur
|
|
weechat.prnt("", "la valeur de l'option weechat.color.chat_delimiters est : %s"
|
|
% (weechat.config_color(weechat.config_get("weechat.color.chat_delimiters"))))
|
|
----------------------------------------
|
|
|
|
[[irc]]
|
|
IRC
|
|
~~~
|
|
|
|
[[irc_catch_messages]]
|
|
Intercepter des messages
|
|
^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
L'extension IRC envoie deux signaux pour un message reçu (`xxx` est le nom
|
|
interne du serveur IRC, `yyy` est le nom de la commande IRC comme JOIN, QUIT,
|
|
PRIVMSG, 301, ..):
|
|
|
|
xxxx,irc_in_yyy::
|
|
signal envoyé avant traitement du message
|
|
|
|
xxx,irc_in2_yyy::
|
|
message sent après traitement du message
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
def join_cb(data, signal, signal_data):
|
|
# signal est par exemple : "freenode,irc_in2_join"
|
|
# signal_data est le message IRC, par exemple : ":nick!user@host JOIN :#canal"
|
|
nick = weechat.info_get("irc_nick_from_host", signal_data)
|
|
server = signal.split(",")[0]
|
|
channel = signal_data.split(":")[-1]
|
|
buffer = weechat.info_get("irc_buffer", "%s,%s" % (server, channel))
|
|
if buffer:
|
|
weechat.prnt(buffer, "Eheh, %s a rejoint le canal !" % nick)
|
|
return weechat.WEECHAT_RC_OK
|
|
|
|
# il est pratique ici d'utiliser "*" comme serveur, pour intercepter les
|
|
# messages JOIN de tous les serveurs IRC
|
|
weechat.hook_signal("*,irc_in2_join", "join_cb", "")
|
|
----------------------------------------
|
|
|
|
[[irc_modify_messages]]
|
|
Modifier des messages
|
|
^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
L'extension IRC envoie un "modifier" appelé "irc_in_xxx" ("xxx" est la commande
|
|
IRC) pour un message reçu, de sorte que vous puissiez le modifier.
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
def modifier_cb(data, modifier, modifier_data, string):
|
|
# ajouter le nom du serveur à tous les messages reçus
|
|
# (ok ce n'est pas très utile, mais c'est juste un exemple !)
|
|
return "%s %s" % (string, modifier_data)
|
|
|
|
weechat.hook_modifier("irc_in_privmsg", "modifier_cb", "")
|
|
----------------------------------------
|
|
|
|
[WARNING]
|
|
Un message mal formé peut provoquer un plantage de WeeChat ou de sérieux
|
|
problèmes !
|
|
|
|
[[irc_message_parse]]
|
|
Analyser un message
|
|
^^^^^^^^^^^^^^^^^^^
|
|
|
|
_Nouveau dans la version 0.3.4._
|
|
|
|
Vous pouvez analyser un message IRC avec l'info_hashtable appelée
|
|
"irc_message_parse".
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
dict = weechat.info_get_hashtable("irc_message_parse",
|
|
{ "message": ":nick!user@host PRIVMSG #weechat :message ici" })
|
|
weechat.prnt("", "dict: %s" % dict)
|
|
|
|
# output:
|
|
# dict: {'nick': 'nick', 'host': 'nick!user@host', 'command': 'PRIVMSG', 'arguments': '#weechat :message ici', 'channel': '#weechat'}
|
|
----------------------------------------
|
|
|
|
[[infos]]
|
|
Infos
|
|
~~~~~
|
|
|
|
[[infos_weechat_version]]
|
|
Version de WeeChat
|
|
^^^^^^^^^^^^^^^^^^
|
|
|
|
Le meilleur moyen de vérifier la version est de demander "version_number" et de
|
|
faire une comparaison entre nombre entiers avec la version hexadécimale de la
|
|
version.
|
|
|
|
Exemple :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
version = weechat.info_get("version_number", "") or 0
|
|
if int(version) >= 0x00030200:
|
|
weechat.prnt("", "C'est WeeChat 0.3.2 ou plus récent")
|
|
else:
|
|
weechat.prnt("", "C'est WeeChat 0.3.1 ou plus ancien")
|
|
----------------------------------------
|
|
|
|
[NOTE]
|
|
Les versions ≤ 0.3.1.1 retournent une chaîne vide pour
|
|
'info_get("version_number")', donc vous devez vérifier que la valeur de retour
|
|
n'est *pas* vide.
|
|
|
|
Pour obtenir la version sous forme de chaîne :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
# ceci affichera par exemple "Version 0.3.2"
|
|
weechat.prnt("", "Version %s" % weechat.info_get("version", ""))
|
|
----------------------------------------
|
|
|
|
[[infos_other]]
|
|
Autres infos
|
|
^^^^^^^^^^^^
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
# répertoire de WeeChat, par exemple : "/home/xxxx/.weechat"
|
|
weechat.prnt("", "Répertoire WeeChat : %s" % weechat.info_get("weechat_dir", ""))
|
|
|
|
# inactivité clavier
|
|
weechat.prnt("", "Inactivité depuis %s secondes" % weechat.info_get("inactivity", ""))
|
|
----------------------------------------
|
|
|
|
[[infolists]]
|
|
Infolists
|
|
~~~~~~~~~
|
|
|
|
[[infolists_read]]
|
|
Lire une infolist
|
|
^^^^^^^^^^^^^^^^^
|
|
|
|
Vous pouvez lire une infolist construite par WeeChat ou d'autres extensions.
|
|
|
|
Exemple :
|
|
|
|
[source,python]
|
|
----------------------------------------
|
|
# lecture de l'infolist "buffer", pour avoir la liste des tampons
|
|
infolist = weechat.infolist_get("buffer", "", "")
|
|
if infolist:
|
|
while weechat.infolist_next(infolist):
|
|
name = weechat.infolist_string(infolist, "name")
|
|
weechat.prnt("", "buffer: %s" % name)
|
|
weechat.infolist_free(infolist)
|
|
----------------------------------------
|
|
|
|
[IMPORTANT]
|
|
N'oubliez pas d'appeler `infolist_free` pour libérer la mémoire utilisée par
|
|
l'infolist, car WeeChat ne libère par automatiquement cette mémoire.
|