diff options
Diffstat (limited to 'doc/fr')
28 files changed, 2806 insertions, 3344 deletions
diff --git a/doc/fr/autogen/plugin_api/completions.txt b/doc/fr/autogen/plugin_api/completions.txt index bcfbca0a2..cd5b602d0 100644 --- a/doc/fr/autogen/plugin_api/completions.txt +++ b/doc/fr/autogen/plugin_api/completions.txt @@ -1,5 +1,5 @@ [width="65%",cols="^1,^2,8",options="header"] -|======================================== +|=== | Extension | Nom | Description | alias | alias | liste des alias @@ -130,4 +130,4 @@ | xfer | nick | pseudos de la discussion DCC -|======================================== +|=== diff --git a/doc/fr/autogen/plugin_api/infolists.txt b/doc/fr/autogen/plugin_api/infolists.txt index ed220a15a..0115a5902 100644 --- a/doc/fr/autogen/plugin_api/infolists.txt +++ b/doc/fr/autogen/plugin_api/infolists.txt @@ -1,5 +1,5 @@ [width="100%",cols="^1,^2,5,5,5",options="header"] -|======================================== +|=== | Extension | Nom | Description | Pointeur | Paramètres | alias | alias | liste des alias | pointeur vers l'alias (optionnel) | nom d'alias (peut démarrer ou se terminer par "*" comme joker) (optionnel) @@ -70,4 +70,4 @@ | xfer | xfer | liste des xfer | pointeur vers le xfer (optionnel) | - -|======================================== +|=== diff --git a/doc/fr/autogen/plugin_api/infos.txt b/doc/fr/autogen/plugin_api/infos.txt index 8c72cab34..a377bb2a5 100644 --- a/doc/fr/autogen/plugin_api/infos.txt +++ b/doc/fr/autogen/plugin_api/infos.txt @@ -1,5 +1,5 @@ [width="100%",cols="^1,^2,6,6",options="header"] -|======================================== +|=== | Extension | Nom | Description | Paramètres | aspell | aspell_dict | liste de dictionnaires (séparés par des virgules) utilisés sur le tampon | pointeur vers un tampon ("0x12345678") ou nom complet de tampon ("irc.freenode.#weechat") @@ -62,4 +62,4 @@ | weechat | weechat_upgrading | 1 si WeeChat est en cours de mise à jour (commande `/upgrade`) | - -|======================================== +|=== diff --git a/doc/fr/autogen/plugin_api/infos_hashtable.txt b/doc/fr/autogen/plugin_api/infos_hashtable.txt index 0f3d1061d..a0c817620 100644 --- a/doc/fr/autogen/plugin_api/infos_hashtable.txt +++ b/doc/fr/autogen/plugin_api/infos_hashtable.txt @@ -1,9 +1,9 @@ [width="100%",cols="^1,^2,6,6,6",options="header"] -|======================================== +|=== | Extension | Nom | Description | Hashtable (entrée) | Hashtable (sortie) | irc | irc_message_parse | analyse un message IRC | "message": message IRC, "server": nom du serveur (optionnel) | "tags": étiquettes, "message_without_tags": message sans les étiquettes, "nick": pseudo, "host": nom d'hôte, "command": commande, "channel": canal, "arguments": paramètres (inclut le canal) | irc | irc_message_split | découper un message IRC (pour tenir dans les 512 octets) | "message": message IRC, "server": nom du serveur (optionnel) | "msg1" ... "msgN": messages à envoyer (sans le "\r\n" final), "args1" ... "argsN": paramètres des messages, "count": nombre de messages -|======================================== +|=== diff --git a/doc/fr/autogen/plugin_api/url_options.txt b/doc/fr/autogen/plugin_api/url_options.txt index c92a2ded9..4e38d55f0 100644 --- a/doc/fr/autogen/plugin_api/url_options.txt +++ b/doc/fr/autogen/plugin_api/url_options.txt @@ -1,5 +1,5 @@ [width="100%",cols="2,^1,7",options="header"] -|======================================== +|=== | Option | Type | Constantes ^(1)^ | verbose | long | @@ -298,4 +298,4 @@ | new_directory_perms | long | -|======================================== +|=== diff --git a/doc/fr/autogen/user/alias_commands.txt b/doc/fr/autogen/user/alias_commands.txt index 5c1387bb8..c61e01240 100644 --- a/doc/fr/autogen/user/alias_commands.txt +++ b/doc/fr/autogen/user/alias_commands.txt @@ -1,7 +1,7 @@ [[command_alias_alias]] [command]*`alias`* créer un alias pour une commande:: ----------------------------------------- +---- /alias [-completion <complétion>] alias [<commande> [;<commande>...]] complétion: complétion pour l'alias (optionnel, par défaut la complétion se fait avec la commande cible) @@ -30,5 +30,5 @@ Exemples: /alias hello /allchan -exclude=#weechat msg * hello alias /forcejoin pour envoyer la commande IRC "forcejoin" avec la complétion de /sajoin : /alias -completion %%sajoin forcejoin /quote forcejoin ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/aspell_commands.txt b/doc/fr/autogen/user/aspell_commands.txt index ab43f1e9f..903fde0ce 100644 --- a/doc/fr/autogen/user/aspell_commands.txt +++ b/doc/fr/autogen/user/aspell_commands.txt @@ -1,7 +1,7 @@ [[command_aspell_aspell]] [command]*`aspell`* configuration de l'extension aspell:: ----------------------------------------- +---- /aspell enable|disable|toggle listdict setdict <dict>[,<dict>...] @@ -23,5 +23,5 @@ Pour activer aspell sur tous les tampons, utilisez l'option "default_dict", par /aspell enable La touche par défaut pour activer/désactiver aspell est alt-s. ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/charset_commands.txt b/doc/fr/autogen/user/charset_commands.txt index 5b87f2132..3859a1aa3 100644 --- a/doc/fr/autogen/user/charset_commands.txt +++ b/doc/fr/autogen/user/charset_commands.txt @@ -1,7 +1,7 @@ [[command_charset_charset]] [command]*`charset`* changer le charset pour le tampon courant:: ----------------------------------------- +---- /charset decode|encode <charset> reset @@ -9,5 +9,5 @@ encode: changer le charset d'encodage charset: nouveau charset pour le tampon courant reset: réinitialiser les charsets pour le tampon courant ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/guile_commands.txt b/doc/fr/autogen/user/guile_commands.txt index 57b2bc065..706b0981d 100644 --- a/doc/fr/autogen/user/guile_commands.txt +++ b/doc/fr/autogen/user/guile_commands.txt @@ -1,7 +1,7 @@ [[command_guile_guile]] [command]*`guile`* lister/charger/décharger des scripts:: ----------------------------------------- +---- /guile list|listfull [<nom>] load [-q] <fichier> autoload @@ -18,5 +18,5 @@ autoload: charger tous les scripts dans le répertoire "autoload" -q: mode silencieux: ne pas afficher de messages Sans paramètre, cette commande liste les scripts chargés. ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/irc_commands.txt b/doc/fr/autogen/user/irc_commands.txt index 2e5f746b4..13768489a 100644 --- a/doc/fr/autogen/user/irc_commands.txt +++ b/doc/fr/autogen/user/irc_commands.txt @@ -1,16 +1,16 @@ [[command_irc_admin]] [command]*`admin`* trouver les informations sur l'administrateur du serveur:: ----------------------------------------- +---- /admin [<cible>] cible: serveur ----------------------------------------- +---- [[command_irc_allchan]] [command]*`allchan`* exécuter une commande sur tous les canaux de tous les serveurs connectés:: ----------------------------------------- +---- /allchan [-current] [-exclude=<canal>[,<canal>...]] <commande> [<paramètres>] -current: exécuter la commande pour les canaux du serveur courant seulement @@ -25,12 +25,12 @@ Exemples: /allchan -exclude=#weechat msg * bonjour dire 'bonjour' partout sauf sur #weechat et les canaux commençant par #linux: /allchan -exclude=#weechat,#linux* msg * bonjour ----------------------------------------- +---- [[command_irc_allserv]] [command]*`allserv`* exécuter une commande sur tous les serveurs connectés:: ----------------------------------------- +---- /allserv [-exclude=<serveur>[,<serveur>...]] <commande> [<paramètres>] -exclude: exclude certains serveurs ('*' est autorisé en début ou fin du nom du serveur, pour exclure plusieurs serveurs) @@ -44,24 +44,24 @@ Exemples: /allserv away Je suis absent faire un whois sur mon pseudo sur tous les serveurs: /allserv whois $nick ----------------------------------------- +---- [[command_irc_ban]] [command]*`ban`* bannir des pseudos ou hôtes:: ----------------------------------------- +---- /ban [<canal>] [<pseudo> [<pseudo>...]] canal: nom du canal pour supprimer le bannissement pseudo: pseudo ou hôte pour supprimer le bannissement Sans paramètre, cette commande affiche la liste des bans pour le canal courant. ----------------------------------------- +---- [[command_irc_connect]] [command]*`connect`* se connecter à un/plusieurs serveur(s) IRC:: ----------------------------------------- +---- /connect [<serveur> [<serveur>...] [-<option>[=<valeur>]] [-no<option>] [-nojoin] [-switch] -all|-auto|-open [-nojoin] [-switch] @@ -85,33 +85,33 @@ Exemples: /connect my.server.org/6697 -ssl -password=test /connect irc://nick@irc.oftc.net/#channel /connect -switch ----------------------------------------- +---- [[command_irc_ctcp]] [command]*`ctcp`* envoyer un message CTCP (Client-To-Client Protocol):: ----------------------------------------- +---- /ctcp <cible> <type> [<arguments>] cible: pseudo ou canal à qui envoyer le CTCP type: type de CTCP (exemples: "version", "ping", etc...) arguments: paramètres pour le CTCP ----------------------------------------- +---- [[command_irc_cycle]] [command]*`cycle`* quitter et rejoindre un canal:: ----------------------------------------- +---- /cycle [<canal>[,<canal>...]] [message] canal: canal à quitter message: message de fin (affiché aux autres utilisateurs) ----------------------------------------- +---- [[command_irc_dcc]] [command]*`dcc`* démarrer un DCC (transfert de fichier ou discussion directe):: ----------------------------------------- +---- /dcc chat <pseudo> send <pseudo> <fichier> @@ -123,76 +123,76 @@ Exemples: /dcc chat toto envoyer le fichier "/home/foo/bar.txt" au pseudo "toto": /dcc send toto /home/foo/bar.txt ----------------------------------------- +---- [[command_irc_dehalfop]] [command]*`dehalfop`* retirer le statut de demi-opérateur du canal à/aux pseudo(s):: ----------------------------------------- +---- /dehalfop <pseudo> [<pseudo>...] pseudo: pseudo ou masque (peut démarrer ou se terminer par "*" comme joker) *: retirer le statut de demi-opérateur de tout le monde sur le canal excepté vous-même ----------------------------------------- +---- [[command_irc_deop]] [command]*`deop`* retirer le statut d'opérateur du canal à/aux pseudo(s):: ----------------------------------------- +---- /deop <pseudo> [<pseudo>...] * -yes pseudo: pseudo ou masque (peut démarrer ou se terminer par "*" comme joker) *: retirer le statut d'opérateur de tout le monde sur le canal excepté vous-même ----------------------------------------- +---- [[command_irc_devoice]] [command]*`devoice`* retirer la voix du/des pseudo(s):: ----------------------------------------- +---- /devoice <pseudo> [<pseudo>...] * -yes pseudo: pseudo ou masque (peut démarrer ou se terminer par "*" comme joker) *: retirer la voix de tout le monde sur le canal ----------------------------------------- +---- [[command_irc_die]] [command]*`die`* arrêter le serveur:: ----------------------------------------- +---- /die [<cible>] cible: nom du serveur ----------------------------------------- +---- [[command_irc_disconnect]] [command]*`disconnect`* se déconnecter d'un ou de tous les serveurs IRC:: ----------------------------------------- +---- /disconnect [<serveur>|-all|-pending [<raison>]] serveur: nom du serveur pour se déconnecter -all: se déconnecter de tous les serveurs -pending: annuler la reconnexion automatique sur les serveurs en cours de reconnexion raison: raison pour le quit ----------------------------------------- +---- [[command_irc_halfop]] [command]*`halfop`* donner le statut de demi-opérateur à un/des pseudo(s):: ----------------------------------------- +---- /halfop <pseudo> [<pseudo>...] * -yes pseudo: pseudo ou masque (peut démarrer ou se terminer par "*" comme joker) *: donner le statut de demi-opérateur à tout le monde sur le canal ----------------------------------------- +---- [[command_irc_ignore]] [command]*`ignore`* ignorer des pseudos/hôtes de serveurs ou canaux:: ----------------------------------------- +---- /ignore list add [re:]<pseudo> [<serveur> [<canal>]] del <numéro>|-all @@ -215,40 +215,40 @@ Exemples: /ignore add toto@domain.com freenode ignorer le hôte "toto*@*.domain.com" sur freenode/#weechat: /ignore add toto*@*.domain.com freenode #weechat ----------------------------------------- +---- [[command_irc_info]] [command]*`info`* voir les informations décrivant le serveur:: ----------------------------------------- +---- /info [<cible>] cible: nom du serveur ----------------------------------------- +---- [[command_irc_invite]] [command]*`invite`* inviter un pseudo sur un canal:: ----------------------------------------- +---- /invite <pseudo> [<pseudo>...] [<canal>] pseudo: pseudo à inviter canal: canal pour l'invitation ----------------------------------------- +---- [[command_irc_ison]] [command]*`ison`* vérifier si un pseudo est actuellement sur IRC:: ----------------------------------------- +---- /ison <pseudo> [<pseudo>...] pseudo: pseudo ----------------------------------------- +---- [[command_irc_join]] [command]*`join`* rejoindre un canal:: ----------------------------------------- +---- /join [-noswitch] [-server <serveur>] [<canal1>[,<canal2>...]] [<clé1>[,<clé2>...]] -noswitch: ne pas basculer sur le nouveau tampon @@ -261,23 +261,23 @@ Exemples: /join #protectedchan,#weechat key /join -server freenode #weechat /join -noswitch #weechat ----------------------------------------- +---- [[command_irc_kick]] [command]*`kick`* retirer par la force un utilisateur d'un canal:: ----------------------------------------- +---- /kick [<canal>] <pseudo> [<raison>] canal: canal où l'utilisateur se trouve pseudo: pseudo à éliminer raison: raison pour l'élimination (les variables spéciales $nick, $channel et $server sont remplacées par leur valeur) ----------------------------------------- +---- [[command_irc_kickban]] [command]*`kickban`* retirer par la force un pseudo d'un canal et le bannir:: ----------------------------------------- +---- /kickban [<canal>] <pseudo> [<raison>] canal: canal où l'utilisateur se trouve @@ -289,32 +289,32 @@ Il est possible d'éliminer/bannir avec un masque, le pseudo sera extrait du mas Exemple: bannir "*!*@host.com" puis éliminer "toto": /kickban toto!*@host.com ----------------------------------------- +---- [[command_irc_kill]] [command]*`kill`* fermer la connexion client-serveur:: ----------------------------------------- +---- /kill <pseudo> <raison> pseudo: pseudo raison: raison ----------------------------------------- +---- [[command_irc_links]] [command]*`links`* lister tous les noms de serveurs connus du serveur qui répondent à la requête:: ----------------------------------------- +---- /links [[<serveur>] <masque_serveur>] serveur: ce serveur doit répondre à la requête masque_serveur: liste des serveurs correspondant au masque ----------------------------------------- +---- [[command_irc_list]] [command]*`list`* lister les canaux et leur titre:: ----------------------------------------- +---- /list [<canal>[,<canal>...]] [<serveur>] [-re <regex>] canal: canal à lister @@ -328,37 +328,37 @@ Exemples: /list #weechat lister tous les canaux commençant par "#weechat" (peut être très lent pour les grands réseaux): /list -re #weechat.* ----------------------------------------- +---- [[command_irc_lusers]] [command]*`lusers`* obtenir des statistiques sur la taille du réseau IRC:: ----------------------------------------- +---- /lusers [<masque> [<cible>]] masque: serveurs qui correspondent au masque seulement cible: serveur pour faire suivre la requête ----------------------------------------- +---- [[command_irc_map]] [command]*`map`* afficher une carte graphique du réseau IRC:: ----------------------------------------- ----------------------------------------- +---- +---- [[command_irc_me]] [command]*`me`* envoyer une action CTCP au canal courant:: ----------------------------------------- +---- /me <message> message: message à envoyer ----------------------------------------- +---- [[command_irc_mode]] [command]*`mode`* changer le mode du canal ou de l'utilisateur:: ----------------------------------------- +---- /mode [<canal>] [+|-]o|p|s|i|t|n|m|l|b|e|v|k [<paramètres>] <pseudo> [+|-]i|s|w|o @@ -390,62 +390,62 @@ Exemples: /mode #weechat +t devenir invisible sur le serveur: /mode nick +i ----------------------------------------- +---- [[command_irc_motd]] [command]*`motd`* obtenir le message du jour:: ----------------------------------------- +---- /motd [<cible>] cible: nom du serveur ----------------------------------------- +---- [[command_irc_msg]] [command]*`msg`* envoyer un message à un pseudo ou canal:: ----------------------------------------- +---- /msg [-server <serveur>] <cible>[,<cible>...] <texte> serveur: envoyer à ce serveur (nom interne) cible: pseudo ou canal (peut-être un masque, '*' = canal courant) texte: texte à envoyer ----------------------------------------- +---- [[command_irc_names]] [command]*`names`* lister les pseudos sur des canaux:: ----------------------------------------- +---- /names [<canal>[,<canal>...]] canal: nom du canal ----------------------------------------- +---- [[command_irc_nick]] [command]*`nick`* changer le pseudo courant:: ----------------------------------------- +---- /nick [-all] <pseudo> -all: définir le nouveau pseudo sur tous les serveurs connectés pseudo: nouveau pseudo ----------------------------------------- +---- [[command_irc_notice]] [command]*`notice`* envoyer un message notice à un utilisateur:: ----------------------------------------- +---- /notice [-server <serveur>] <cible> <texte> serveur: envoyer à ce serveur (nom interne) cible: pseudo ou canal texte: texte à envoyer ----------------------------------------- +---- [[command_irc_notify]] [command]*`notify`* ajouter une notification de présence ou de statut d'absence pour des pseudos sur les serveurs:: ----------------------------------------- +---- /notify add <pseudo> [<serveur> [-away]] del <pseudo>|-all [<serveur>] @@ -465,96 +465,96 @@ Exemples: /notify add toto freenode notifier quand "toto" est absent ou de retour sur le serveur freenode: /notify add toto freenode -away ----------------------------------------- +---- [[command_irc_op]] [command]*`op`* donner le statut d'opérateur à un/des pseudo(s):: ----------------------------------------- +---- /op <pseudo> [<pseudo>...] * -yes pseudo: pseudo ou masque (peut démarrer ou se terminer par "*" comme joker) *: donner le statut d'opérateur à tout le monde sur le canal ----------------------------------------- +---- [[command_irc_oper]] [command]*`oper`* obtenir le statut d'opérateur:: ----------------------------------------- +---- /oper <utilisateur> <mot_de_passe> utilisateur: utilisateur mot_de_passe: mot de passe ----------------------------------------- +---- [[command_irc_part]] [command]*`part`* quitter un canal:: ----------------------------------------- +---- /part [<canal>[,<canal>...]] [message] canal: canal à quitter message: message de fin (affiché aux autres utilisateurs) ----------------------------------------- +---- [[command_irc_ping]] [command]*`ping`* envoyer un ping au serveur:: ----------------------------------------- +---- /ping <serveur1> [<serveur2>] serveur1: serveur serveur2: faire suivre le ping à ce serveur ----------------------------------------- +---- [[command_irc_pong]] [command]*`pong`* répondre à un message ping:: ----------------------------------------- +---- /pong <démon> [<démon2>] démon: démon qui a répondu au message Ping démon2: faire suivre le message à ce démon ----------------------------------------- +---- [[command_irc_query]] [command]*`query`* envoyer un message privé à un pseudo:: ----------------------------------------- +---- /query [-server <serveur>] <pseudo>[,<pseudo>...] [<texte>] serveur: envoyer à ce serveur (nom interne) pseudo: pseudo pour la conversation privée texte: texte à envoyer ----------------------------------------- +---- [[command_irc_quiet]] [command]*`quiet`* faire taire des pseudos ou hôtes:: ----------------------------------------- +---- /quiet [<canal>] [<pseudo> [<pseudo>...]] canal: nom du canal pour faire taire pseudo: pseudo ou hôte à faire taire Sans paramètre, cette commande affiche la liste des "quiet" pour le canal courant. ----------------------------------------- +---- [[command_irc_quote]] [command]*`quote`* envoyer des données brutes au serveur sans analyse:: ----------------------------------------- +---- /quote [-server <serveur>] <données> serveur: envoyer à ce serveur (nom interne) données: données brutes à envoyer ----------------------------------------- +---- [[command_irc_reconnect]] [command]*`reconnect`* se reconnecter à un/plusieurs serveur(s):: ----------------------------------------- +---- /reconnect <serveur> [<serveur>...] [-nojoin] [-switch] -all [-nojoin] [-switch] @@ -562,80 +562,80 @@ serveur: nom du serveur pour se reconnecter -all: se reconnecter à tous les serveurs -nojoin: ne rejoindre aucun canal (même si l'autojoin est activé pour le serveur) -switch: basculer vers l'adresse suivante du serveur ----------------------------------------- +---- [[command_irc_rehash]] [command]*`rehash`* demander au serveur de recharger son fichier de configuration:: ----------------------------------------- +---- /rehash [<option>] option: option supplémentaire, pour certains serveurs ----------------------------------------- +---- [[command_irc_restart]] [command]*`restart`* demander au serveur de redémarrer:: ----------------------------------------- +---- /restart [<cible>] cible: nom du serveur ----------------------------------------- +---- [[command_irc_sajoin]] [command]*`sajoin`* forcer un utilisateur à rejoindre un ou plusieurs canaux:: ----------------------------------------- +---- /sajoin <pseudo> <canal>[,<canal>...] pseudo: pseudo canal: canal ----------------------------------------- +---- [[command_irc_samode]] [command]*`samode`* changer le mode du canal, sans avoir le statut d'opérateur:: ----------------------------------------- +---- /samode <canal> <mode> canal: nom du canal mode: mode pour le canal ----------------------------------------- +---- [[command_irc_sanick]] [command]*`sanick`* forcer un utilisateur à utiliser un autre pseudo:: ----------------------------------------- +---- /sanick <pseudo> <nouveau_pseudo> pseudo: pseudo nouveau_pseudo: nouveau pseudo ----------------------------------------- +---- [[command_irc_sapart]] [command]*`sapart`* forcer un utilisateur à quitter un ou plusieurs canaux:: ----------------------------------------- +---- /sapart <pseudo> <canal>[,<canal>...] pseudo: pseudo canal: canal ----------------------------------------- +---- [[command_irc_saquit]] [command]*`saquit`* forcer un utilisateur à quitter le serveur avec une raison:: ----------------------------------------- +---- /saquit <pseudo> <raison> pseudo: pseudo raison: raison ----------------------------------------- +---- [[command_irc_server]] [command]*`server`* lister, ajouter ou retirer des serveurs IRC:: ----------------------------------------- +---- /server list|listfull [<serveur>] add <serveur> <nom>[/<port>] [-temp] [-<option>[=<valeur>]] [-no<option>] copy|rename <serveur> <nouveau_nom> @@ -668,179 +668,179 @@ Exemples: /server rename oftc newoftc /server del freenode /server deloutq ----------------------------------------- +---- [[command_irc_service]] [command]*`service`* enregistrer un nouveau service:: ----------------------------------------- +---- /service <pseudo> <réservé> <distribution> <type> <réservé> <info> distribution: visibilité du service type: réservé pour une utilisation future ----------------------------------------- +---- [[command_irc_servlist]] [command]*`servlist`* lister les services actuellement connectés au réseau:: ----------------------------------------- +---- /servlist [<masque> [<type>]] masque: lister seulement les services qui correspondent à ce masque type: lister seulement les services de ce type ----------------------------------------- +---- [[command_irc_squery]] [command]*`squery`* envoyer un message à un service:: ----------------------------------------- +---- /squery <service> <texte> service: nom du service texte: texte à envoyer ----------------------------------------- +---- [[command_irc_squit]] [command]*`squit`* déconnecter les liens vers un serveur:: ----------------------------------------- +---- /squit <serveur> <commentaire> serveur: nom du serveur commentaire: commentaire pour quitter ----------------------------------------- +---- [[command_irc_stats]] [command]*`stats`* demander des statistiques sur le serveur:: ----------------------------------------- +---- /stats [<requête> [<serveur>]] requête: c/h/i/k/l/m/o/y/u (voir la RFC1459) serveur: nom du serveur ----------------------------------------- +---- [[command_irc_summon]] [command]*`summon`* envoyer aux utilisateurs d'un serveur IRC un message leur demandant de rejoindre IRC:: ----------------------------------------- +---- /summon <utilisateur> [<cible> [<canal>]] utilisateur: nom d'utilisateur cible: nom du serveur canal: nom du canal ----------------------------------------- +---- [[command_irc_time]] [command]*`time`* demander l'heure locale de serveur:: ----------------------------------------- +---- /time [<cible>] cible: demander l'heure de ce serveur ----------------------------------------- +---- [[command_irc_topic]] [command]*`topic`* recevoir/définir le titre du canal:: ----------------------------------------- +---- /topic [<canal>] [<titre>|-delete] canal: nom du canal titre: nouveau titre pour le canal -delete: supprime le titre du canal ----------------------------------------- +---- [[command_irc_trace]] [command]*`trace`* trouver le chemin jusqu'à un serveur spécifique:: ----------------------------------------- +---- /trace [<cible>] cible: serveur ----------------------------------------- +---- [[command_irc_unban]] [command]*`unban`* supprimer le bannissement sur des pseudos ou hôtes:: ----------------------------------------- +---- /unban [<canal>] <pseudo> [<pseudo>...] canal: nom du canal pour supprimer le bannissement pseudo: pseudo ou hôte pour supprimer le bannissement ----------------------------------------- +---- [[command_irc_userhost]] [command]*`userhost`* retourner une liste d'informations sur des pseudos:: ----------------------------------------- +---- /userhost <pseudo> [<pseudo>...] pseudo: pseudo ----------------------------------------- +---- [[command_irc_users]] [command]*`users`* liste des utilisateurs connectés au serveur:: ----------------------------------------- +---- /users [<cible>] cible: serveur ----------------------------------------- +---- [[command_irc_version]] [command]*`version`* retourner la version du pseudo ou du serveur (courant ou spécifié):: ----------------------------------------- +---- /version [<serveur>|<pseudo>] serveur: nom du serveur pseudo: pseudo ----------------------------------------- +---- [[command_irc_voice]] [command]*`voice`* donner la voix à/aux pseudo(s):: ----------------------------------------- +---- /voice <pseudo> [<pseudo>...] pseudo: pseudo ou masque (peut démarrer ou se terminer par "*" comme joker) *: donner la voix à tout le monde sur le canal ----------------------------------------- +---- [[command_irc_wallchops]] [command]*`wallchops`* envoyer une notice aux opérateurs du canal:: ----------------------------------------- +---- /wallchops [<canal>] <texte> canal: nom du canal texte: texte à envoyer ----------------------------------------- +---- [[command_irc_wallops]] [command]*`wallops`* envoyer un message à tous les utilisateurs connectés qui ont activé le mode utilisateur 'w' pour eux-mêmes:: ----------------------------------------- +---- /wallops <texte> texte: texte à envoyer ----------------------------------------- +---- [[command_irc_who]] [command]*`who`* générer une requête qui retourne une liste d'information:: ----------------------------------------- +---- /who [<masque> [o]] masque: information qui correspond à ce masque uniquement o: seul les opérateurs sont retournés correspondant au masque fourni ----------------------------------------- +---- [[command_irc_whois]] [command]*`whois`* demander les informations sur le(s) utilisateur(s):: ----------------------------------------- +---- /whois [<serveur>] [<pseudo>[,<pseudo>...]] serveur: nom de serveur @@ -849,16 +849,16 @@ serveur: nom de serveur Sans paramètre, cette commande effectuera un whois sur : - votre propre pseudo si le tampon est un serveur/canal - le pseudo distant si le tampon est un privé. ----------------------------------------- +---- [[command_irc_whowas]] [command]*`whowas`* demander de l'information sur un pseudo qui n'existe plus:: ----------------------------------------- +---- /whowas <pseudo>[,<pseudo>...] [<nombre> [<cible>]] pseudo: pseudo à chercher nombre: nombre de réponses à retourner (recherche complète si nombre négatif) cible: la réponse doit correspondre à ce masque ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/logger_commands.txt b/doc/fr/autogen/user/logger_commands.txt index 4eca477a6..13b5c1465 100644 --- a/doc/fr/autogen/user/logger_commands.txt +++ b/doc/fr/autogen/user/logger_commands.txt @@ -1,7 +1,7 @@ [[command_logger_logger]] [command]*`logger`* configuration de l'extension logger:: ----------------------------------------- +---- /logger list set <niveau> flush @@ -33,5 +33,5 @@ Exemples: /set logger.level.core.weechat 0 utiliser un répertoire par serveur IRC et un fichier par canal dedans: /set logger.mask.irc "$server/$channel.weechatlog" ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/lua_commands.txt b/doc/fr/autogen/user/lua_commands.txt index 6bd3248f0..4d0ca455f 100644 --- a/doc/fr/autogen/user/lua_commands.txt +++ b/doc/fr/autogen/user/lua_commands.txt @@ -1,7 +1,7 @@ [[command_lua_lua]] [command]*`lua`* lister/charger/décharger des scripts:: ----------------------------------------- +---- /lua list|listfull [<nom>] load [-q] <fichier> autoload @@ -18,5 +18,5 @@ autoload: charger tous les scripts dans le répertoire "autoload" -q: mode silencieux: ne pas afficher de messages Sans paramètre, cette commande liste les scripts chargés. ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/perl_commands.txt b/doc/fr/autogen/user/perl_commands.txt index f22fbcbf4..441730ec6 100644 --- a/doc/fr/autogen/user/perl_commands.txt +++ b/doc/fr/autogen/user/perl_commands.txt @@ -1,7 +1,7 @@ [[command_perl_perl]] [command]*`perl`* lister/charger/décharger des scripts:: ----------------------------------------- +---- /perl list|listfull [<nom>] load [-q] <fichier> autoload @@ -18,5 +18,5 @@ autoload: charger tous les scripts dans le répertoire "autoload" -q: mode silencieux: ne pas afficher de messages Sans paramètre, cette commande liste les scripts chargés. ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/python_commands.txt b/doc/fr/autogen/user/python_commands.txt index 1a41e1efb..22333b387 100644 --- a/doc/fr/autogen/user/python_commands.txt +++ b/doc/fr/autogen/user/python_commands.txt @@ -1,7 +1,7 @@ [[command_python_python]] [command]*`python`* lister/charger/décharger des scripts:: ----------------------------------------- +---- /python list|listfull [<nom>] load [-q] <fichier> autoload @@ -18,5 +18,5 @@ autoload: charger tous les scripts dans le répertoire "autoload" -q: mode silencieux: ne pas afficher de messages Sans paramètre, cette commande liste les scripts chargés. ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/relay_commands.txt b/doc/fr/autogen/user/relay_commands.txt index 9ee27725c..d86c1ce9f 100644 --- a/doc/fr/autogen/user/relay_commands.txt +++ b/doc/fr/autogen/user/relay_commands.txt @@ -1,7 +1,7 @@ [[command_relay_relay]] [command]*`relay`* contrôle du relai:: ----------------------------------------- +---- /relay list|listfull|listrelay add [ipv4.][ipv6.][ssl.]<protocole.nom> <port> del [ipv4.][ipv6.][ssl.]<protocole.nom> @@ -42,5 +42,5 @@ Exemples: /relay add ipv6.ssl.weechat 9001 protocole weechat avec SSL, en utilisant IPv4 + IPv6: /relay add ipv4.ipv6.ssl.weechat 9001 ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/rmodifier_commands.txt b/doc/fr/autogen/user/rmodifier_commands.txt index affab9061..36dd40b5f 100644 --- a/doc/fr/autogen/user/rmodifier_commands.txt +++ b/doc/fr/autogen/user/rmodifier_commands.txt @@ -1,7 +1,7 @@ [[command_rmodifier_rmodifier]] [command]*`rmodifier`* modifier des chaînes de "modifier" avec des expressions régulières:: ----------------------------------------- +---- /rmodifier list|listdefault add <nom> <modifiers> <groupes> <regex> del <nom>|-all [<nom>...] @@ -27,5 +27,5 @@ Exemples: /rmodifier del password supprimer tous les rmodifiers: /rmodifier del -all ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/ruby_commands.txt b/doc/fr/autogen/user/ruby_commands.txt index 5a3f7ff3b..bc2788abd 100644 --- a/doc/fr/autogen/user/ruby_commands.txt +++ b/doc/fr/autogen/user/ruby_commands.txt @@ -1,7 +1,7 @@ [[command_ruby_ruby]] [command]*`ruby`* lister/charger/décharger des scripts:: ----------------------------------------- +---- /ruby list|listfull [<nom>] load [-q] <fichier> autoload @@ -18,5 +18,5 @@ autoload: charger tous les scripts dans le répertoire "autoload" -q: mode silencieux: ne pas afficher de messages Sans paramètre, cette commande liste les scripts chargés. ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/script_commands.txt b/doc/fr/autogen/user/script_commands.txt index e5c99dd82..e4804de52 100644 --- a/doc/fr/autogen/user/script_commands.txt +++ b/doc/fr/autogen/user/script_commands.txt @@ -1,7 +1,7 @@ [[command_script_script]] [command]*`script`* Gestionnaire de scripts WeeChat:: ----------------------------------------- +---- /script list [-o|-i] search <texte> show <script> @@ -73,5 +73,5 @@ Exemples: /script hold urlserver.py /script reload urlserver /script upgrade ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/tcl_commands.txt b/doc/fr/autogen/user/tcl_commands.txt index a56bf427c..ba9226145 100644 --- a/doc/fr/autogen/user/tcl_commands.txt +++ b/doc/fr/autogen/user/tcl_commands.txt @@ -1,7 +1,7 @@ [[command_tcl_tcl]] [command]*`tcl`* lister/charger/décharger des scripts:: ----------------------------------------- +---- /tcl list|listfull [<nom>] load [-q] <fichier> autoload @@ -18,5 +18,5 @@ autoload: charger tous les scripts dans le répertoire "autoload" -q: mode silencieux: ne pas afficher de messages Sans paramètre, cette commande liste les scripts chargés. ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/weechat_commands.txt b/doc/fr/autogen/user/weechat_commands.txt index dc40833ab..aa96dcd27 100644 --- a/doc/fr/autogen/user/weechat_commands.txt +++ b/doc/fr/autogen/user/weechat_commands.txt @@ -1,17 +1,17 @@ [[command_weechat_away]] [command]*`away`* définir ou supprimer le statut d'absence:: ----------------------------------------- +---- /away [-all] [<message>] -all: définir ou supprimer le statut d'absence sur tous les serveurs connectés message: message pour l'absence (si pas de message donné, le statut d'absence est supprimé) ----------------------------------------- +---- [[command_weechat_bar]] [command]*`bar`* gestion des barres:: ----------------------------------------- +---- /bar list|listfull|listitems add <nom> <type>[,<conditions>] <position> <taille> <séparateur> <objet1>[,<objet2>...] default [input|title|status|nicklist] @@ -58,12 +58,12 @@ Exemples: /bar scroll nicklist * y+10 faire défiler la liste des pseudos à la fin sur le tampon courant: /bar scroll nicklist * ye ----------------------------------------- +---- [[command_weechat_buffer]] [command]*`buffer`* gestion des tampons:: ----------------------------------------- +---- /buffer list clear [<nombre>|<nom>|-merged|-all] move|merge <nombre> @@ -120,12 +120,12 @@ Exemples: /buffer #weechat aller au tampon suivant: /buffer +1 ----------------------------------------- +---- [[command_weechat_color]] [command]*`color`* définir des alias de couleurs et afficher la palette des couleurs:: ----------------------------------------- +---- /color alias <couleur> <nom> unalias <couleur> reset @@ -145,22 +145,22 @@ Exemples: /color alias 214 orange supprimer la couleur 214: /color unalias 214 ----------------------------------------- +---- [[command_weechat_command]] [command]*`command`* lancer explicitement une commande WeeChat ou d'une extension:: ----------------------------------------- +---- /command <extension> <commande> extension: nom de l'extension ('weechat' pour une commande interne WeeChat) commande: commande à exécuter (un '/' est automatiquement ajouté s'il n'est pas trouvé au début de la commande) ----------------------------------------- +---- [[command_weechat_cursor]] [command]*`cursor`* mouvement libre du curseur sur l'écran pour exécuter des actions sur des zones spécifiques de l'écran:: ----------------------------------------- +---- /cursor go chat|<barre>|<x>,<y> move up|down|left|right|area_up|area_down|area_left|area_right stop @@ -178,12 +178,12 @@ Exemples: /cursor go nicklist aller aux coordonnées x=10, y=5: /cursor go 10,5 ----------------------------------------- +---- [[command_weechat_debug]] [command]*`debug`* contrôle du debug pour le cœur/les extensions:: ----------------------------------------- +---- /debug list set <extension> <niveau> dump [<extension>] @@ -208,12 +208,12 @@ infolists: afficher des infos sur les infolists tags: afficher les étiquettes pour les lignes term: afficher des infos sur le terminal windows: afficher l'arbre des fenêtres ----------------------------------------- +---- [[command_weechat_eval]] [command]*`eval`* évaluer une expression et envoyer le résultat au tampon:: ----------------------------------------- +---- /eval [-n] <expression> [-n] -c <expression1> <opérateur> <expression2> @@ -266,12 +266,12 @@ Exemples: /eval -n -c abcd =~ (?-i)^ABC ==> 0 /eval -n -c abcd =~ (?-i)^abc ==> 1 /eval -n -c abcd !~ abc ==> 0 ----------------------------------------- +---- [[command_weechat_filter]] [command]*`filter`* filtrer les messages dans les tampons, pour les cacher/afficher selon des tags ou expressions régulières:: ----------------------------------------- +---- /filter list enable|disable|toggle [<nom>] add <nom> <tampon>[,<tampon>...] <tags> <regex> @@ -320,12 +320,12 @@ Exemples: /filter add toto irc.freenode.#weechat nick_toto * filtrer les lignes contenant "weechat sucks" sur le canal IRC #weechat: /filter add sucks irc.freenode.#weechat * weechat sucks ----------------------------------------- +---- [[command_weechat_help]] [command]*`help`* afficher l'aide sur les commandes et les options:: ----------------------------------------- +---- /help -list|-listfull [<extension> [<extension>...]] <commande> <option> @@ -335,23 +335,23 @@ Exemples: extension: lister les commandes de cette extension commande: un nom de commande option: un nom d'option (utilisez /set pour voir la liste) ----------------------------------------- +---- [[command_weechat_history]] [command]*`history`* afficher l'historique des commandes du tampon:: ----------------------------------------- +---- /history clear <valeur> clear: effacer l'historique valeur: nombre d'entrées dans l'historique à afficher ----------------------------------------- +---- [[command_weechat_input]] [command]*`input`* fonctions pour la ligne de commande:: ----------------------------------------- +---- /input <action> [<paramètres>] liste des actions: @@ -406,12 +406,12 @@ liste des actions: paste_stop: fin de collage (mode "bracketed paste") Cette commande est utilisé par les associations de touches ou les extensions. ----------------------------------------- +---- [[command_weechat_key]] [command]*`key`* associer/libérer des touches:: ----------------------------------------- +---- /key list|listdefault|listdiff [<contexte>] bind <touche> [<commande> [<args>]] bindctxt <contexte> <touche> [<commande> [<args>]] @@ -461,12 +461,12 @@ Exemples: /key bindctxt search ctrl-I /input search_stop bouton du milieu de la souris sur un pseudo pour récupérer les infos sur le pseudo: /key bindctxt mouse @item(buffer_nicklist):button3 /msg nickserv info ${nick} ----------------------------------------- +---- [[command_weechat_layout]] [command]*`layout`* sauver/appliquer/réinitialiser la disposition des tampons et fenêtres:: ----------------------------------------- +---- /layout save [<nom>] [buffers|windows] apply [<nom>] [buffers|windows] leave @@ -484,12 +484,12 @@ buffers: sauver/appliquer seulement pour les tampons (ordre des tampons) windows: sauver/appliquer seulement pour les fenêtres (le tampon affiché par chaque fenêtre) Sans paramètre, cette commande affiche les dispositions sauvegardées. ----------------------------------------- +---- [[command_weechat_mouse]] [command]*`mouse`* contrôle de la souris:: ----------------------------------------- +---- /mouse enable|disable|toggle [<délai>] enable: activer la souris @@ -504,12 +504,12 @@ Exemples: /mouse enable activer/désactiver la souris pendant 5 secondes: /mouse toggle 5 ----------------------------------------- +---- [[command_weechat_mute]] [command]*`mute`* exécuter une commande silencieusement:: ----------------------------------------- +---- /mute [-current | -buffer <nom> | -all] commande -current: pas d'affichage sur le tampon courant @@ -527,12 +527,12 @@ Exemples: /mute -current msg * bonjour ! message au canal #weechat: /mute -buffer irc.freenode.#weechat msg #weechat bonjour ! ----------------------------------------- +---- [[command_weechat_plugin]] [command]*`plugin`* lister/charger/décharger des extensions:: ----------------------------------------- +---- /plugin list|listfull [<nom>] load <fichier> [<paramètres>] autoload [<paramètres>] @@ -550,12 +550,12 @@ Exemples: paramètres: paramètres donnés à l'extension lors de son chargement Sans paramètre, cette commande liste les extensions chargées. ----------------------------------------- +---- [[command_weechat_proxy]] [command]*`proxy`* gestion des proxies:: ----------------------------------------- +---- /proxy list add <nom> <type> <adresse> <port> [<utilisateur> [<mot_de_passe>]] del <nom>|-all @@ -584,34 +584,34 @@ Exemples: /proxy add myproxy socks5 sample.host.org 3128 myuser mypass supprimer un proxy: /proxy del myproxy ----------------------------------------- +---- [[command_weechat_quit]] [command]*`quit`* quitter WeeChat:: ----------------------------------------- +---- /quit [-yes] [<paramètres>] -yes: requis si l'option weechat.look.confirm_quit est activée paramètres: texte envoyé avec le signal "quit" (par exemple l'extension irc utilise ce texte pour envoyer le message de quit au serveur) ----------------------------------------- +---- [[command_weechat_reload]] [command]*`reload`* recharger les fichiers de configuration depuis le disque:: ----------------------------------------- +---- /reload [<fichier> [<fichier>...]] fichier: fichier de configuration à recharger (sans l'extension ".conf") Sans paramètre, tous les fichiers (WeeChat et extensions) sont rechargés. ----------------------------------------- +---- [[command_weechat_repeat]] [command]*`repeat`* exécuter une commande plusieurs fois:: ----------------------------------------- +---- /repeat [-interval <délai>] <nombre> <commande> délai: délai entre l'exécution des commandes (en millisecondes) @@ -623,23 +623,23 @@ Toutes les commandes sont exécutées sur le tampon où la commande a été lanc Exemple: faire défiler de 2 pages vers le haut: /repeat 2 /window page_up ----------------------------------------- +---- [[command_weechat_save]] [command]*`save`* sauvegarder les fichiers de configuration sur disque:: ----------------------------------------- +---- /save [<fichier> [<fichier>...]] fichier: fichier de configuration à sauvegarder (sans l'extension ".conf") Sans paramètre, tous les fichiers (WeeChat et extensions) sont sauvegardés. ----------------------------------------- +---- [[command_weechat_secure]] [command]*`secure`* gestion des données sécurisées (mots de passe ou données privées chiffrés dans le fichier sec.conf):: ----------------------------------------- +---- /secure passphrase <phrase de chiffrement>|-delete decrypt <phrase de chiffrement>|-discard set <nom> <valeur> @@ -676,12 +676,12 @@ Exemples : /set irc.server.oftc.command "/msg nickserv identify ${sec.data.oftc}" alias pour ghost du pseudo "pseudo" : /alias ghost /eval /msg -server freenode nickserv ghost pseudo ${sec.data.freenode} ----------------------------------------- +---- [[command_weechat_set]] [command]*`set`* modifier des options de configuration:: ----------------------------------------- +---- /set [<option> [<valeur>]] diff [<option> [<option>...]] @@ -706,12 +706,12 @@ Exemples: /set diff afficher les options modifiées dans l'extension irc: /set diff irc.* ----------------------------------------- +---- [[command_weechat_unset]] [command]*`unset`* supprimer/réinitialiser des options de configuration:: ----------------------------------------- +---- /unset <option> option: nom d'une option (peut commencer ou se terminer par "*" pour réinitialiser plusieurs options, à utiliser avec prudence !) @@ -723,12 +723,12 @@ Exemples: /unset weechat.look.item_time_format réinitialiser toutes les options de couleur: /unset weechat.color.* ----------------------------------------- +---- [[command_weechat_upgrade]] [command]*`upgrade`* mettre à jour WeeChat sans se déconnecter des serveurs:: ----------------------------------------- +---- /upgrade [<chemin_vers_binaire>|-quit] chemin_vers_binaire: chemin vers le binaire WeeChat (par défaut le binaire courant) @@ -754,32 +754,32 @@ Avec l'option "-quit", le processus est légèrement différent : Et plus tard vous pouvez restaurer la session avec la commande: weechat --upgrade IMPORTANT: vous devez restaurer la session avec exactement la même configuration (fichiers *.conf). Il est également possible de restaurer la session WeeChat sur une autre machine si vous y copiez le contenu du répertoire "~/.weechat". ----------------------------------------- +---- [[command_weechat_uptime]] [command]*`uptime`* montrer l'uptime de WeeChat:: ----------------------------------------- +---- /uptime [-o | -ol] -o: envoyer l'uptime sur le tampon courant comme entrée (chaîne en anglais) -ol: envoyer l'uptime sur le tampon courant comme entrée (chaîne traduite) ----------------------------------------- +---- [[command_weechat_version]] [command]*`version`* afficher la version de WeeChat et la date de compilation:: ----------------------------------------- +---- /version [-o | -ol] -o: envoyer la version sur le tampon courant comme entrée (chaîne en anglais) -ol: envoyer la version sur le tampon courant comme entrée (chaîne traduite) ----------------------------------------- +---- [[command_weechat_wait]] [command]*`wait`* planifier l'exécution d'une commande dans le futur:: ----------------------------------------- +---- /wait <nombre>[<unité>] <commande> nombre: temps à attendre (nombre entier) @@ -799,12 +799,12 @@ Exemples: /wait 15m /away -all I'm away dire 'bonjour' dans 2 minutes: /wait 2m bonjour ----------------------------------------- +---- [[command_weechat_window]] [command]*`window`* gestion des fenêtres:: ----------------------------------------- +---- /window list -1|+1|b#|up|down|left|right [-window <numéro>] <numéro> @@ -863,5 +863,5 @@ Exemples: /window scroll -d zoom sur la fenêtre numéro 2: /window zoom -window 2 ----------------------------------------- +---- diff --git a/doc/fr/autogen/user/xfer_commands.txt b/doc/fr/autogen/user/xfer_commands.txt index ae67f444e..11cf06b3e 100644 --- a/doc/fr/autogen/user/xfer_commands.txt +++ b/doc/fr/autogen/user/xfer_commands.txt @@ -1,21 +1,21 @@ [[command_xfer_me]] [command]*`me`* envoyer une action CTCP à l'hôte distant:: ----------------------------------------- +---- /me <message> message: message à envoyer ----------------------------------------- +---- [[command_xfer_xfer]] [command]*`xfer`* contrôle xfer:: ----------------------------------------- +---- /xfer [list|listfull] list: lister les xfer listfull: lister les xfer (verbeux) Sans paramètre, cette commande ouvre le tampon avec la liste des xfer. ----------------------------------------- +---- diff --git a/doc/fr/weechat.1.fr.txt b/doc/fr/weechat.1.fr.txt index 1006f0f83..984af25e9 100644 --- a/doc/fr/weechat.1.fr.txt +++ b/doc/fr/weechat.1.fr.txt @@ -1,14 +1,11 @@ -WEECHAT(1) -========== += WEECHAT(1) :doctype: manpage -NOM ---- +== NOM weechat - le client de discussion extensible -SYNOPSIS --------- +== SYNOPSIS [verse] 'weechat' [-a|--no-connect] [-d|--dir <répertoire>] [-p|--no-plugin] [-r|--run-command <commande>] [-s|--no-script] [--upgrade] [extension:option...] @@ -18,21 +15,18 @@ SYNOPSIS 'weechat' [-l|--license] 'weechat' [-v|--version] -DESCRIPTION ------------ +== DESCRIPTION WeeChat est un client de discussion rapide, léger et extensible. Il est modulaire (cœur léger avec des extensions), multi-protocoles (IRC et Jabber), extensible avec du C et des scripts écrits en différents langages. -OPTIONS -------- +== OPTIONS include::cmdline_options.fr.txt[] -OPTIONS D'EXTENSION -------------------- +== OPTIONS D'EXTENSION Pour une documentation complète sur les options des extensions, merci de consulter la documentation des extensions dans le @@ -52,8 +46,7 @@ après, par exemple : irc://monpseudo@[2001:db8:0:85a3::ac1f:8001]:6668/#test -FICHIERS --------- +== FICHIERS $HOME/.weechat/weechat.conf:: fichier de configuration principal de WeeChat @@ -91,8 +84,7 @@ $HOME/.weechat/xfer.conf:: $HOME/.weechat/weechat.log:: fichier de log de WeeChat -AUTEURS -------- +== AUTEURS WeeChat est écrit par Sébastien Helleu et des contributeurs (la liste complète est dans le fichier AUTHORS). @@ -108,8 +100,7 @@ Merci de consulter le fichier COPYING pour plus d'informations. Site web : <http://weechat.org/> -SIGNALER DES BUGS ------------------ +== SIGNALER DES BUGS Merci de signaler les bugs ou demandes de nouvelles fonctionnalités sur le site Savannah : diff --git a/doc/fr/weechat_faq.fr.txt b/doc/fr/weechat_faq.fr.txt index 2cf3848bc..137565660 100644 --- a/doc/fr/weechat_faq.fr.txt +++ b/doc/fr/weechat_faq.fr.txt @@ -1,5 +1,4 @@ -WeeChat FAQ (Questions Fréquemment Posées) -========================================== += WeeChat FAQ (Questions Fréquemment Posées) Sébastien Helleu <flashcode@flashtux.org> @@ -8,12 +7,10 @@ Ce document est écrit pour les versions de WeeChat ≥ 0.3.0 mais devrait être utilisé de préférence avec la dernière version stable de WeeChat. -Général -------- +== Général [[weechat_name]] -D'où vient le nom "WeeChat" ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== D'où vient le nom "WeeChat" ? "Wee" est un acronyme récursif qui signifie "Wee Enhanced Environment". Donc le nom complet est "Wee Enhanced Environment for Chat". @@ -22,20 +19,17 @@ Donc le nom complet est "Wee Enhanced Environment for Chat". mais elle ne s'applique pas à WeeChat !). [[why_choose_weechat]] -Pourquoi choisir WeeChat ? X-Chat et Irssi sont si bien... -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Pourquoi choisir WeeChat ? X-Chat et Irssi sont si bien... Parce que WeeChat est très léger et apporte des fonctionnalités innovantes. Plus d'infos sur cette page : http://weechat.org/about/features [[compilation_install]] -Compilation / installation --------------------------- +== Compilation / installation [[gui]] -J'ai entendu parler de plusieurs interfaces pour WeeChat. Comment puis-je les compiler/utiliser ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== J'ai entendu parler de plusieurs interfaces pour WeeChat. Comment puis-je les compiler/utiliser ? Des interfaces distantes sont disponibles : @@ -45,8 +39,7 @@ Des interfaces distantes sont disponibles : * https://github.com/eirikb/weecloud[weecloud] (Web) [[compile_git]] -Je ne peux pas compiler WeeChat après avoir cloné la base git, pourquoi ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Je ne peux pas compiler WeeChat après avoir cloné la base git, pourquoi ? La méthode recommandée pour compiler WeeChat est d'utiliser cmake. @@ -60,8 +53,7 @@ git et qu'il est moins pratique que de cloner la base git pour installer des mises à jour. [[lost]] -J'ai lancé WeeChat, mais je suis perdu, que puis-je faire ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== J'ai lancé WeeChat, mais je suis perdu, que puis-je faire ? Pour obtenir de l'aide tapez `/help`. Pour de l'aide sur une commande, tapez `/help commande`. Les touches et commandes sont listées dans la documentation. @@ -70,12 +62,10 @@ Il est recommandé pour les nouveaux utilisateurs de lire le guide de démarrage rapide (voir la page de doc sur le site). [[display]] -Affichage ---------- +== Affichage [[charset]] -Je ne vois pas bien certains accents dans WeeChat, que faire ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Je ne vois pas bien certains accents dans WeeChat, que faire ? C'est un problème courant, merci de lire attentivement et vérifier *TOUS* les points ci-dessous : @@ -106,8 +96,7 @@ locale, assurez-vous que *tout* soit configuré en ISO (terminal, screen, ...) et *pas* en UTF-8. [[bars_background]] -Des barres telles que le titre et le statut ne sont pas remplies, la couleur de fond s'arrête après le texte, pourquoi ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Des barres telles que le titre et le statut ne sont pas remplies, la couleur de fond s'arrête après le texte, pourquoi ? Cela peut être du à la variable TERM qui n'a pas la bonne valeur (regardez la sortie de `echo $TERM` dans votre terminal). @@ -122,8 +111,7 @@ Selon la façon de lancer WeeChat, vous devriez avoir : Si besoin, corrigez la variable TERM : `export TERM="xxx"`. [[screen_weird_chars]] -Quand j'utilise weechat sous screen/tmux, j'ai des caractères bizarres et aléatoires, comment corriger ça ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Quand j'utilise weechat sous screen/tmux, j'ai des caractères bizarres et aléatoires, comment corriger ça ? Cela peut être du à la variable TERM qui n'a pas la bonne valeur (regardez la sortie de `echo $TERM` dans votre terminal, *en dehors de screen/tmux*). @@ -134,8 +122,7 @@ Par exemple 'xterm-color' provoque ce genre de problèmes, utilisez Si besoin, corrigez la variable TERM : `export TERM="xxx"`. [[osx_display_broken]] -J'ai compilé WeeChat sous OS X, et je vois des "(null)" partout sur l'écran, pourquoi ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== J'ai compilé WeeChat sous OS X, et je vois des "(null)" partout sur l'écran, pourquoi ? Si vous avez compilé ncursesw vous-même, essayez avec le ncurses standard (celui fourni avec le système). @@ -144,8 +131,7 @@ De plus, sous OS X, il est recommandé d'installer WeeChat avec le gestionnaire de paquets Homebrew. [[buffer_vs_window]] -J'ai entendu parler de "buffer" et "window", quelle est la différence ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== J'ai entendu parler de "buffer" et "window", quelle est la différence ? Un tampon ('buffer') est composé d'un numéro, un nom, des lignes affichées (ainsi que d'autres données). @@ -158,42 +144,39 @@ Chaque fenêtre affiche un tampon. Un tampon peut être caché (affiché par aucune fenêtre) ou affiché par une ou plusieurs fenêtres. [[buffers_list]] -Comment afficher la liste des tampons sur la gauche ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment afficher la liste des tampons sur la gauche ? Utilisez le script 'buffers.pl'. Pour limiter la taille de la barre : ----------------------------------------- +---- /set weechat.bar.buffers.size_max 15 ----------------------------------------- +---- Pour déplacer la barre en bas : ----------------------------------------- +---- /set weechat.bar.buffers.position bottom ----------------------------------------- +---- [[customize_prefix]] -Comment puis-je réduire la longueur des pseudos ou supprimer l'alignement des pseudos dans la zone de discussion ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je réduire la longueur des pseudos ou supprimer l'alignement des pseudos dans la zone de discussion ? Pour réduire la longueur maximum des pseudos dans la zone de discussion : ----------------------------------------- +---- /set weechat.look.prefix_align_max 15 ----------------------------------------- +---- Pour supprimer l'alignement sur les pseudos : ----------------------------------------- +---- /set weechat.look.prefix_align none ----------------------------------------- +---- [[input_bar_size]] -Comment utiliser une ligne de commande sur plusieurs lignes ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment utiliser une ligne de commande sur plusieurs lignes ? L'option 'size' dans la barre input peut être définie à une valeur supérieure à 1 (pour une taille fixe, la taille par défaut est 1) ou 0 pour une taille @@ -202,41 +185,39 @@ limite). Exemple avec une taille dynamique : ----------------------------------------- +---- /set weechat.bar.input.size 0 ----------------------------------------- +---- Taille maximum de 2 : ----------------------------------------- +---- /set weechat.bar.input.size_max 2 ----------------------------------------- +---- [[one_input_root_bar]] -Est-il possible d'avoir une seule bar input pour toutes les fenêtres (après un découpage) ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Est-il possible d'avoir une seule bar input pour toutes les fenêtres (après un découpage) ? Oui, vous devez créer une barre de type "root" (avec un objet pour savoir dans quelle fenêtre vous êtes), puis supprimer la barre input courante. Par exemple : ----------------------------------------- +---- /bar add rootinput root bottom 1 0 [buffer_name]+[input_prompt]+(away),[input_search],[input_paste],input_text /bar del input ----------------------------------------- +---- Si jamais vous n'étiez pas satisfait avec ça, supprimez simplement la nouvelle barre, WeeChat recréera automatiquement la barre par défaut "input" si l'objet "input_text" n'est utilisé dans aucune barre : ----------------------------------------- +---- /bar del rootinput ----------------------------------------- +---- [[terminal_copy_paste]] -Comment puis-je copier/coller du texte sans coller la liste des pseudos ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je copier/coller du texte sans coller la liste des pseudos ? Vous pouvez utiliser un terminal qui propose la sélection rectangulaire (comme rxvt-unicode, konsole, gnome-terminal, etc...). La touche est habituellement @@ -245,32 +226,31 @@ rxvt-unicode, konsole, gnome-terminal, etc...). La touche est habituellement Une autre solution est de déplacer la liste des pseudos en haut ou en bas, par exemple : ----------------------------------------- +---- /set weechat.bar.nicklist.position top ----------------------------------------- +---- [[urls]] -Comment puis-je cliquer sur les longs URLs (plus d'une ligne) ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je cliquer sur les longs URLs (plus d'une ligne) ? Par défaut, WeeChat affiche l'heure et un préfixe pour chaque ligne avec des barres optionnelles autour de la zone de discussion. Pour rendre la le clic d'URL plus facile, vous pouvez déplacer la liste des pseudos en haut et supprimer l'alignement sur les pseudos : ----------------------------------------- +---- /set weechat.bar.nicklist.position top /set weechat.look.prefix_align none /set weechat.look.align_end_of_lines time ----------------------------------------- +---- Avec WeeChat ≥ 0.3.6, vous pouvez activer l'option "eat_newline_glitch", pour éviter qu'un caractère de nouvelle ligne soit affiché après chaque ligne (donc cela ne cassera pas la sélection d'une URL) : ----------------------------------------- +---- /set weechat.look.eat_newline_glitch on ----------------------------------------- +---- [IMPORTANT] Cette option peut causer des problèmes d'affichage. Si vous rencontrez de tels @@ -280,23 +260,21 @@ Une autre solution est d'utiliser un script : http://weechat.org/scripts/stable/tag/url [[change_locale_without_quit]] -Je souhaite changer la langue des messages affichés par WeeChat, mais sans quitter WeeChat, est-ce possible ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Je souhaite changer la langue des messages affichés par WeeChat, mais sans quitter WeeChat, est-ce possible ? Oui, il faut utiliser le script python 'shell.py' (disponible sur le site de WeeChat) et taper ces commandes une fois le script chargé : ----------------------------------------- +---- /shell setenv LANG=fr_FR.UTF-8 /upgrade ----------------------------------------- +---- Pour avoir des messages anglais avec encodage UTF-8 pour le terminal, pour les utilisateurs en ISO, vous pouvez taper : `/shell setenv LANG=fr_FR`. [[use_256_colors]] -Comment puis-je utiliser 256 couleurs sous WeeChat ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je utiliser 256 couleurs sous WeeChat ? Les 256 couleurs sont supportées avec WeeChat ≥ 0.3.4. @@ -312,18 +290,18 @@ valeurs dans la variable 'TERM'. Si vous utilisez screen, vous pouvez ajouter cette ligne dans votre '~/.screenrc': ----------------------------------------- +---- term screen-256color ----------------------------------------- +---- Si votre variable 'TERM' a une valeur erronée et que WeeChat est déjà lancé, ne paniquez pas ! Vous pouvez la changer sans redémarrer, grâce au script 'shell.py' : ----------------------------------------- +---- /shell setenv TERM=screen-256color /upgrade ----------------------------------------- +---- Pour la version 0.3.4, vous devez utiliser la commande `/color` pour ajouter des nouvelles couleurs. @@ -336,8 +314,7 @@ Merci de lire le guide utilisateur pour plus d'information sur la gestion des couleurs. [[search_text]] -Comment puis-je chercher du texte dans le tampon (comme /lastlog dans irssi) ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je chercher du texte dans le tampon (comme /lastlog dans irssi) ? La touche par défaut est @k(C-)@k(r) (la commande est : `/input search_text`). Et sauter aux highlights : @k(A-)@k(p)/@k(n). @@ -346,31 +323,28 @@ Voir le guide utilisateur pour plus d'information sur cette fonctionnalité (raccourcis clavier par défaut). [[key_bindings]] -Raccourcis clavier ------------------- +== Raccourcis clavier [[meta_keys]] -Quelques touches meta (alt + touche) ne fonctionnent pas, pourquoi ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Quelques touches meta (alt + touche) ne fonctionnent pas, pourquoi ? Si vous utilisez certains terminaux comme xterm ou uxterm, quelques touches meta ne fonctionnent pas par défaut. Vous pouvez ajouter cette ligne dans le fichier '~/.Xresources': * pour xterm: ----------------------------------------- +---- XTerm*metaSendsEscape: true ----------------------------------------- +---- * pour uxterm: ----------------------------------------- +---- UXTerm*metaSendsEscape: true ----------------------------------------- +---- Puis recharger les ressources (`xrdb -override ~/.Xresources`) ou redémarrez X. [[customize_key_bindings]] -Comment puis-je configurer les raccourcis clavier ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je configurer les raccourcis clavier ? Les raccourcis clavier sont modifiables avec la commande `/key`. @@ -378,33 +352,31 @@ La touche par défaut @k(A-)@k(k) permet de capturer le code d'une touche et de l'inclure dans la ligne de commande. [[jump_to_buffer_11_or_higher]] -Quelle est la touche pour sauter vers le tampon 11 (ou numéro plus élevé) ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Quelle est la touche pour sauter vers le tampon 11 (ou numéro plus élevé) ? La touche est @k(A-)@k(j) puis 2 chiffres, par exemple @k(A-)@k(j) puis @k(1), @k(1) pour sauter au tampon 11. Vous pouvez définir une touche, par exemple : ----------------------------------------- +---- /key bind meta-q /buffer *11 ----------------------------------------- +---- La liste des touches par défaut est dans le Guide utilisateur. [[global_history]] -Comment utiliser l'historique global (au lieu de l'historique du tampon) avec les touches haut et bas ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment utiliser l'historique global (au lieu de l'historique du tampon) avec les touches haut et bas ? Vous pouvez assigner les touches haut et bas sur l'historique global (les touches par défaut pour l'historique global sont @k(C-)@k(↑) et @k(C-)@k(↓)). Exemple : ----------------------------------------- +---- /key bind meta2-A /input history_global_previous /key bind meta2-B /input history_global_next ----------------------------------------- +---- [NOTE] Les touches "meta2-A" et "meta2-B" peuvent être différentes dans votre terminal. @@ -412,20 +384,18 @@ Pour trouver le code de la touche appuyez sur @k(A-)@k(k) puis la touche (haut ou bas). [[mouse]] -Souris ------- +== Souris [[mouse_not_working]] -La souris ne fonctionne pas du tout, que puis-je faire ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== La souris ne fonctionne pas du tout, que puis-je faire ? La souris est supportée avec WeeChat ≥ 0.3.6. Premièrement essayez d'activer la souris : ----------------------------------------- +---- /mouse enable ----------------------------------------- +---- Si la souris ne fonctionne toujours pas, vérifiez la variable TERM dans votre shell (regardez la sortie de `echo $TERM` dans votre terminal). @@ -433,22 +403,21 @@ Selon le terminfo utilisé, la souris peut ne pas être supportée. Vous pouvez tester le support de la souris dans le terminal : ----------------------------------------- +---- $ printf '\033[?1002h' ----------------------------------------- +---- Et cliquez sur le premier caractère du terminal (en haut à gauche). Vous devriez voir " !!#!!". Pour désactiver la souris dans le terminal : ----------------------------------------- +---- $ printf '\033[?1002l' ----------------------------------------- +---- [[mouse_coords]] -La souris ne fait rien pour un X ou Y supérieur à 94, pourquoi ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== La souris ne fait rien pour un X ou Y supérieur à 94, pourquoi ? Certains terminaux envoient seulement des caractères ISO pour les coordonnées de la souris, donc cela ne fonctionne pas avec un X/Y supérieur à 94. @@ -457,8 +426,7 @@ Vous devriez utiliser un terminal qui supporte les coordonnées UTF-8 pour la souris, comme rxvt-unicode. [[mouse_select_paste]] -Comment puis-je sélectionner ou coller du texte quand la souris est activée dans WeeChat ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je sélectionner ou coller du texte quand la souris est activée dans WeeChat ? Lorsque la souris est activée dans WeeChat, vous pouvez utiliser la touche @k(-S-) pour sélectionner ou cliquer dans le terminal, comme si la souris était @@ -466,49 +434,45 @@ désactivée (sous certains terminaux comme iTerm, vous devez utiliser @k(-A-) a lieu de @k(-S-)). [[irc]] -IRC ---- +== IRC [[irc_ssl_connection]] -J'ai des problèmes pour me connecter au serveur avec SSL, que puis-je faire ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== J'ai des problèmes pour me connecter au serveur avec SSL, que puis-je faire ? Si vous voyez des erreurs à propos de la poignée de main gnutls ("handshake"), vous pouvez utiliser une valeur plus petite pour la clé Diffie-Hellman (par défaut 2048) : ----------------------------------------- +---- /set irc.server.freenode.ssl_dhkey_size 1024 ----------------------------------------- +---- Si vous voyez des erreurs à propos du certificat, vous pouvez désactiver "ssl_verify" (attention, la connexion sera moins sûre en faisant cela) : ----------------------------------------- +---- /set irc.server.freenode.ssl_verify off ----------------------------------------- +---- [[irc_ssl_handshake_error]] -Lors de la connexion SSL à un serveur, je vois juste une erreur "TLS handshake failed", que puis-je faire ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Lors de la connexion SSL à un serveur, je vois juste une erreur "TLS handshake failed", que puis-je faire ? Vous pouvez essayer une chaîne de priorité différente (WeeChat ≥ 0.3.5 seulement), remplacez "xxx" par le nom de votre serveur : ----------------------------------------- +---- /set irc.server.xxx.ssl_priorities "NORMAL:-VERS-TLS-ALL:+VERS-TLS1.0:+VERS-SSL3.0:%COMPAT" ----------------------------------------- +---- [[irc_ssl_freenode]] -Comment puis-je me connecter à freenode avec SSL ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je me connecter à freenode avec SSL ? Positionnez l'option 'weechat.network.gnutls_ca_file' avec le fichier des certificats : ----------------------------------------- +---- /set weechat.network.gnutls_ca_file "/etc/ssl/certs/ca-certificates.crt" ----------------------------------------- +---- [NOTE] Vérifiez que vous avez bien ce fichier (fourni généralement par le paquet @@ -516,16 +480,15 @@ Vérifiez que vous avez bien ce fichier (fourni généralement par le paquet Configurez le port du serveur, SSL, dhkey_size, puis connectez-vous : ----------------------------------------- +---- /set irc.server.freenode.addresses "chat.freenode.net/7000" /set irc.server.freenode.ssl on /set irc.server.freenode.ssl_dhkey_size 1024 /connect freenode ----------------------------------------- +---- [[irc_oauth]] -Comment se connecter à un serveur qui requiert "oauth" ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment se connecter à un serveur qui requiert "oauth" ? Des serveurs tels que 'twitch' requièrent oauth pour se connecter. @@ -534,34 +497,32 @@ L'oauth est simplement un mot de passe avec la valeur "oauth:XXXX". Vous pouvez créer un tel serveur et vous y connecter avec les commandes suivantes (remplacez le nom et l'adresse par les valeurs appropriées) : ----------------------------------------- +---- /server add nom irc.server.org -password="oauth:XXXX" /connect nom ----------------------------------------- +---- [[irc_sasl]] -Comment puis-je être identifié avant de rejoindre les canaux ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je être identifié avant de rejoindre les canaux ? Si le serveur supporte SASL, vous devriez l'utiliser au lieu d'envoyer une commande pour l'authentification avec nickserv, par exemple : ----------------------------------------- +---- /set irc.server_default.sasl_mechanism dh-blowfish /set irc.server.freenode.sasl_username "mynick" /set irc.server.freenode.sasl_password "xxxxxxx" ----------------------------------------- +---- Si le serveur ne supporte pas SASL, vous pouvez ajouter un délai (entre la commande et le join des canaux) : ----------------------------------------- +---- /set irc.server.freenode.command_delay 5 ----------------------------------------- +---- [[ignore_vs_filter]] -Quelle est la différence entre les commandes /ignore et /filter ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Quelle est la différence entre les commandes /ignore et /filter ? La commande `/ignore` est une commande IRC, donc elle s'applique uniquement aux tampons IRC (serveurs et canaux). @@ -579,38 +540,36 @@ de les voir en désactivant les filtres (par défaut, la touche @k(A-)@k(=) active/désactive les filtres). [[filter_irc_join_part_quit]] -Comment puis-je filtrer les messages join/part/quit sur les canaux IRC ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je filtrer les messages join/part/quit sur les canaux IRC ? Avec le filtre intelligent (pour garder les join/part/quit des utilisateurs qui ont parlé récemment) : ----------------------------------------- +---- /set irc.look.smart_filter on /filter add irc_smart * irc_smart_filter * ----------------------------------------- +---- Avec un filtre global (pour cacher *tous* les join/part/quit) : ----------------------------------------- +---- /filter add joinquit * irc_join,irc_part,irc_quit * ----------------------------------------- +---- [NOTE] Pour l'aide : `/help filter` et `/help irc.look.smart_filter` [[filter_irc_join_channel_messages]] -Comment puis-je filtrer certains messages affichés quand je rejoins un canal IRC ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je filtrer certains messages affichés quand je rejoins un canal IRC ? Avec WeeChat ≥ 0.4.1, vous pouvez désactiver des messages avec l'option 'irc.look.display_join_message'. Par exemple, pour désactiver les noms (qui est le message IRC '366') : ----------------------------------------- +---- /set irc.look.display_join_message "329,332,333" ----------------------------------------- +---- [NOTE] Pour l'aide : `/help irc.look.display_join_message` @@ -627,17 +586,16 @@ tampon des données brutes IRC (`/server raw`). Exemples : * filtrer les noms : ----------------------------------------- +---- /filter add irc_join_names * irc_366 * ----------------------------------------- +---- * filtrer le titre (et la date): ----------------------------------------- +---- /filter add irc_join_topic_date * irc_332,irc_333 * ----------------------------------------- +---- [[filter_voice_messages]] -Comment puis-je filtrer les messages voice (par exemple sur le serveur Bitlbee) ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je filtrer les messages voice (par exemple sur le serveur Bitlbee) ? Il n'est pas facile de filtrer les messages voice, car le mode voice peut être positionné avec d'autres modes dans le même message IRC. @@ -649,15 +607,15 @@ couleur spéciale pour les pseudos absents dans la liste des pseudos. Pour Bitlbee ≥ 3, faites ceci sur le canal '&bitlbee' : ----------------------------------------- +---- channel set show_users online,away ----------------------------------------- +---- Pour une version plus ancienne de Bitlbee, faites ceci sur le canal '&bitlbee': ----------------------------------------- +---- set away_devoice false ----------------------------------------- +---- Pour vérifier les pseudos absents dans WeeChat, voir la question à propos des <<color_away_nicks,pseudos absents>>. @@ -666,13 +624,12 @@ Si vous voulez vraiment filtrer les messages voice, vous pouvez utiliser cette commande, mais elle n'est pas parfaite (elle fonctionne seulement si le premier mode changé est voice) : ----------------------------------------- +---- /filter add hidevoices * irc_mode (\+|\-)v ----------------------------------------- +---- [[color_away_nicks]] -Comment puis-je voir les pseudos absents dans la liste des pseudos ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je voir les pseudos absents dans la liste des pseudos ? Vous devez positionner l'option 'irc.server_default.away_check' avec une valeur positive (minutes entre chaque vérification des pseudos absents). @@ -683,56 +640,51 @@ pour limiter la vérification d'absence sur les petits canaux seulement. Par exemple, pour vérifier les pseudos absents toutes les 5 minutes, pour les canaux avec maximum 25 pseudos : ----------------------------------------- +---- /set irc.server_default.away_check 5 /set irc.server_default.away_check_max_nicks 25 ----------------------------------------- +---- [NOTE] Pour WeeChat ≤ 0.3.3, les options sont 'irc.network.away_check' et 'irc.network.away_check_max_nicks'. [[highlight_notification]] -Comment être averti lorsque quelqu'un prononce mon pseudo sur un canal ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment être averti lorsque quelqu'un prononce mon pseudo sur un canal ? Vous pouvez utiliser un script comme 'beep.pl' ou 'launcher.pl'. Pour 'launcher.pl', vous devez configurer la commande : ----------------------------------------- +---- /set plugins.var.perl.launcher.signal.weechat_highlight "/chemin/vers/commande paramètres" ----------------------------------------- +---- Autres scripts sur ce sujet : http://weechat.org/scripts/stable/tag/notify/ [[irc_target_buffer]] -Comment puis-je changer le serveur cible pour les commandes avec des tampons mélangés (comme le tampon avec les serveurs) ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je changer le serveur cible pour les commandes avec des tampons mélangés (comme le tampon avec les serveurs) ? La touche par défaut est @k(C-)@k(x) (la commande est : `/input switch_active_buffer`). [[plugins_scripts]] -Extensions / scripts --------------------- +== Extensions / scripts [[openbsd_plugins]] -J'utilise OpenBSD et WeeChat ne charge aucune extension, pourquoi ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== J'utilise OpenBSD et WeeChat ne charge aucune extension, pourquoi ? Sous OpenBSD, le nom des extensions se termine par ".so.0.0" (".so" sous Linux). Vous devez configurer ça : ----------------------------------------- +---- /set weechat.plugin.extension ".so.0.0" /plugin autoload ----------------------------------------- +---- [[load_scripts]] -Comment puis-je charger des scripts Perl/Python/Ruby/Lua/Tcl ? Les scripts sont-ils compatibles avec d'autres clients IRC ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je charger des scripts Perl/Python/Ruby/Lua/Tcl ? Les scripts sont-ils compatibles avec d'autres clients IRC ? Les commandes `/perl`, `/python`, `/ruby`, `/lua` et `/tcl` permettent de charger les scripts (le chemin par défaut est '~/.weechat/<langage>/'). @@ -746,12 +698,10 @@ Notes : * l'extension 'tcl' est disponible à partir de la version 0.3.0. [[settings]] -Réglages --------- +== Réglages [[memory_usage]] -Comment configurer WeeChat pour consommer moins de mémoire ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment configurer WeeChat pour consommer moins de mémoire ? Vous pouvez essayer les astuces suivantes pour consommer moins de mémoire : @@ -768,12 +718,10 @@ Vous pouvez essayer les astuces suivantes pour consommer moins de mémoire : * réduire la valeur de l'option 'weechat.history.max_commands' [[development]] -Développement -------------- +== Développement [[bug_task_patch]] -Comment puis-je reporter un bug, demander une nouvelle fonctionnalité ou envoyer un patch ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Comment puis-je reporter un bug, demander une nouvelle fonctionnalité ou envoyer un patch ? Il y a 3 possibilités : @@ -787,29 +735,27 @@ Il y a 3 possibilités : (vous pouvez souscrire et envoyer à la liste de diffusion nommée "support") [[gdb_error_threads]] -Quand je lance WeeChat sous gdb, il y a une erreur à propos des threads, que puis-je faire ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Quand je lance WeeChat sous gdb, il y a une erreur à propos des threads, que puis-je faire ? Quand vous lancez WeeChat sous gdb, vous pouvez avoir cette erreur : ----------------------------------------- +---- $ gdb /path/to/weechat (gdb) run [Thread debugging using libthread_db enabled] Cannot find new threads: generic error ----------------------------------------- +---- Pour corriger ça, vous pouvez lancer gdb avec cette commande (remplacez le chemin vers libpthread et WeeChat avec les chemins sur votre système) : ----------------------------------------- +---- $ LD_PRELOAD=/lib/libpthread.so.0 gdb /path/to/weechat (gdb) run ----------------------------------------- +---- [[supported_os]] -Quelle est la liste des plates-formes supportées par WeeChat ? Sera-t-il porté sur d'autres systèmes d'exploitation ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Quelle est la liste des plates-formes supportées par WeeChat ? Sera-t-il porté sur d'autres systèmes d'exploitation ? La liste complète est sur cette page : http://weechat.org/download @@ -818,8 +764,7 @@ Toute aide est la bienvenue pour les systèmes que nous n'avons pas, pour y tester WeeChat. [[help_developers]] -Je souhaiterais aider les développeurs WeeChat. Que puis-je faire ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Je souhaiterais aider les développeurs WeeChat. Que puis-je faire ? Il y a plusieurs choses à faire (test, code, documentation, etc...) @@ -827,8 +772,7 @@ Merci de prendre contact avec nous par IRC ou mail, consultez la page support : http://weechat.org/dev/support [[donate]] -Puis-je donner de l'argent ou d'autres choses aux développeurs WeeChat ? -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Puis-je donner de l'argent ou d'autres choses aux développeurs WeeChat ? Vous pouvez donner de l'argent pour aider le développement. Plus de détails sur http://weechat.org/about/donate diff --git a/doc/fr/weechat_plugin_api.fr.txt b/doc/fr/weechat_plugin_api.fr.txt index 91359fa0a..75ba9e0d4 100644 --- a/doc/fr/weechat_plugin_api.fr.txt +++ b/doc/fr/weechat_plugin_api.fr.txt @@ -1,5 +1,4 @@ -Référence API Extension WeeChat -=============================== += Référence API Extension WeeChat Sébastien Helleu <flashcode@flashtux.org> @@ -11,8 +10,7 @@ http://weechat.org/doc [[introduction]] -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. @@ -21,8 +19,7 @@ Ce manuel documente l'API WeeChat des extensions, utilisée par les extensions en C pour interagir avec le cœur de WeeChat. [[plugins_in_weechat]] -Extensions dans WeeChat ------------------------ +== Extensions dans WeeChat Une extension est un programme C qui peut appeler des fonctions WeeChat définies dans une interface. @@ -40,8 +37,7 @@ Ce fichier définit les structures et types utilisés pour communiquer avec WeeChat. [[macros]] -Macros -~~~~~~ +=== Macros L'extension doit utiliser des macros (pour définir quelques variables) : @@ -58,26 +54,24 @@ WEECHAT_PLUGIN_LICENSE("GPL3"):: licence de l'extension [[main_functions]] -Fonctions principales -~~~~~~~~~~~~~~~~~~~~~ +=== Fonctions principales L'extension doit utiliser deux fonctions : * weechat_plugin_init * weechat_plugin_end -weechat_plugin_init -^^^^^^^^^^^^^^^^^^^ +==== weechat_plugin_init Cette fonction est appelée quand l'extension est chargée par WeeChat. Prototype : [source,C] ----------------------------------------- +---- int weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[]); ----------------------------------------- +---- Paramètres : @@ -91,17 +85,16 @@ Valeur de retour : * 'WEECHAT_RC_OK' si ok (l'extension sera chargée) * 'WEECHAT_RC_ERROR' si erreur (l'extension ne sera PAS chargée) -weechat_plugin_end -^^^^^^^^^^^^^^^^^^ +==== weechat_plugin_end Cette fonction est appelée quand l'extension est déchargée par WeeChat. Prototype : [source,C] ----------------------------------------- +---- int weechat_plugin_end (struct t_weechat_plugin *plugin); ----------------------------------------- +---- Paramètres : @@ -113,22 +106,20 @@ Valeur de retour : * 'WEECHAT_RC_ERROR' si erreur [[compile_plugin]] -Compilation de l'extension -~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Compilation de l'extension La compilation ne nécessite pas les sources de WeeChat, seul le fichier 'weechat-plugin.h' est requis. Pour compiler l'extension qui n'a qu'un fichier "toto.c" (sous GNU/Linux) : ----------------------------------------- +---- $ gcc -fPIC -Wall -c toto.c $ gcc -shared -fPIC -o libtoto.so toto.o ----------------------------------------- +---- [[load_plugin]] -Chargement de l'extension -~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Chargement de l'extension Copiez le fichier 'libtoto.so' dans le répertoire système des extensions (par exemple '/usr/local/lib/weechat/plugins') ou dans le répertoire utilisateur des @@ -136,20 +127,19 @@ extensions (par exemple '/home/xxx/.weechat/plugins'). Sous WeeChat : ----------------------------------------- +---- /plugin load toto ----------------------------------------- +---- [[plugin_example]] -Exemple d'extension -~~~~~~~~~~~~~~~~~~~ +=== Exemple d'extension Exemple complet d'extension, qui ajoute une commande '/double' : affiche deux fois les paramètres sur le tampon courant, ou exécute deux fois une commande (ok ce n'est pas très utile, mais c'est juste un exemple !) : [source,C] ----------------------------------------- +---- #include <stdlib.h> #include "weechat-plugin.h" @@ -209,11 +199,10 @@ weechat_plugin_end (struct t_weechat_plugin *plugin) return WEECHAT_RC_OK; } ----------------------------------------- +---- [[plugin_api]] -API extension -------------- +== API extension Les chapîtres ci-dessous décrivent les fonctions de l'API, classées par catégorie. @@ -229,22 +218,20 @@ Pour chaque fonction, on donne : similaire). [[plugins]] -Extensions -~~~~~~~~~~ +=== Extensions Fonctions pour obtenir des informations sur les extensions. -weechat_plugin_get_name -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_plugin_get_name Retourne le nom d'une extension. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_plugin_get_name (struct t_weechat_plugin *plugin); ----------------------------------------- +---- Paramètres : @@ -258,32 +245,30 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- const char *name = weechat_plugin_get_name (plugin); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype name = weechat.plugin_get_name(plugin) # exemple plugin = weechat.buffer_get_pointer(weechat.current_buffer(), "plugin") name = weechat.plugin_get_name(plugin) ----------------------------------------- +---- [[strings]] -Chaînes de caractères -~~~~~~~~~~~~~~~~~~~~~ +=== Chaînes de caractères Plusieurs fonctions sur les chaînes de caractères sont déjà disponibles via les fonctions standard du C, mais il est recommandé d'utiliser celles de l'API car elles sont ok avec UTF-8 et la locale. -weechat_charset_set -^^^^^^^^^^^^^^^^^^^ +==== weechat_charset_set Définit le nouveau jeu de caractères (le jeu de caractères par défaut est 'UTF-8', donc si votre extension utilise 'UTF-8', vous n'avez pas besoin @@ -292,9 +277,9 @@ d'appeler cette fonction). Prototype : [source,C] ----------------------------------------- +---- void weechat_charset_set (const char *charset); ----------------------------------------- +---- Paramètres : @@ -303,32 +288,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_charset_set ("iso-8859-1"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.charset_set(charset) # exemple weechat.charset_set("iso-8859-1") ----------------------------------------- +---- -weechat_iconv_to_internal -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_iconv_to_internal Convertit une chaîne vers le jeu de caractères interne (UTF-8). Prototype : [source,C] ----------------------------------------- +---- char *weechat_iconv_to_internal (const char *charset, const char *string); ----------------------------------------- +---- Paramètres : @@ -342,34 +326,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = weechat_iconv_to_internal ("iso-8859-1", "chaîne iso : é à"); /* ... */ free (str); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype str = weechat.iconv_to_internal(charset, string) # exemple str = weechat.iconv_to_internal("iso-8859-1", "chaîne iso : é à") ----------------------------------------- +---- -weechat_iconv_from_internal -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_iconv_from_internal Convertie une chaîne du jeu de caractères interne (UTF-8) vers un autre. Prototype : [source,C] ----------------------------------------- +---- char *weechat_iconv_from_internal (const char *charset, const char *string); ----------------------------------------- +---- Paramètres : @@ -383,34 +366,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = weechat_iconv_from_internal ("iso-8859-1", "chaîne utf-8 : é à"); /* ... */ free (str); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype str = weechat.iconv_from_internal(charset, string) # exemple str = weechat.iconv_from_internal("iso-8859-1", "chaîne utf-8 : é à") ----------------------------------------- +---- -weechat_gettext -^^^^^^^^^^^^^^^ +==== weechat_gettext Retourne la chaîne traduite (dépend de la langue locale). Prototype : [source,C] ----------------------------------------- +---- const char *weechat_gettext (const char *string); ----------------------------------------- +---- Paramètres : @@ -423,23 +405,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = weechat_gettext ("hello"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype str = weechat.gettext(string) # exemple str = weechat.gettext("hello") ----------------------------------------- +---- -weechat_ngettext -^^^^^^^^^^^^^^^^ +==== weechat_ngettext Retourne la chaîne traduite, en utilisant le singulier ou le pluriel, selon le paramètre 'count'. @@ -447,10 +428,10 @@ le paramètre 'count'. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_ngettext (const char *string, const char *plural, int count); ----------------------------------------- +---- Paramètres : @@ -466,33 +447,32 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = weechat_ngettext ("file", "files", num_files); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype str = weechat.ngettext(string, plural, count) # exemple num_files = 2 str = weechat.ngettext("file", "files", num_files) ----------------------------------------- +---- -weechat_strndup -^^^^^^^^^^^^^^^ +==== weechat_strndup Retourne la chaîne dupliquée, avec au plus 'length' caractères. Prototype : [source,C] ----------------------------------------- +---- char *weechat_strndup (const char *string, int length); ----------------------------------------- +---- Paramètres : @@ -506,26 +486,25 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = weechat_strndup ("abcdef", 3); /* résultat : "abc" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_tolower -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_tolower Convertit une chaîne UTF-8 en minuscules. Prototype : [source,C] ----------------------------------------- +---- void weechat_string_tolower (const char *string); ----------------------------------------- +---- Paramètres : @@ -534,25 +513,24 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- char *str = "AbCdé"; weechat_string_tolower (str); /* str vaut maintenant : "abcdé" */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_toupper -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_toupper Convertir une chaîne UTF-8 en majuscules. Prototype : [source,C] ----------------------------------------- +---- void weechat_string_toupper (const char *string); ----------------------------------------- +---- Paramètres : @@ -561,25 +539,24 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- char *str = "AbCdé"; weechat_string_toupper (str); /* str vaut maintenant : "ABCDé" */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_strcasecmp -^^^^^^^^^^^^^^^^^^ +==== weechat_strcasecmp Comparaison de chaînes indépendante de la locale et de la casse. Prototype : [source,C] ----------------------------------------- +---- int weechat_strcasecmp (const char *string1, const char *string2); ----------------------------------------- +---- Paramètres : @@ -596,15 +573,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int diff = weechat_strcasecmp ("aaa", "CCC"); /* == -2 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_strcasecmp_range -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_strcasecmp_range _WeeChat ≥ 0.3.7._ @@ -614,9 +590,9 @@ intervalle pour comparer la casse. Prototype : [source,C] ----------------------------------------- +---- int weechat_strcasecmp_range (const char *string1, const char *string2, int range); ----------------------------------------- +---- Paramètres : @@ -640,15 +616,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int diff = weechat_strcasecmp_range ("nick{away}", "NICK[away]", 29); /* == 0 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_strncasecmp -^^^^^^^^^^^^^^^^^^^ +==== weechat_strncasecmp Comparaison de chaînes indépendante de la locale et de la casse, pour 'max' caractères. @@ -656,9 +631,9 @@ caractères. Prototype : [source,C] ----------------------------------------- +---- int weechat_strncasecmp (const char *string1, const char *string2, int max); ----------------------------------------- +---- Paramètres : @@ -676,15 +651,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int diff = weechat_strncasecmp ("aabb", "aacc", 2); /* == 0 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_strncasecmp_range -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_strncasecmp_range _WeeChat ≥ 0.3.7._ @@ -694,9 +668,9 @@ caractères, avec un intervalle pour comparer la casse. Prototype : [source,C] ----------------------------------------- +---- int weechat_strncasecmp_range (const char *string1, const char *string2, int max, int range); ----------------------------------------- +---- Paramètres : @@ -721,15 +695,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int diff = weechat_strncasecmp_range ("nick{away}", "NICK[away]", 6, 29); /* == 0 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_strcmp_ignore_chars -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_strcmp_ignore_chars Comparaison de chaînes indépendante de la locale (et en option de la casse), en ignorant des caractères. @@ -737,11 +710,11 @@ ignorant des caractères. Prototype : [source,C] ----------------------------------------- +---- int weechat_strcmp_ignore_chars (const char *string1, const char *string2, const char *chars_ignored, int case_sensitive); ----------------------------------------- +---- Paramètres : @@ -760,24 +733,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int diff = weechat_strcmp_ignore_chars ("a-b", "--a-e", "-", 1); /* == -3 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_strcasestr -^^^^^^^^^^^^^^^^^^ +==== weechat_strcasestr Recherche de chaîne indépendante de la locale et de la casse. Prototype : [source,C] ----------------------------------------- +---- char *weechat_strcasestr (const char *string, const char *search); ----------------------------------------- +---- Paramètres : @@ -791,15 +763,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *pos = weechat_strcasestr ("aBcDeF", "de"); /* résultat : pointeur vers "DeF" */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_strlen_screen -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_strlen_screen _WeeChat ≥ 0.4.2._ @@ -811,9 +782,9 @@ la fonction <<_weechat_utf8_strlen_screen,weechat_utf8_strlen_screen>>). Prototype : [source,C] ----------------------------------------- +---- int weechat_strlen_screen (const char *string); ----------------------------------------- +---- Paramètres : @@ -826,33 +797,32 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int length_on_screen = weechat_strlen_screen ("é"); /* == 1 */ ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototype length = weechat.strlen_screen(string) # exemple length = weechat.strlen_screen("é") # 1 ----------------------------------------- +---- -weechat_string_match -^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_match Vérifie si une chaîne correspond à un masque. Prototype : [source,C] ----------------------------------------- +---- int weechat_string_match (const char *string, const char *mask, int case_sensitive); ----------------------------------------- +---- Paramètres : @@ -868,17 +838,17 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int match1 = weechat_string_match ("abcdef", "abc*", 0); /* == 1 */ int match2 = weechat_string_match ("abcdef", "*dd*", 0); /* == 0 */ int match3 = weechat_string_match ("abcdef", "*def", 0); /* == 1 */ int match4 = weechat_string_match ("abcdef", "*de*", 0); /* == 1 */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype match = weechat.string_match(string, mask, case_sensitive) @@ -887,20 +857,19 @@ match1 = weechat.string_match("abcdef", "abc*", 0) # 1 match2 = weechat.string_match("abcdef", "*dd*", 0) # 0 match3 = weechat.string_match("abcdef", "*def", 0) # 1 match4 = weechat.string_match("abcdef", "*de*", 0) # 1 ----------------------------------------- +---- -weechat_string_replace -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_replace Remplace toutes les occurrences d'une chaîne par une autre chaîne. Prototype : [source,C] ----------------------------------------- +---- char *weechat_string_replace (const char *string, const char *search, const char *replace); ----------------------------------------- +---- Paramètres : @@ -916,17 +885,16 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = weechat_string_replace ("test, test", "s", "x"); /* résultat : "text" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_expand_home -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_expand_home _WeeChat ≥ 0.3.3._ @@ -936,9 +904,9 @@ débute pas par `~`, alors une chaîne identique est retournée. Prototype : [source,C] ----------------------------------------- +---- char *weechat_string_expand_home (const char *path); ----------------------------------------- +---- Paramètres : @@ -952,18 +920,17 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = weechat_string_expand_home ("~/fichier.txt"); /* résultat: "/home/xxx/fichier.txt" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_remove_quotes -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_remove_quotes Supprime les apostrophes/guillemets au début et à la fin d'une chaîne (ignore les blancs s'ils sont avant la première apostrophe ou après la dernière). @@ -971,9 +938,9 @@ les blancs s'ils sont avant la première apostrophe ou après la dernière). Prototype : [source,C] ----------------------------------------- +---- char *weechat_string_remove_quotes (const char *string, const char *quotes); ----------------------------------------- +---- Paramètres : @@ -988,28 +955,27 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = weechat_string_remove_quotes (string, " 'aujourd'hui' ", "'"); /* résultat : "aujourd'hui" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_strip -^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_strip Supprime des caractères au début et/ou à la fin d'une chaîne. Prototype : [source,C] ----------------------------------------- +---- char *weechat_string_strip (const char *string, int left, int right, const char *chars); ----------------------------------------- +---- Paramètres : @@ -1026,17 +992,16 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = weechat_string_strip (".abc -", 0, 1, "- ."); /* résultat : ".abc" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_mask_to_regex -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_mask_to_regex Retourne une expression régulière ("regex"), construite avec un masque où le seul caractère spécial est "`*`". Tous les autres caractères spéciaux @@ -1045,9 +1010,9 @@ d'expression régulière sont échappés. Prototype : [source,C] ----------------------------------------- +---- char *weechat_string_mask_to_regex (const char *mask); ----------------------------------------- +---- Paramètres : @@ -1061,26 +1026,25 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str_regex = weechat_string_mask_to_regex ("test*mask"); /* résultat : "test.*mask" */ /* ... */ free (str_regex); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype regex = weechat.string_mask_to_regex(mask) # exemple regex = weechat.string_mask_to_regex("test*mask") # "test.*mask" ----------------------------------------- +---- -weechat_string_regex_flags -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_regex_flags _WeeChat ≥ 0.3.7._ @@ -1090,9 +1054,9 @@ les "flags" pour compiler l'expression régulière. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_string_regex_flags (const char *regex, int default_flags, int *flags) ----------------------------------------- +---- Paramètres : @@ -1125,18 +1089,17 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- const char *regex = "(?i)test"; int flags; const char *ptr_regex = weechat_string_regex_flags (regex, REG_EXTENDED, &flags); /* ptr_regex == "test", flags == REG_EXTENDED | REG_ICASE */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_regcomp -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_regcomp _WeeChat ≥ 0.3.7._ @@ -1147,9 +1110,9 @@ Compile une expression régulière avec des "flags" optionnels en début de cha Prototype : [source,C] ----------------------------------------- +---- int weechat_string_regcomp (void *preg, const char *regex, int default_flags) ----------------------------------------- +---- Paramètres : @@ -1169,19 +1132,18 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- regex_t my_regex; if (weechat_string_regcomp (&my_regex, "(?i)test", REG_EXTENDED) != 0) { /* erreur */ } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_has_highlight -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_has_highlight Vérifie si une chaîne a un ou plusieurs "highlights", en utilisant une liste de mots "highlight". @@ -1189,10 +1151,10 @@ de mots "highlight". Prototype : [source,C] ----------------------------------------- +---- int weechat_string_has_highlight (const char *string, const char highlight_words); ----------------------------------------- +---- Paramètres : @@ -1206,23 +1168,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int hl = weechat_string_has_highlight ("my test string", "test,word2"); /* == 1 */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype highlight = weechat.string_has_highlight(string, highlight_words) # exemple highlight = weechat.string_has_highlight("my test string", "test,word2") # 1 ----------------------------------------- +---- -weechat_string_has_highlight_regex -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_has_highlight_regex _WeeChat ≥ 0.3.4._ @@ -1234,9 +1195,9 @@ caractères de mot (caractère alphanumérique, "-", "_" ou "|"). Prototype : [source,C] ----------------------------------------- +---- int weechat_string_has_highlight_regex (const char *string, const char *regex); ----------------------------------------- +---- Paramètres : @@ -1250,34 +1211,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int hl = weechat_string_has_highlight_regex ("my test string", "test|word2"); /* == 1 */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype highlight = weechat.string_has_highlight_regex(string, regex) # exemple highlight = weechat.string_has_highlight_regex("my test string", "test|word2") # 1 ----------------------------------------- +---- -weechat_string_split -^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_split Découpe une chaîne à l'aide de délimiteur(s). Prototype : [source,C] ----------------------------------------- +---- char **weechat_string_split (const char *string, const char *separators, int keep_eol, int num_items_max, int *num_items); ----------------------------------------- +---- Paramètres : @@ -1302,7 +1262,7 @@ Valeur de retour : Exemples en C : [source,C] ----------------------------------------- +---- char **argv; int argc; argv = weechat_string_split ("abc de fghi", " ", 0, 0, &argc); @@ -1322,22 +1282,21 @@ argv = weechat_string_split ("abc de fghi", " ", 1, 0, &argc); argc == 3 */ weechat_string_free_split (argv); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_free_split -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_free_split Libère la mémoire utilisée pour le découpage d'une chaîne. Prototype : [source,C] ----------------------------------------- +---- void weechat_string_free_split (char **split_string); ----------------------------------------- +---- Paramètres : @@ -1347,29 +1306,28 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- char *argv; int argc; argv = weechat_string_split (string, " ", 0, 0, &argc); /* ... */ weechat_string_free_split (argv); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_build_with_split_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_build_with_split_string Construit une chaîne à partir d'une chaîne découpée. Prototype : [source,C] ----------------------------------------- +---- char *weechat_string_build_with_split_string (char **split_string const char *separator); ----------------------------------------- +---- Paramètres : @@ -1385,7 +1343,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char **argv; int argc; argv = weechat_string_split ("abc def ghi", " ", 0, 0, &argc); @@ -1393,13 +1351,12 @@ char *str = weechat_string_build_with_split_string (argv, ";"); /* str == "abc;def;ghi" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_split_command -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_split_command Éclate une liste de commandes séparées par 'separator' (qui peut être échappé par "\" dans la chaîne). @@ -1407,9 +1364,9 @@ par "\" dans la chaîne). Prototype : [source,C] ----------------------------------------- +---- char **weechat_string_split_command (const char *command, char separator); ----------------------------------------- +---- Paramètres : @@ -1424,28 +1381,27 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char **argv = weechat_string_split_command ("/commande1 arg;/commande2", ';'); /* résultat : argv[0] == "/commande1 arg" argv[1] == "/commande2" */ weechat_free_split_command (argv); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_free_split_command -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_free_split_command Libère la mémoire utilisée par une commande éclatée. Prototype : [source,C] ----------------------------------------- +---- void weechat_string_free_split_command (char **split_command); ----------------------------------------- +---- Paramètres : @@ -1455,17 +1411,16 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- char **argv = weechat_string_split_command ("/commande1 arg;/commande2", ';'); /* ... */ weechat_free_split_command (argv); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_format_size -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_format_size Construit une chaîne avec une taille de fichier formatée et une unité traduite dans la langue locale. @@ -1473,9 +1428,9 @@ dans la langue locale. Prototype : [source,C] ----------------------------------------- +---- char *weechat_string_format_size (unsigned long long size); ----------------------------------------- +---- Paramètres : @@ -1488,7 +1443,7 @@ Valeur de retour : Exemples en C : [source,C] ----------------------------------------- +---- /* exemples avec la langue française */ char *str = weechat_string_format_size (0); /* str == "0 octet" */ @@ -1506,23 +1461,22 @@ free (str); char *str = weechat_string_format_size (2097152); /* str == "2 Mo" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_remove_color -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_remove_color Supprime les couleurs WeeChat dans une chaîne. Prototype : [source,C] ----------------------------------------- +---- char *weechat_string_remove_color (const char *string, const char *replacement); ----------------------------------------- +---- Paramètres : @@ -1539,7 +1493,7 @@ Valeur de retour : Exemples en C : [source,C] ----------------------------------------- +---- /* supprime les codes couleur */ char *str = weechat_string_remove_color (ma_chaine1, NULL); /* ... */ @@ -1549,21 +1503,20 @@ free (str); char *str = weechat_string_remove_color (ma_chaine2, "?"); /* ... */ free (str); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype str = weechat.string_remove_color(string, replacement) # exemple str = weechat.string_remove_color(ma_chaine, "?") ----------------------------------------- +---- -weechat_string_encode_base64 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_encode_base64 _WeeChat ≥ 0.3.2._ @@ -1572,9 +1525,9 @@ Encode une chaîne en base64. Prototype : [source,C] ----------------------------------------- +---- void weechat_string_encode_base64 (const char *from, int length, char *to); ----------------------------------------- +---- Paramètres : @@ -1586,17 +1539,16 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- char *string = "abcdefgh", result[128]; weechat_string_encode_base64 (string, strlen (string), result); /* result == "YWJjZGVmZ2g=" */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_decode_base64 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_decode_base64 _WeeChat ≥ 0.3.2._ @@ -1605,9 +1557,9 @@ Décode une chaîne base64. Prototype : [source,C] ----------------------------------------- +---- int weechat_string_decode_base64 (const char *from, char *to); ----------------------------------------- +---- Paramètres : @@ -1622,18 +1574,17 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *string = "YWJjZGVmZ2g=", result[128]; int length; length = weechat_string_decode_base64 (string, result); /* length == 8, result == "abcdefgh" */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_string_is_command_char -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_is_command_char _WeeChat ≥ 0.3.2._ @@ -1643,9 +1594,9 @@ caractère par défaut de commande est '/'). Prototype : [source,C] ----------------------------------------- +---- int weechat_string_is_command_char (const char *string); ----------------------------------------- +---- Paramètres : @@ -1658,25 +1609,24 @@ Valeur de retour : Exemples en C : [source,C] ----------------------------------------- +---- int command_char1 = weechat_string_is_command_char ("/test"); /* == 1 */ int command_char2 = weechat_string_is_command_char ("test"); /* == 0 */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype is_cmdchar = weechat.string_is_command_char(string) # exemples command_char1 = weechat.string_is_command_char("/test") # == 1 command_char2 = weechat.string_is_command_char("test") # == 0 ----------------------------------------- +---- -weechat_string_input_for_buffer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_input_for_buffer _WeeChat ≥ 0.3.2._ @@ -1686,9 +1636,9 @@ l'intérieur du paramètre "string"), ou NULL si c'est une commande. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_string_input_for_buffer (const char *string); ----------------------------------------- +---- Paramètres : @@ -1701,16 +1651,16 @@ Valeur de retour : Exemples en C : [source,C] ----------------------------------------- +---- const char *str1 = weechat_string_input_for_buffer ("test"); /* "test" */ const char *str2 = weechat_string_input_for_buffer ("/test"); /* NULL */ const char *str3 = weechat_string_input_for_buffer ("//test"); /* "/test" */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype str = weechat.string_input_for_buffer(string) @@ -1718,10 +1668,9 @@ str = weechat.string_input_for_buffer(string) str1 = weechat.string_input_for_buffer("test") # "test" str2 = weechat.string_input_for_buffer("/test") # "" str3 = weechat.string_input_for_buffer("//test") # "/test" ----------------------------------------- +---- -weechat_string_eval_expression -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_eval_expression _WeeChat ≥ 0.4.0, mis à jour dans la 0.4.2._ @@ -1732,12 +1681,12 @@ commande `/eval` dans le 'Guide utilisateur WeeChat'). Prototype : [source,C] ----------------------------------------- +---- char *weechat_string_eval_expression (const char *expr, struct t_hashtable *pointers, struct t_hashtable *extra_vars, struct t_hashtable *options); ----------------------------------------- +---- Paramètres : @@ -1765,7 +1714,7 @@ Valeur de retour : Exemples en C : [source,C] ----------------------------------------- +---- struct t_hashtable *options = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, @@ -1776,12 +1725,12 @@ if (options) char *str1 = weechat_string_eval_expression ("${buffer.full_name}", NULL, NULL, NULL); /* "core.weechat" */ char *str2 = weechat_string_eval_expression ("${window.win_width} > 100", NULL, NULL, options); /* "1" */ char *str3 = weechat_string_eval_expression ("abc =~ def", NULL, NULL, options); /* "0" */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype str = weechat.string_eval_expression(expr, pointers, extra_vars, options) @@ -1789,25 +1738,23 @@ str = weechat.string_eval_expression(expr, pointers, extra_vars, options) str1 = weechat.string_eval_expression("${buffer.full_name}", {}, {}, {}) # "core.weechat" str2 = weechat.string_eval_expression("${window.win_width} > 100", {}, {}, {"type": "condition"}) # "1" str3 = weechat.string_eval_expression("abc =~ def", {}, {}, {"type": "condition"}) # "0" ----------------------------------------- +---- [[utf-8]] -UTF-8 -~~~~~ +=== UTF-8 Fonctions pour les chaînes UTF-8. -weechat_utf8_has_8bits -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_has_8bits Vérifie si une chaîne a des caractères 8-bits. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_has_8bits (const char *string); ----------------------------------------- +---- Paramètres : @@ -1821,27 +1768,26 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_utf8_has_8bits (string)) { /* ... */ } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_is_valid -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_is_valid Vérifie si une chaîne est valide UTF-8. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_is_valid (const char *string, char **error); ----------------------------------------- +---- Paramètres : @@ -1856,7 +1802,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *error; if (weechat_utf8_is_valid (string, &error)) { @@ -1866,13 +1812,12 @@ else { /* "error" pointe vers le premier caractère invalide */ } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_normalize -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_normalize Normalise une chaîne UTF-8 : supprime tous les caractères non valides UTF-8 en les remplaçant par un caractère. @@ -1880,9 +1825,9 @@ en les remplaçant par un caractère. Prototype : [source,C] ----------------------------------------- +---- void weechat_utf8_normalize (char *string, char replacement); ----------------------------------------- +---- Paramètres : @@ -1892,24 +1837,23 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_utf8_normalize (string, '?'); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_prev_char -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_prev_char Retourne un pointeur vers le caractère UTF-8 précédent dans une chaîne. Prototype : [source,C] ----------------------------------------- +---- char *weechat_utf8_prev_char (const char *string_start, const char *string); ----------------------------------------- +---- Paramètres : @@ -1925,24 +1869,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *prev_char = weechat_utf8_prev_char (string, ptr_in_string); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_next_char -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_next_char Retourne un pointeur vers le caractère UTF-8 suivant dans une chaîne. Prototype : [source,C] ----------------------------------------- +---- char *weechat_utf8_next_char (const char *string); ----------------------------------------- +---- Paramètres : @@ -1956,24 +1899,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *next_char = weechat_utf8_next_char (string); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_char_int -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_char_int Retourne un caractère UTF-8 sous forme d'entier. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_char_int (const char *string); ----------------------------------------- +---- Paramètres : @@ -1986,24 +1928,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int char_int = weechat_utf8_char_int ("être"); /* "ê" comme entier */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_char_size -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_char_size Retourne la taille d'un caractère UTF-8 (en octets). Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_char_size (const char *string); ----------------------------------------- +---- Paramètres : @@ -2016,24 +1957,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int char_size = weechat_utf8_char_size ("être"); /* == 2 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_strlen -^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_strlen Retourne la taille d'une chaîne UTF-8 (en nombre de caractères UTF-8). Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_strlen (const char *string); ----------------------------------------- +---- Paramètres : @@ -2046,15 +1986,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int length = weechat_utf8_strlen ("chêne"); /* == 5 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_strnlen -^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_strnlen Retourne la taille d'une chaîne UTF-8 (en nombre de caractères UTF-8), pour au maximum 'bytes' octets dans la chaîne. @@ -2062,9 +2001,9 @@ maximum 'bytes' octets dans la chaîne. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_strnlen (const char *string, int bytes); ----------------------------------------- +---- Paramètres : @@ -2078,15 +2017,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int length = weechat_utf8_strnlen ("chêne", 4); /* == 3 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_strlen_screen -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_strlen_screen Retourne le nombre de caractères nécessaires pour afficher la chaîne UTF-8 sur l'écran. @@ -2094,9 +2032,9 @@ sur l'écran. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_strlen_screen (const char *string); ----------------------------------------- +---- Paramètres : @@ -2109,24 +2047,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int length_on_screen = weechat_utf8_strlen_screen ("é"); /* == 1 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_charcmp -^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_charcmp Compare deux caractères UTF-8. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_charcmp (const char *string1, const char *string2); ----------------------------------------- +---- Paramètres : @@ -2143,24 +2080,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int diff = weechat_utf8_charcmp ("aaa", "ccc"); /* == -2 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_charcasecmp -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_charcasecmp Compare deux caractères UTF-8 en ignorant la casse. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_charcasecmp (const char *string1, const char *string2); ----------------------------------------- +---- Paramètres : @@ -2177,15 +2113,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int diff = weechat_utf8_charcasecmp ("aaa", "CCC"); /* == -2 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_char_size_screen -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_char_size_screen Retourne le nombre de caractères nécessaires pour afficher le caractère UTF-8 sur l'écran. @@ -2193,9 +2128,9 @@ sur l'écran. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_char_size_screen (const char *string); ----------------------------------------- +---- Paramètres : @@ -2208,24 +2143,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int length_on_screen = weechat_utf8_char_size_screen ("é"); /* == 1 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_add_offset -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_add_offset Avancer de N caractères dans une chaîne UTF-8. Prototype : [source,C] ----------------------------------------- +---- char *weechat_utf8_add_offset (const char *string, int offset); ----------------------------------------- +---- Paramètres : @@ -2240,25 +2174,24 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *str = "chêne"; char *str2 = weechat_utf8_add_offset (str, 3); /* pointe vers "ne" */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_real_pos -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_real_pos Retourne la position réelle dans une chaîne UTF-8. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_real_pos (const char *string, int pos); ----------------------------------------- +---- Paramètres : @@ -2272,24 +2205,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int pos = weechat_utf8_real_pos ("chêne", 3); /* == 4 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_pos -^^^^^^^^^^^^^^^^ +==== weechat_utf8_pos Retourne la position dans une chaîne UTF-8. Prototype : [source,C] ----------------------------------------- +---- int weechat_utf8_pos (const char *string, int real_pos); ----------------------------------------- +---- Paramètres : @@ -2303,24 +2235,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int pos = weechat_utf8_pos ("chêne", 4); /* == 3 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_utf8_strndup -^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_strndup Retourne une chaîne dupliquée, avec au plus 'length' caractères. Prototype : [source,C] ----------------------------------------- +---- char *weechat_utf8_strndup (const char *string, int length); ----------------------------------------- +---- Paramètres : @@ -2334,32 +2265,30 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *string = weechat_utf8_strndup ("chêne", 3); /* retourne "chê" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. [[directories]] -Répertoires -~~~~~~~~~~~ +=== Répertoires Fonctions liées aux répertoires. -weechat_mkdir_home -^^^^^^^^^^^^^^^^^^ +==== weechat_mkdir_home Crée un répertoire dans le répertoire de WeeChat. Prototype : [source,C] ----------------------------------------- +---- int weechat_mkdir_home (char *directory, int mode); ----------------------------------------- +---- Paramètres : @@ -2373,35 +2302,34 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (!weechat_mkdir_home ("temp", 0755)) { /* erreur */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.mkdir_home(directory, mode) # exemple weechat.mkdir_home("temp", 0755) ----------------------------------------- +---- -weechat_mkdir -^^^^^^^^^^^^^ +==== weechat_mkdir Crée un répertoire. Prototype : [source,C] ----------------------------------------- +---- int weechat_mkdir (char *directory, int mode); ----------------------------------------- +---- Paramètres : @@ -2415,35 +2343,34 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (!weechat_mkdir ("/tmp/mydir", 0755)) { /* erreur */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.mkdir(directory, mode) # exemple weechat.mkdir("/tmp/mydir", 0755) ----------------------------------------- +---- -weechat_mkdir_parents -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_mkdir_parents Crée un répertoire et ses parents si besoin. Prototype : [source,C] ----------------------------------------- +---- int weechat_mkdir_parents (char *directory, int mode); ----------------------------------------- +---- Paramètres : @@ -2457,26 +2384,25 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (!weechat_mkdir_parents ("/tmp/my/dir", 0755)) { /* erreur */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.mkdir_parents(directory, mode) # exemple weechat.mkdir_parents("/tmp/my/dir", 0755) ----------------------------------------- +---- -weechat_exec_on_files -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_exec_on_files Balaye les fichiers dans un répertoire et exécute un "callback" pour chaque fichier. @@ -2484,13 +2410,13 @@ fichier. Prototype : [source,C] ----------------------------------------- +---- void weechat_exec_on_files (const char *directory, int hidden_files, void *data, void (*callback)(void *data, const char *filename)); ----------------------------------------- +---- Paramètres : @@ -2504,20 +2430,19 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- void callback (void *data, const char *filename) { /* ... */ } ... weechat_exec_on_files ("/tmp", 0, NULL, &callback); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_file_get_content -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_file_get_content _WeeChat ≥ 0.3.1._ @@ -2526,9 +2451,9 @@ Lit le contenu d'un fichier texte dans une chaîne de caractères. Prototype : [source,C] ----------------------------------------- +---- char *weechat_file_get_content (const char *filename); ----------------------------------------- +---- Paramètres : @@ -2542,34 +2467,32 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *contenu; contenu = weechat_file_get_content ("/tmp/test.txt"); /* ... */ free (contenu); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. [[util]] -Util -~~~~ +=== Util Quelques fonctions utiles. -weechat_util_timeval_cmp -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_timeval_cmp Compare deux structures "timeval". Prototype : [source,C] ----------------------------------------- +---- int weechat_util_timeval_cmp (struct timeval *tv1, struct timeval *tv2); ----------------------------------------- +---- Paramètres : @@ -2585,27 +2508,26 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_util_timeval_cmp (&tv1, &tv2) > 0) { /* tv1 > tv2 */ } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_util_timeval_diff -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_timeval_diff Retourne la différence (en millisecondes) entre deux structures "timeval". Prototype : [source,C] ----------------------------------------- +---- long weechat_util_timeval_diff (struct timeval *tv1, struct timeval *tv2); ----------------------------------------- +---- Paramètres : @@ -2619,24 +2541,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- long diff = weechat_util_timeval_diff (&tv1, &tv2); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_util_timeval_add -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_timeval_add Ajoute un intervalle (en millisecondes) à une structure "timeval". Prototype : [source,C] ----------------------------------------- +---- void weechat_util_timeval_add (struct timeval *tv, long interval); ----------------------------------------- +---- Paramètres : @@ -2646,15 +2567,14 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_util_timeval_add (&tv, 2000); /* ajoute 2 secondes */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_util_get_time_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_get_time_string _WeeChat ≥ 0.3.2._ @@ -2663,9 +2583,9 @@ Retourne la date/heure sous forme de chaîne construite avec "strftime". Prototype : [source,C] ----------------------------------------- +---- char *weechat_util_get_time_string (const time_t *date); ----------------------------------------- +---- Paramètres : @@ -2674,17 +2594,16 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- time_t date = time (NULL); weechat_printf (NULL, "date: %s", weechat_util_get_time_string (&date)); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_util_version_number -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_version_number _WeeChat ≥ 0.3.9._ @@ -2693,9 +2612,9 @@ Convertit une chaîne avec la version WeeChat en nombre. Prototype : [source,C] ----------------------------------------- +---- int weechat_util_version_number (const char *version); ----------------------------------------- +---- Paramètres : @@ -2705,33 +2624,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- version_number = weechat_util_version_number ("0.3.8"); /* == 0x00030800 */ version_number = weechat_util_version_number ("0.3.9-dev"); /* == 0x00030900 */ version_number = weechat_util_version_number ("0.3.9-rc1"); /* == 0x00030900 */ version_number = weechat_util_version_number ("0.3.9"); /* == 0x00030900 */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. [[sorted_lists]] -Listes triées -~~~~~~~~~~~~~ +=== Listes triées Fonctions pour les listes triées. -weechat_list_new -^^^^^^^^^^^^^^^^ +==== weechat_list_new Crée une nouvelle liste. Prototype : [source,C] ----------------------------------------- +---- struct t_weelist *weechat_list_new (); ----------------------------------------- +---- Valeur de retour : @@ -2740,35 +2657,34 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_weelist *list = weechat_list_new (); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype list = weechat.list_new() # exemple list = weechat.list_new() ----------------------------------------- +---- -weechat_list_add -^^^^^^^^^^^^^^^^ +==== weechat_list_add Ajoute un élément dans une liste. Prototype : [source,C] ----------------------------------------- +---- struct t_weelist_item *weechat_list_add (struct t_weelist *weelist, const char *data, const char *where, void *user_data); ----------------------------------------- +---- Paramètres : @@ -2787,34 +2703,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_weelist_item *my_item = weechat_list_add (list, "ma donnée", WEECHAT_LIST_POS_SORT, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype item = weechat.list_add(list, data, where, user_data) # exemple item = weechat.list_add(list, "ma donnée", weechat.WEECHAT_LIST_POS_SORT, "") ----------------------------------------- +---- -weechat_list_search -^^^^^^^^^^^^^^^^^^^ +==== weechat_list_search Recherche un élément dans une liste. Prototype : [source,C] ----------------------------------------- +---- struct t_weelist_item *weechat_list_search (struct t_weelist *weelist, const char *data); ----------------------------------------- +---- Paramètres : @@ -2828,23 +2743,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_weelist_item *item = weechat_list_search (list, "ma donnée"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype item = weechat.list_search(list, data) # exemple item = weechat.list_search(list, "ma donnée") ----------------------------------------- +---- -weechat_list_search_pos -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_list_search_pos _WeeChat ≥ 0.3.4._ @@ -2853,10 +2767,10 @@ Recherche la position d'un élément dans une liste. Prototype : [source,C] ----------------------------------------- +---- int weechat_list_search_pos (struct t_weelist *weelist, const char *data); ----------------------------------------- +---- Paramètres : @@ -2870,33 +2784,32 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int pos_item = weechat_list_search_pos (list, "ma donnée"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype pos_item = weechat.list_search_pos(list, data) # exemple pos_item = weechat.list_search_pos(list, "ma donnée") ----------------------------------------- +---- -weechat_list_casesearch -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_list_casesearch Recherche un élément dans la liste, sans tenir compte de la casse. Prototype : [source,C] ----------------------------------------- +---- struct t_weelist_item *weechat_list_casesearch (struct t_weelist *weelist, const char *data); ----------------------------------------- +---- Paramètres : @@ -2910,23 +2823,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_weelist_item *item = weechat_list_casesearch (list, "ma donnée"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype item = weechat.list_casesearch(list, data) # exemple item = weechat.list_casesearch(list, "ma donnée") ----------------------------------------- +---- -weechat_list_casesearch_pos -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_list_casesearch_pos _WeeChat ≥ 0.3.4._ @@ -2935,10 +2847,10 @@ Recherche la position d'un élément dans la liste, sans tenir compte de la cass Prototype : [source,C] ----------------------------------------- +---- int weechat_list_casesearch_pos (struct t_weelist *weelist, const char *data); ----------------------------------------- +---- Paramètres : @@ -2952,33 +2864,32 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int pos_item = weechat_list_casesearch_pos (list, "ma donnée"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype pos_item = weechat.list_casesearch_pos(list, data) # exemple pos_item = weechat.list_casesearch_pos(list, "ma donnée") ----------------------------------------- +---- -weechat_list_get -^^^^^^^^^^^^^^^^ +==== weechat_list_get Retourne un élément de la liste par sa position. Prototype : [source,C] ----------------------------------------- +---- struct t_weelist_item *weechat_list_get (struct t_weelist *weelist, int position); ----------------------------------------- +---- Paramètres : @@ -2992,32 +2903,31 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_weelist_item *item = weechat_list_get (list, 0); /* premier élément */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype item = weechat.list_get(list, position) # exemple item = weechat.list_get(list, 0) ----------------------------------------- +---- -weechat_list_set -^^^^^^^^^^^^^^^^ +==== weechat_list_set Affecte une nouvelle valeur pour un élément. Prototype : [source,C] ----------------------------------------- +---- void weechat_list_set (struct t_weelist_item *item, const char *value); ----------------------------------------- +---- Paramètres : @@ -3027,32 +2937,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_list_set (item, "nouvelle donnée"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.list_set(item, value) # exemple weechat.list_set(item, "nouvelle donnée") ----------------------------------------- +---- -weechat_list_next -^^^^^^^^^^^^^^^^^ +==== weechat_list_next Retourne l'éléement suivant dans la liste. Prototype : [source,C] ----------------------------------------- +---- struct t_weelist_item *weechat_list_next (struct t_weelist_item *item); ----------------------------------------- +---- Paramètres : @@ -3066,32 +2975,31 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_weelist_item *next_item = weechat_list_next (item); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype item = weechat.list_next(item) # exemple item = weechat.list_next(item) ----------------------------------------- +---- -weechat_list_prev -^^^^^^^^^^^^^^^^^ +==== weechat_list_prev Retourne l'élément précédent dans la liste. Prototype : [source,C] ----------------------------------------- +---- struct t_weelist_item *weechat_list_prev (struct t_weelist_item *item); ----------------------------------------- +---- Paramètres : @@ -3105,32 +3013,31 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_weelist_item *prev_item = weechat_list_prev (item); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype item = weechat.list_prev(item) # exemple item = weechat.list_prev(item) ----------------------------------------- +---- -weechat_list_string -^^^^^^^^^^^^^^^^^^^ +==== weechat_list_string Retourne la valeur de l'élément sous forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_list_string (struct t_weelist_item *item); ----------------------------------------- +---- Paramètres : @@ -3143,32 +3050,31 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "valeur de l'item : %s", weechat_list_string (item)); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.list_string(item) # exemple weechat.prnt("", "valeur de l'item : %s" % weechat.list_string(item)) ----------------------------------------- +---- -weechat_list_size -^^^^^^^^^^^^^^^^^ +==== weechat_list_size Retourne la taille de la liste (nombre d'éléments). Prototype : [source,C] ----------------------------------------- +---- char *weechat_list_size (struct t_weelist *weelist); ----------------------------------------- +---- Paramètres : @@ -3181,33 +3087,32 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "taille de la liste : %d", weechat_list_size (list)); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype size = weechat.list_size(list) # exemple weechat.prnt("", "taille de la liste : %d" % weechat.list_size(list)) ----------------------------------------- +---- -weechat_list_remove -^^^^^^^^^^^^^^^^^^^ +==== weechat_list_remove Supprime un élément de la liste. Prototype : [source,C] ----------------------------------------- +---- void weechat_list_remove (struct t_weelist *weelist, struct t_weelist_item *item); ----------------------------------------- +---- Paramètres : @@ -3217,32 +3122,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_list_remove (list, item); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.list_remove(list, item) # exemple weechat.list_remove(list, item) ----------------------------------------- +---- -weechat_list_remove_all -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_list_remove_all Supprime tous les éléments de la liste. Prototype : [source,C] ----------------------------------------- +---- void weechat_list_remove_all (struct t_weelist *weelist); ----------------------------------------- +---- Paramètres : @@ -3251,32 +3155,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_list_remove_all (list); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.list_remove_all(list) # exemple weechat.list_remove_all(list) ----------------------------------------- +---- -weechat_list_free -^^^^^^^^^^^^^^^^^ +==== weechat_list_free Supprime une liste. Prototype : [source,C] ----------------------------------------- +---- void weechat_list_free (struct t_weelist *weelist); ----------------------------------------- +---- Paramètres : @@ -3285,29 +3188,27 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_list_free (list); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.list_free(list) # exemple weechat.list_free(list) ----------------------------------------- +---- [[hashtables]] -Hashtables -~~~~~~~~~~ +=== Hashtables Fonctions pour les hashtables. -weechat_hashtable_new -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_new _WeeChat ≥ 0.3.3._ @@ -3316,7 +3217,7 @@ Crée une nouvelle hashtable. Prototype : [source,C] ----------------------------------------- +---- struct t_hashtable *weechat_hashtable_new (int size, const char *type_keys, const char *type_values, @@ -3325,7 +3226,7 @@ struct t_hashtable *weechat_hashtable_new (int size, int (*callback_keycmp)(struct t_hashtable *hashtable, const void *key1, const void *key2)); ----------------------------------------- +---- Paramètres : @@ -3370,19 +3271,18 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hashtable *hashtable = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, NULL, NULL); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_set_with_size -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_set_with_size _WeeChat ≥ 0.3.3, mis à jour dans la 0.4.2._ @@ -3392,11 +3292,11 @@ et la valeur. Prototype : [source,C] ----------------------------------------- +---- struct t_hashtable_item *weechat_hashtable_set_with_size (struct t_hashtable *hashtable, const void *key, int key_size, const void *value, int value_size); ----------------------------------------- +---- Paramètres : @@ -3415,16 +3315,15 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_hashtable_set_with_size (hashtable, "ma_cle", 0, my_buffer, sizeof (my_buffer_struct)); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_set -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_set _WeeChat ≥ 0.3.3, mis à jour dans la 0.4.2._ @@ -3433,10 +3332,10 @@ Ajoute ou met à jour une entrée dans la hashtable. Prototype : [source,C] ----------------------------------------- +---- struct t_hashtable_item *weechat_hashtable_set (struct t_hashtable *hashtable, const void *key, const void *value); ----------------------------------------- +---- Paramètres : @@ -3451,15 +3350,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_hashtable_set (hashtable, "ma_cle", "ma_valeur"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_get -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_get _WeeChat ≥ 0.3.3._ @@ -3468,9 +3366,9 @@ Retourne la valeur associée à une clé dans une hashtable. Prototype : [source,C] ----------------------------------------- +---- void *weechat_hashtable_get (struct t_hashtable *hashtable, void *key); ----------------------------------------- +---- Paramètres : @@ -3484,15 +3382,14 @@ Valeur en retour : Exemple en C : [source,C] ----------------------------------------- +---- void *value = weechat_hashtable_get (hashtable, "ma_cle"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_has_key -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_has_key _WeeChat ≥ 0.3.4._ @@ -3501,9 +3398,9 @@ Retourne 1 si la clé est dans la hashtable, sinon 0. Prototype : [source,C] ----------------------------------------- +---- int weechat_hashtable_has_key (struct t_hashtable *hashtable, void *key); ----------------------------------------- +---- Paramètres : @@ -3517,19 +3414,18 @@ Valeur en retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_hashtable_has_key (hashtable, "ma_cle")) { /* la clé est dans la hashtable */ /* ... */ } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_map -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_map _WeeChat ≥ 0.3.3._ @@ -3538,14 +3434,14 @@ Appelle une fonction pour chaque entrée d'une hashtable. Prototype : [source,C] ----------------------------------------- +---- void hashtable_map (struct t_hashtable *hashtable, void (*callback_map)(void *data, struct t_hashtable *hashtable, const void *key, const void *value), void *callback_map_data); ----------------------------------------- +---- Paramètres : @@ -3556,7 +3452,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- void map_cb (void *data, struct t_hashtable *hashtable, const void *key, const void *value) @@ -3568,13 +3464,12 @@ map_cb (void *data, struct t_hashtable *hashtable, } /* ... */ weechat_hashtable_map (hashtable, &map_cb, NULL); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_map_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_map_string _WeeChat ≥ 0.3.7._ @@ -3584,14 +3479,14 @@ et valeurs sous forme de chaînes. Prototype : [source,C] ----------------------------------------- +---- void hashtable_map_string (struct t_hashtable *hashtable, void (*callback_map)(void *data, struct t_hashtable *hashtable, const char *key, const char *value), void *callback_map_data); ----------------------------------------- +---- Paramètres : @@ -3606,7 +3501,7 @@ temporaires, elles sont supprimées après l'appel au "callback". Exemple en C : [source,C] ----------------------------------------- +---- void map_cb (void *data, struct t_hashtable *hashtable, const char *key, const char *value) @@ -3617,13 +3512,12 @@ map_cb (void *data, struct t_hashtable *hashtable, } /* ... */ weechat_hashtable_map_string (hashtable, &map_cb, NULL); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_get_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_get_integer _WeeChat ≥ 0.3.3._ @@ -3632,10 +3526,10 @@ Retourne une valeur entière pour une propriété d'une hashtable. Prototype : [source,C] ----------------------------------------- +---- int weechat_hashtable_get_integer (struct t_hashtable *hashtable, void *property); ----------------------------------------- +---- Paramètres : @@ -3651,15 +3545,14 @@ Valeur en retour : Exemple en C : [source,C] ----------------------------------------- +---- int items_count = weechat_hashtable_get_integer (hashtable, "items_count"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_get_string _WeeChat ≥ 0.3.4._ @@ -3668,10 +3561,10 @@ Retourne une valeur pour une propriété d'une hashtable sous forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_hashtable_get_string (struct t_hashtable *hashtable, const char *property); ----------------------------------------- +---- Paramètres : @@ -3705,18 +3598,17 @@ Valeur en retour : Exemples en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "les clés sont de type: %s", weechat_hashtable_get_string (hashtable, "type_keys")); weechat_printf (NULL, "liste des clés: %s", weechat_hashtable_get_string (hashtable, "keys")); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_set_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_set_pointer _WeeChat ≥ 0.3.4._ @@ -3725,10 +3617,10 @@ Affecte un pointeur à une propriété d'une hashtable. Prototype : [source,C] ----------------------------------------- +---- void weechat_hashtable_set_pointer (struct t_hashtable *hashtable, const char *property, void *pointer); ----------------------------------------- +---- Paramètres : @@ -3742,7 +3634,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- void my_free_value_cb (struct t_hashtable *hashtable, const void *key, void *value) { @@ -3750,13 +3642,12 @@ my_free_value_cb (struct t_hashtable *hashtable, const void *key, void *value) } weechat_hashtable_set_pointer (hashtable, "callback_free_value", &my_free_value_cb); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_add_to_infolist -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_add_to_infolist _WeeChat ≥ 0.3.3._ @@ -3765,11 +3656,11 @@ Ajoute les éléments d'une hashtable dans un objet infolist. Prototype : [source,C] ----------------------------------------- +---- int weechat_hashtable_add_to_infolist (struct t_hashtable *hashtable, struct t_infolist_item *infolist_item, const char *prefix); ----------------------------------------- +---- Paramètres : @@ -3784,7 +3675,7 @@ Valeur en retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_hashtable_add_to_infolist (hashtable, infolist_item, "testhash"); /* si la hashtable contient : @@ -3796,13 +3687,12 @@ weechat_hashtable_add_to_infolist (hashtable, infolist_item, "testhash"); "testhash_name_00001" = "cle2" "testhash_value_00001" = "valeur 2" */ ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_remove -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_remove _WeeChat ≥ 0.3.3._ @@ -3811,9 +3701,9 @@ Supprime un élément d'une hashtable. Prototype : [source,C] ----------------------------------------- +---- void weechat_hashtable_remove (struct t_hashtable *hashtable, const void *key); ----------------------------------------- +---- Paramètres : @@ -3823,15 +3713,14 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_hashtable_remove (hashtable, "ma_cle"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_remove_all -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_remove_all _WeeChat ≥ 0.3.3._ @@ -3840,9 +3729,9 @@ Supprime tous les éléments d'une hashtable. Prototype : [source,C] ----------------------------------------- +---- void weechat_hashtable_remove_all (struct t_hashtable *hashtable); ----------------------------------------- +---- Paramètres : @@ -3851,15 +3740,14 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_hashtable_remove_all (hashtable); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hashtable_free -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_free _WeeChat ≥ 0.3.3._ @@ -3868,9 +3756,9 @@ Supprime une hashtable. Prototype : [source,C] ----------------------------------------- +---- void weechat_hashtable_free (struct t_hashtable *hashtable); ----------------------------------------- +---- Paramètres : @@ -3879,33 +3767,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_hashtable_free (hashtable); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. [[configuration_files]] -Fichiers de configuration -~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Fichiers de configuration Fonctions pour les fichiers de configuration. -weechat_config_new -^^^^^^^^^^^^^^^^^^ +==== weechat_config_new Crée un nouveau fichier de configuration. Prototype : [source,C] ----------------------------------------- +---- struct t_config_file *weechat_config_new (const char *name, int (*callback_reload)(void *data, struct t_config_file *config_file), void *callback_reload_data); ----------------------------------------- +---- Paramètres : @@ -3937,7 +3823,7 @@ Vous ne devriez appeler cette fonction qu'après avoir créé les sections (avec Exemple en C : [source,C] ----------------------------------------- +---- int my_config_reload_cb (void *data, struct t_config_file *config_file) { @@ -3949,12 +3835,12 @@ my_config_reload_cb (void *data, struct t_config_file *config_file) struct t_config_file *config_file = weechat_config_new ("test", &my_config_reload_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype config_file = weechat.config_new(name, calback_reload, callback_reload_data) @@ -3964,17 +3850,16 @@ def my_config_reload_cb(data, config_file): return weechat.WEECHAT_RC_OK config_file = weechat.config_new("test", "my_config_reload_cb", "") ----------------------------------------- +---- -weechat_config_new_section -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_new_section Crée une nouvelle section dans un fichier de configuration. Prototype : [source,C] ----------------------------------------- +---- struct t_config_section *weechat_config_new_section ( struct t_config_file *config_file, const char *name, @@ -4005,7 +3890,7 @@ struct t_config_section *weechat_config_new_section ( struct t_config_section *section, struct t_config_option *option), void *callback_delete_option_data); ----------------------------------------- +---- Paramètres : @@ -4093,7 +3978,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_section_read_cb (void *data, struct t_config_file *config_file, struct t_config_section *section, const char *option_name, @@ -4167,12 +4052,12 @@ struct t_config_section *new_section2 = &my_section_write_default_cb, NULL, &my_section_create_option_cb, NULL, &my_section_delete_option_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype section = weechat.config_new_section(config_file, name, user_can_add_options, user_can_delete_options, @@ -4211,21 +4096,20 @@ section = weechat.config_new_section(config_file, "section1", 1, 1, "my_section_write_default_cb", "", "my_section_create_option_cb", "", "my_section_delete_option_cb", "") ----------------------------------------- +---- -weechat_config_search_section -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_search_section Recherche une section dans un fichier de configuration. Prototype : [source,C] ----------------------------------------- +---- struct t_config_section *weechat_config_search_section ( struct t_config_file *config_file, const char *section_name); ----------------------------------------- +---- Paramètres : @@ -4239,31 +4123,30 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_section *section = weechat_config_search_section (config_file, "section"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype section = weechat.config_search_section(config_file, section_name) # exemple section = weechat.config_search_section(config_file, "section") ----------------------------------------- +---- -weechat_config_new_option -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_new_option Crée une nouvelle option dans une section d'un fichier de configuration. Prototype : [source,C] ----------------------------------------- +---- struct t_config_option *weechat_config_new_option ( struct t_config_file *config_file, struct t_config_section *section, @@ -4286,7 +4169,7 @@ struct t_config_option *weechat_config_new_option ( void (*callback_delete)(void *data, struct t_config_option *option), void *callback_delete_data); ----------------------------------------- +---- Paramètres : @@ -4338,7 +4221,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- /* booléen */ struct t_config_option *option1 = weechat_config_new_option (config_file, section, "option1", "boolean", @@ -4404,12 +4287,12 @@ struct t_config_option *option5 = NULL, NULL, /* callback de vérification */ NULL, NULL, /* callback de changement de valeur */ NULL, NULL); /* callback de suppression de l'option */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype option = weechat.config_new_option(config_file, section, name, type, description, string_values, min, max, default_value, value, null_value_allowed, @@ -4464,7 +4347,7 @@ option5 = weechat.config_new_option(config_file, section, "option5", "color", "", "", "", "", "", "") ----------------------------------------- +---- [NOTE] En Ruby, les 3 "callbacks" + "data" (6 chaînes) doivent être données dans un @@ -4472,20 +4355,19 @@ tableau de 6 chaînes de caractères (en raison d'une limitation de Ruby à 15 paramètres par fonction), voir le 'Guide pour Scripts WeeChat' pour plus d'infos _(corrigé dans la version 0.4.1)_. -weechat_config_search_option -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_search_option Recherche une option dans une section d'un fichier de configuration. Prototype : [source,C] ----------------------------------------- +---- struct t_config_option *weechat_config_search_option ( struct t_config_file *config_file, struct t_config_section *section, const char *option_name); ----------------------------------------- +---- Paramètres : @@ -4500,24 +4382,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_search_option (config_file, section, "option"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype option = weechat.config_search_option(config_file, section, option_name) # exemple option = weechat.config_search_option(config_file, section, "option") ----------------------------------------- +---- -weechat_config_search_section_option -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_search_section_option Recherche une section et une option dans un fichier de configuration ou une section. @@ -4525,13 +4406,13 @@ section. Prototype : [source,C] ----------------------------------------- +---- void weechat_config_search_section_option (struct t_config_file *config_file, struct t_config_section *section, const char *option_name, struct t_config_section **section_found, struct t_config_option **option_found); ----------------------------------------- +---- Paramètres : @@ -4546,7 +4427,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_section *ptr_section; struct t_config_option *ptr_option; @@ -4563,26 +4444,25 @@ else { /* option non trouvée */ } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_config_search_with_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_search_with_string Recherche une option avec le nom complet. Prototype : [source,C] ----------------------------------------- +---- void weechat_config_search_with_string (const char *option_name, struct t_config_file **config_file, struct t_config_section **section, struct t_config_option **option, char **pos_option_name); ----------------------------------------- +---- Paramètres : @@ -4600,7 +4480,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_file *ptr_config_file; struct t_config_section *ptr_section; struct t_config_option *ptr_option; @@ -4619,22 +4499,21 @@ else { /* option non trouvée */ } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_config_string_to_boolean -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_string_to_boolean Vérifie si un texte est "vrai" ou "faux", au sens booléen. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_string_to_boolean (const char *text); ----------------------------------------- +---- Paramètres : @@ -4648,7 +4527,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_config_string_to_boolean (option_value)) { /* la valeur est "vrai" */ @@ -4657,32 +4536,31 @@ else { /* la valeur est "faux" */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_string_to_boolean(text) # exemple if weechat.config_string_to_boolean(text): # ... ----------------------------------------- +---- -weechat_config_option_reset -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_reset Réinitialise une option à sa valeur par défaut. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_option_reset (struct t_config_option *option, int run_callback); ----------------------------------------- +---- Paramètres : @@ -4700,7 +4578,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- switch (weechat_config_option_reset (option, 1)) { case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED: @@ -4713,12 +4591,12 @@ switch (weechat_config_option_reset (option, 1)) /* .... */ break; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.config_option_reset(option, run_callback) @@ -4730,20 +4608,19 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR: # ... ----------------------------------------- +---- -weechat_config_option_set -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_set Affecter une nouvelle valeur pour une option. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_option_set (struct t_config_option *option, const char *value, int run_callback); ----------------------------------------- +---- Paramètres : @@ -4761,7 +4638,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- switch (weechat_config_option_set (option, "nouvelle_valeur", 1)) { case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED: @@ -4774,12 +4651,12 @@ switch (weechat_config_option_set (option, "nouvelle_valeur", 1)) /* .... */ break; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.config_option_set(option, value, run_callback) @@ -4791,20 +4668,19 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR: # ... ----------------------------------------- +---- -weechat_config_option_set_null -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_set_null Affecter "null" (valeur indéfinie) à une option. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_option_set_null (struct t_config_option *option, int run_callback); ----------------------------------------- +---- Paramètres : @@ -4825,7 +4701,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- switch (weechat_config_option_set_null (option, 1)) { case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED: @@ -4838,12 +4714,12 @@ switch (weechat_config_option_set_null (option, 1)) /* .... */ break; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.config_option_set_null(option, run_callback) @@ -4855,19 +4731,18 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR: # ... ----------------------------------------- +---- -weechat_config_option_unset -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_unset Réinitialiser ou supprimer une option. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_option_unset (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -4885,7 +4760,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- switch (weechat_config_option_unset (option)) { case WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET: @@ -4901,12 +4776,12 @@ switch (weechat_config_option_unset (option)) /* .... */ break; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.config_option_unset(option) @@ -4920,20 +4795,19 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_ERROR: # ... ----------------------------------------- +---- -weechat_config_option_rename -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_rename Renomme une option. Prototype : [source,C] ----------------------------------------- +---- void weechat_config_option_rename (struct t_config_option *option, const char *new_name); ----------------------------------------- +---- Paramètres : @@ -4943,33 +4817,32 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_config_option_rename (option, "nouveau_nom"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.config_option_rename(option, new_name) # exemple weechat.config_option_rename(option, "nouveau_nom") ----------------------------------------- +---- -weechat_config_option_get_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_get_pointer Retourne un pointeur vers une propriété de l'option. Prototype : [source,C] ----------------------------------------- +---- void *weechat_config_option_get_pointer (struct t_config_option *option, const char *property); ----------------------------------------- +---- Paramètres : @@ -4998,24 +4871,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *description = weechat_config_option_get_pointer (option, "description"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_config_option_is_null -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_is_null Vérifie si une option est "null" (valeur non définie). Prototype : [source,C] ----------------------------------------- +---- int weechat_config_option_is_null (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5029,7 +4901,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_config_option_is_null (option)) { /* la valeur est "null" */ @@ -5038,31 +4910,30 @@ else { /* la valeur n'est pas "null" */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype is_null = weechat.config_option_is_null(option) # exemple if weechat.config_option_is_null(option): # ... ----------------------------------------- +---- -weechat_config_option_default_is_null -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_default_is_null Vérifie si la valeur par défaut d'une option est "null" (valeur non définie). Prototype : [source,C] ----------------------------------------- +---- int weechat_config_option_default_is_null (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5076,7 +4947,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_config_option_default_is_null (option)) { /* la valeur par défaut est "null" */ @@ -5085,31 +4956,30 @@ else { /* la valeur par défaut n'est pas "null" */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype is_null = weechat.config_option_default_is_null(option) # exemple if weechat.config_option_default_is_null(option): # ... ----------------------------------------- +---- -weechat_config_boolean -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_boolean Retourne la valeur booléenne de l'option. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_boolean (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5122,7 +4992,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); if (weechat_config_boolean (option)) { @@ -5132,12 +5002,12 @@ else { /* la valeur est "faux" */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_boolean(option) @@ -5145,19 +5015,18 @@ value = weechat.config_boolean(option) option = weechat.config_get("plugin.section.option") if weechat.config_boolean(option): # ... ----------------------------------------- +---- -weechat_config_boolean_default -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_boolean_default Retourne la valeur booléenne par défaut de l'option. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_boolean_default (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5170,7 +5039,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); if (weechat_config_boolean_default (option)) { @@ -5180,12 +5049,12 @@ else { /* la valeur est "faux" */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_boolean_default(option) @@ -5193,19 +5062,18 @@ value = weechat.config_boolean_default(option) option = weechat.config_get("plugin.section.option") if weechat.config_boolean_default(option): # ... ----------------------------------------- +---- -weechat_config_integer -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_integer Retourne la valeur entière de l'option. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_integer (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5218,34 +5086,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); int value = weechat_config_integer (option); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_integer(option) # exemple option = weechat.config_get("plugin.section.option") value = weechat.config_integer(option) ----------------------------------------- +---- -weechat_config_integer_default -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_integer_default Retourne la valeur entière par défaut de l'option. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_integer_default (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5258,34 +5125,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); int value = weechat_config_integer_default (option); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_integer_default(option) # exemple option = weechat.config_get("plugin.section.option") value = weechat.config_integer_default(option) ----------------------------------------- +---- -weechat_config_string -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_string Retourne la valeur de l'option, sous forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_config_string (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5298,34 +5164,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); const char *value = weechat_config_string (option); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_string(option) # exemple option = weechat.config_get("plugin.section.option") value = weechat.config_string(option) ----------------------------------------- +---- -weechat_config_string_default -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_string_default Retourne la valeur par défaut de l'option, sous forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_config_string_default (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5338,34 +5203,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); const char *value = weechat_config_string_default (option); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_string_default(option) # exemple option = weechat.config_get("plugin.section.option") value = weechat.config_string_default(option) ----------------------------------------- +---- -weechat_config_color -^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_color Retourne la valeur de l'option, sous forme de couleur. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_config_color (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5378,34 +5242,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); const char *color = weechat_config_color (option); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_color(option) # exemple option = weechat.config_get("plugin.section.option") value = weechat.config_color(option) ----------------------------------------- +---- -weechat_config_color_default -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_color_default Retourne la valeur par défaut de l'option, sous forme de couleur. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_config_color_default (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5419,25 +5282,24 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); const char *color = weechat_config_color_default (option); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_color_default(option) # exemple option = weechat.config_get("plugin.section.option") value = weechat.config_color_default(option) ----------------------------------------- +---- -weechat_config_write_option -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_write_option Écrit une ligne dans le fichier de configuration avec l'option et sa valeur (cette fonction doit être appelée uniquement dans un "callback" "write" ou @@ -5446,10 +5308,10 @@ weechat_config_write_option Prototype : [source,C] ----------------------------------------- +---- void weechat_config_write_option (struct t_config_file *config_file, struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5459,7 +5321,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- int my_section_write_cb (void *data, struct t_config_file *config_file, const char *section_name) @@ -5470,12 +5332,12 @@ my_section_write_cb (void *data, struct t_config_file *config_file, return WEECHAT_RC_OK; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.config_write_option(config_file, option) @@ -5484,10 +5346,9 @@ def my_section_write_cb(data, config_file, section_name): weechat.config_write_line(config_file, "ma_section", "") weechat.config_write_option(config_file, option) return weechat.WEECHAT_RC_OK ----------------------------------------- +---- -weechat_config_write_line -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_write_line Écrit une ligne dans un fichier de configuration (cette fonction doit être appelée uniquement dans un "callback" "write" ou "write_default" pour une @@ -5496,11 +5357,11 @@ section). Prototype : [source,C] ----------------------------------------- +---- void weechat_config_write_line (struct t_config_file *config_file, const char *option_name, const char *value, ...); ----------------------------------------- +---- Paramètres : @@ -5512,7 +5373,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- int my_section_write_cb (void *data, struct t_config_file *config_file, const char *section_name) @@ -5524,12 +5385,12 @@ my_section_write_cb (void *data, struct t_config_file *config_file, return WEECHAT_RC_OK; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.config_write_line(config_file, option_name, value) @@ -5538,19 +5399,18 @@ def my_section_write_cb(data, config_file, section_name): weechat.config_write_line(config_file, "ma_section", "") weechat.config_write_line(config_file, "option", "valeur") return weechat.WEECHAT_RC_OK ----------------------------------------- +---- -weechat_config_write -^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_write Écrit un fichier de configuration sur le disque. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_write (struct t_config_file *config_file); ----------------------------------------- +---- Paramètres : @@ -5565,7 +5425,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- switch (weechat_config_write (config_file)) { case WEECHAT_CONFIG_WRITE_OK: @@ -5578,12 +5438,12 @@ switch (weechat_config_write (config_file)) /* ... */ break; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.config_write(config_file) @@ -5595,19 +5455,18 @@ elif rc == weechat.WEECHAT_CONFIG_WRITE_MEMORY_ERROR: # ... elif rc == weechat.WEECHAT_CONFIG_WRITE_ERROR: # ... ----------------------------------------- +---- -weechat_config_read -^^^^^^^^^^^^^^^^^^^ +==== weechat_config_read Lit un fichier de configuration depuis le disque. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_read (struct t_config_file *config_file); ----------------------------------------- +---- Paramètres : @@ -5622,7 +5481,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- switch (weechat_config_read (config_file)) { case WEECHAT_CONFIG_READ_OK: @@ -5635,12 +5494,12 @@ switch (weechat_config_read (config_file)) /* ... */ break; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.config_read(config_file) @@ -5652,19 +5511,18 @@ elif rc == weechat.WEECHAT_CONFIG_READ_MEMORY_ERROR: # ... elif rc == weechat.WEECHAT_CONFIG_READ_FILE_NOT_FOUND: # ... ----------------------------------------- +---- -weechat_config_reload -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_reload Relit un fichier de configuration depuis le disque. Prototype : [source,C] ----------------------------------------- +---- int weechat_config_reload (struct t_config_file *config_file); ----------------------------------------- +---- Paramètres : @@ -5679,7 +5537,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- switch (weechat_config_reload (config_file)) { case WEECHAT_CONFIG_READ_OK: @@ -5692,12 +5550,12 @@ switch (weechat_config_reload (config_file)) /* ... */ break; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.config_reload(config_file) @@ -5709,19 +5567,18 @@ elif rc == weechat.WEECHAT_CONFIG_READ_MEMORY_ERROR: # ... elif rc == weechat.WEECHAT_CONFIG_READ_FILE_NOT_FOUND: # ... ----------------------------------------- +---- -weechat_config_option_free -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_free Libère une option. Prototype : [source,C] ----------------------------------------- +---- void weechat_config_option_free (struct t_config_option *option); ----------------------------------------- +---- Paramètres : @@ -5730,32 +5587,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_config_option_free (option); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.config_option_free(option) # exemple weechat.config_option_free(option) ----------------------------------------- +---- -weechat_config_section_free_options -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_section_free_options Libère toutes les options dans une section. Prototype : [source,C] ----------------------------------------- +---- void weechat_config_section_free_options (struct t_config_section *section); ----------------------------------------- +---- Paramètres : @@ -5764,32 +5620,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_config_section_free_options (section); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.config_section_free_options(section) # exemple weechat.config_section_free_options(section) ----------------------------------------- +---- -weechat_config_section_free -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_section_free Libère une section. Prototype : [source,C] ----------------------------------------- +---- void weechat_config_section_free (struct t_config_section *section); ----------------------------------------- +---- Paramètres : @@ -5798,32 +5653,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_config_section_free (section); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.config_section_free(section) # exemple weechat.config_section_free(section) ----------------------------------------- +---- -weechat_config_free -^^^^^^^^^^^^^^^^^^^ +==== weechat_config_free Libère un fichier de configuration. Prototype : [source,C] ----------------------------------------- +---- void weechat_config_free (struct t_config_file *config_file); ----------------------------------------- +---- Paramètres : @@ -5832,32 +5686,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_config_free (config_file); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.config_free(config_file) # exemple weechat.config_free(config_file) ----------------------------------------- +---- -weechat_config_get -^^^^^^^^^^^^^^^^^^ +==== weechat_config_get Recherche une option avec le nom complet. Prototype : [source,C] ----------------------------------------- +---- struct t_config_option *weechat_config_get (const char *option_name); ----------------------------------------- +---- Paramètres : @@ -5870,23 +5723,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("weechat.look.item_time_format"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype option = weechat.config_get(option_name) # exemple option = weechat.config_get("weechat.look.item_time_format") ----------------------------------------- +---- -weechat_config_get_plugin -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_get_plugin Recherche une option dans le fichier de configuration des extensions (plugins.conf). @@ -5894,9 +5746,9 @@ Recherche une option dans le fichier de configuration des extensions Prototype : [source,C] ----------------------------------------- +---- const char *weechat_config_get_plugin (const char *option_name); ----------------------------------------- +---- Paramètres : @@ -5910,25 +5762,24 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- /* si l'extension courante est "test", alors on cherche la valeur de l'option "plugins.var.test.option" dans le fichier plugins.conf */ char *value = weechat_config_get_plugin ("option"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_get_plugin(option_name) # exemple value = weechat.config_get_plugin("option") ----------------------------------------- +---- -weechat_config_is_set_plugin -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_is_set_plugin Vérifie si une option existe dans le fichier de configuration des extensions (plugins.conf). @@ -5936,9 +5787,9 @@ Vérifie si une option existe dans le fichier de configuration des extensions Prototype : [source,C] ----------------------------------------- +---- int weechat_config_is_set_plugin (const char *option_name); ----------------------------------------- +---- Paramètres : @@ -5952,7 +5803,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_config_is_set_plugin ("option")) { /* l'option existe */ @@ -5961,12 +5812,12 @@ else { /* l'option n'existe pas */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.config_is_set_plugin(option_name) @@ -5977,10 +5828,9 @@ if weechat.config_is_set_plugin("option"): else: # l'option n'existe pas # ... ----------------------------------------- +---- -weechat_config_set_plugin -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_set_plugin Affecter une nouvelle valeur pour une option dans le fichier de configuration des extensions (plugins.conf). @@ -5988,9 +5838,9 @@ des extensions (plugins.conf). Prototype : [source,C] ----------------------------------------- +---- int weechat_config_set_plugin (const char *option_name, const char *value); ----------------------------------------- +---- Paramètres : @@ -6008,7 +5858,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- switch (weechat_config_set_plugin ("option", "valeur_test")) { case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED: @@ -6024,12 +5874,12 @@ switch (weechat_config_set_plugin ("option", "valeur_test")) /* ... */ break; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.config_set_plugin(option_name, value) @@ -6043,10 +5893,9 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR: # ... ----------------------------------------- +---- -weechat_config_set_desc_plugin -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_set_desc_plugin _WeeChat ≥ 0.3.5._ @@ -6056,10 +5905,10 @@ extensions (plugins.conf). Prototype : [source,C] ----------------------------------------- +---- void weechat_config_set_desc_plugin (const char *option_name, const char *description); ----------------------------------------- +---- Paramètres : @@ -6074,14 +5923,14 @@ Une création future de cette option utilisera cette description. Exemple en C : [source,C] ----------------------------------------- +---- weechat_config_set_desc_plugin ("option", "description de l'option"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.config_set_desc_plugin(option_name, description) @@ -6089,19 +5938,18 @@ weechat.config_set_desc_plugin(option_name, description) version = weechat.info_get("version_number", "") or 0 if int(version) >= 0x00030500: weechat.config_set_desc_plugin("option", "description de l'option") ----------------------------------------- +---- -weechat_config_unset_plugin -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_unset_plugin Supprime une option du fichier de configuration des extensions (plugins.conf). Prototype : [source,C] ----------------------------------------- +---- int weechat_config_unset_plugin (const char *option_name); ----------------------------------------- +---- Paramètres : @@ -6120,7 +5968,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- switch (weechat_config_unset_plugin ("option")) { case WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET: @@ -6136,12 +5984,12 @@ switch (weechat_config_unset_plugin ("option")) /* ... */ break; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.config_unset_plugin(option_name) @@ -6155,16 +6003,14 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_ERROR: # ... ----------------------------------------- +---- [[key_bindings]] -Associations de touches -~~~~~~~~~~~~~~~~~~~~~~~ +=== Associations de touches Fonctions pour les associations de touches. -weechat_key_bind -^^^^^^^^^^^^^^^^ +==== weechat_key_bind _WeeChat ≥ 0.3.6._ @@ -6179,9 +6025,9 @@ créées. Pour supprimer une association de touche, utilisez Prototype : [source,C] ----------------------------------------- +---- int weechat_key_bind (const char *context, struct t_hashtable *keys); ----------------------------------------- +---- Paramètres : @@ -6200,7 +6046,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hashtable *keys = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, @@ -6214,12 +6060,12 @@ if (keys) weechat_key_bind ("mouse", keys); weechat_hashtable_free (keys); } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype num_keys = weechat.key_bind(context, keys) @@ -6228,10 +6074,9 @@ keys = { "@chat(python.test):button1": "hsignal:test_mouse", "@chat(python.test):wheelup": "/mycommand up", "@chat(python.test):wheeldown": "/mycommand down" } weechat.key_bind("mouse", keys) ----------------------------------------- +---- -weechat_key_unbind -^^^^^^^^^^^^^^^^^^ +==== weechat_key_unbind _WeeChat ≥ 0.3.6._ @@ -6243,9 +6088,9 @@ When calling this function, ensure that you will not remove a user key binding. Prototype : [source,C] ----------------------------------------- +---- int weechat_key_unbind (const char *context, const char *key); ----------------------------------------- +---- Paramètres : @@ -6261,18 +6106,18 @@ Valeur de retour : Exemples en C : [source,C] ----------------------------------------- +---- /* supprimer une seule touche */ weechat_key_unbind ("mouse", "@chat(plugin.buffer):button1"); /* supprimer toutes les touches avec la zone "chat(plugin.buffer)" */ weechat_key_unbind ("mouse", "area:chat(plugin.buffer)"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype num_keys = weechat.key_unbind(context, key) @@ -6283,39 +6128,37 @@ weechat.key_unbind("mouse", "@chat(plugin.buffer):button1") # supprimer toutes les touches avec la zone "chat(python.test)" weechat.key_unbind("mouse", "area:chat(python.test)") ----------------------------------------- +---- [[display]] -Affichage -~~~~~~~~~ +=== Affichage Fonctions pour afficher du texte dans les tampons. -weechat_prefix -^^^^^^^^^^^^^^ +==== weechat_prefix Retourne un préfixe. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_prefix (const char *prefix); ----------------------------------------- +---- Paramètres : * 'prefix' : nom du préfixe : [width="70%",cols="^2e,^1,^3,5",options="header"] -|======================================== +|=== | Préfixe | Valeur | Couleur | Description | error | `=!=` | jaune ("yellow") | Message d'erreur | network | `--` | violet ("magenta") | Message du réseau | action | `*` | blanc ("white") | Action personnelle | join | `-->` | vert clair ("lightgreen") | Quelqu'un a rejoint la discussion | quit | `<--` | rouge clair ("lightred") | Quelqu'un a quitté la discussion -|======================================== +|=== [NOTE] Les valeurs et couleurs peuvent être configurées avec la commande `/set`. @@ -6328,32 +6171,31 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "%sCeci est une erreur...", weechat_prefix ("error")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.prefix(prefix) # exemple weechat.prnt("", "%sCeci est une erreur..." % weechat.prefix("error")) ----------------------------------------- +---- -weechat_color -^^^^^^^^^^^^^ +==== weechat_color Retourne une chaîne avec un code couleur pour affichage. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_color (const char *color_name); ----------------------------------------- +---- Paramètres : @@ -6409,36 +6251,35 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "Couleur : %sbleu %scouleur par défaut %sjaune sur rouge", weechat_color ("blue"), weechat_color ("chat"), weechat_color ("yellow,red")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.color(color_name) # exemple weechat.prnt("", "%sCouleur : %sbleu %scouleur par défaut %sjaune sur rouge" % (weechat.color("blue"), weechat.color("chat"), weechat.color("yellow,red"))) ----------------------------------------- +---- -weechat_printf -^^^^^^^^^^^^^^ +==== weechat_printf Affiche un message sur un tampon. Prototype : [source,C] ----------------------------------------- +---- void weechat_printf (struct t_gui_buffer *buffer, const char *message, ...); ----------------------------------------- +---- Paramètres : @@ -6461,19 +6302,19 @@ positionnée à 0. Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "Bonjour sur le tampon WeeChat"); weechat_printf (buffer, "Bonjour sur ce tampon"); weechat_printf (buffer, "%sCeci est une erreur !", weechat_prefix ("error")); weechat_printf (buffer, " \tMessage sans préfixe mais avec \t quelques \t tabulations"); weechat_printf (buffer, "\t\tMessage sans heure/alignement"); weechat_printf (buffer, "\t\t"); /* ligne vide (sans heure) */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.prnt(buffer, message) @@ -6484,23 +6325,22 @@ weechat.prnt(buffer, "%sCeci est une erreur !" % weechat.prefix("error")) weechat.prnt(buffer, " \tMessage sans préfixe mais avec \t quelques \t tabulations") weechat.prnt(buffer, "\t\tMessage sans heure/alignement") weechat.prnt(buffer, "\t\t") # ligne vide (sans heure) ----------------------------------------- +---- [NOTE] La fonction s'appelle "print" dans les scripts ("prnt" en Python). -weechat_printf_date -^^^^^^^^^^^^^^^^^^^ +==== weechat_printf_date Affiche un message sur un tampon, en utilisant une date personnalisée. Prototype : [source,C] ----------------------------------------- +---- void weechat_printf_date (struct t_gui_buffer *buffer, time_t date, const char *message, ...); ----------------------------------------- +---- Paramètres : @@ -6512,25 +6352,24 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf_date (NULL, time (NULL) - 120, "Bonjour, il y a 2 minutes"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_printf_tags -^^^^^^^^^^^^^^^^^^^ +==== weechat_printf_tags Affiche un message sur un tampon, avec des étiquettes ("tags") personnalisées. Prototype : [source,C] ----------------------------------------- +---- void weechat_printf_tags (struct t_gui_buffer *buffer, const char *tags, const char *message, ...); ----------------------------------------- +---- Paramètres : @@ -6542,16 +6381,15 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf_tags (NULL, "notify_message", "Message avec une étiquette 'notify_message'"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_printf_date_tags -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_printf_date_tags Affiche un message sur un tampon, en utilisant une date et des étiquettes ("tags") personnalisées. @@ -6559,10 +6397,10 @@ Affiche un message sur un tampon, en utilisant une date et des étiquettes Prototype : [source,C] ----------------------------------------- +---- void weechat_printf_date_tags (struct t_gui_buffer *buffer, time_t date, const char *tags, const char *message, ...); ----------------------------------------- +---- Paramètres : @@ -6575,7 +6413,7 @@ Paramètres : Tags couramment utilisés (liste non exhaustive) : [width="70%",cols="1m,4",options="header"] -|======================================== +|=== | Tag | Description | no_filter | La ligne ne peut pas être filtrée | no_highlight | Aucun highlight n'est possible sur cette ligne @@ -6595,20 +6433,20 @@ Tags couramment utilisés (liste non exhaustive) : | irc_ctcp_reply | Réponse à un message CTCP | irc_smart_filter | Message IRC qui peut être filtré avec le "smart filter" (filtre intelligent) | away_info | Message avec une info d'absence -|======================================== +|=== Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf_date_tags (NULL, time (NULL) - 120, "notify_message", "Message il y a 2 minutes avec une étiquette 'notify_message'"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.prnt_date_tags(buffer, date, tags, message) @@ -6616,24 +6454,23 @@ weechat.prnt_date_tags(buffer, date, tags, message) time = int(time.time()) weechat.prnt_date_tags("", time - 120, "notify_message", "Message il y a 2 minutes avec une étiquette 'notify_message'") ----------------------------------------- +---- [NOTE] La fonction s'appelle "print_date_tags" dans les scripts ("prnt_date_tags" en Python). -weechat_printf_y -^^^^^^^^^^^^^^^^ +==== weechat_printf_y Affiche un message sur une ligne d'un tampon avec contenu libre. Prototype : [source,C] ----------------------------------------- +---- void weechat_printf_y (struct t_gui_buffer *buffer, int y, const char *message, ...); ----------------------------------------- +---- Paramètres : @@ -6644,35 +6481,34 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf_y (buffer, 2, "Mon message sur la 3ème ligne"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.prnt_y(buffer, y, message) # exemple weechat.prnt_y("", 2, "Mon message sur la 3ème ligne") ----------------------------------------- +---- [NOTE] La fonction s'appelle "print_y" dans les scripts ("prnt_y" en Python). -weechat_log_printf -^^^^^^^^^^^^^^^^^^ +==== weechat_log_printf Écrit un message dans le fichier de log WeeChat (weechat.log). Prototype : [source,C] ----------------------------------------- +---- void weechat_log_printf (const char *message, ...); ----------------------------------------- +---- Paramètres : @@ -6681,32 +6517,30 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_log_printf ("Mon message dans le fichier log"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.log_print(message) # exemple weechat.log_print("Mon message dans le fichier log") ----------------------------------------- +---- [NOTE] La fonction s'appelle "log_print" dans les scripts. [[hooks]] -Hooks -~~~~~ +=== Hooks [[hook_priority]] [float] -Hook priority -^^^^^^^^^^^^^ +==== Hook priority _WeeChat ≥ 0.3.4._ @@ -6725,24 +6559,23 @@ La priorité par défaut est 1000. Exemple en C : [source,C] ----------------------------------------- +---- /* accroche un modifieur avec priorité = 2000 */ weechat_hook_modifier ("2000|input_text_display", &modifier_cb, NULL); ----------------------------------------- +---- Les types de "hooks" suivants autorisent une priorité : command, command_run, signal, hsignal, config, completion, modifier, info, info_hashtable, infolist, hdata, focus. -weechat_hook_command -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_command Accroche une commande. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_command (const char *command, const char *description, const char *args, @@ -6754,7 +6587,7 @@ struct t_hook *weechat_hook_command (const char *command, char **argv, char **argv_eol), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -6799,7 +6632,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_command_cb (void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) @@ -6831,7 +6664,7 @@ struct t_hook *my_command_hook = &my_command_cb, /* callback_data */ NULL); ----------------------------------------- +---- Par exemple, si la commande appelée est `/command abc def ghi`, alors 'argv' et 'argv_eol' ont les valeurs suivantes : @@ -6852,7 +6685,7 @@ Pour les scripts, 'args' a la valeur "abc def ghi". Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_command(command, description, args, args_description, completion, callback, callback_data) @@ -6872,23 +6705,22 @@ hook = weechat.hook_command("monfiltre", "description de monfiltre", " || add %(filters_names) %(buffers_plugins_names)|*" " || del %(filters_names)|-all", "my_command_cb", "") ----------------------------------------- +---- -weechat_hook_command_run -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_command_run Intercepter une commande lorsqu'elle est exécutée par WeeChat. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_command_run (const char *command, int (*callback)(void *data, struct t_gui_buffer *buffer, const char *command), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -6918,7 +6750,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_command_run_cb (void *data, struct t_gui_buffer *buffer, const char *command) { @@ -6930,12 +6762,12 @@ my_command_run_cb (void *data, struct t_gui_buffer *buffer, const char *command) struct t_hook *my_command_run_hook = weechat_hook_command_run ("/input complete*", &my_command_run_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_command_run(command, callback, callback_data) @@ -6945,24 +6777,23 @@ def my_command_run_cb(data, buffer, command): return weechat.WEECHAT_RC_OK_EAT hook = weechat.hook_command_run("/input complete*", "my_command_run_cb", "") ----------------------------------------- +---- -weechat_hook_timer -^^^^^^^^^^^^^^^^^^ +==== weechat_hook_timer Accroche un "timer" (fonction appelée à intervalles réguliers). Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_timer (long interval, int align_second, int max_calls, int (*callback)(void *data, int remaining_calls), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -6991,7 +6822,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_timer_cb (void *data, int remaining_calls) { @@ -7002,12 +6833,12 @@ my_timer_cb (void *data, int remaining_calls) /* timer appelé toutes les 20 secondes */ struct t_hook *my_timer_hook = weechat_hook_timer (20 * 1000, 0, 0, &my_timer_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_timer(interval, align_second, max_calls, callback, callback_data) @@ -7018,17 +6849,16 @@ def my_timer_cb(data, remaining_calls): # timer appelé toutes les 20 secondes hook = weechat.hook_timer(20 * 1000, 0, 0, "my_timer_cb", "") ----------------------------------------- +---- -weechat_hook_fd -^^^^^^^^^^^^^^^ +==== weechat_hook_fd Accroche un descripteur de fichier (fichier ou socket). Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_fd (int fd, int flag_read, int flag_write, @@ -7036,7 +6866,7 @@ struct t_hook *weechat_hook_fd (int fd, int (*callback)(void *data, int fd), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -7061,7 +6891,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_fd_cb (void *data, int fd) { @@ -7073,12 +6903,12 @@ int sock = socket (AF_INET, SOCK_STREAM, 0); /* définir les options du socket */ /* ... */ struct t_hook *my_fd_hook = weechat_hook_fd (sock, 1, 0, 0, &my_fd_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_fd(fd, flag_read, flag_write, flag_exception, callback, callback_data) @@ -7089,10 +6919,9 @@ def my_fd_cb(data, fd): sock = ... hook = weechat.hook_fd(sock, 1, 0, 0, "my_fd_cb", "") ----------------------------------------- +---- -weechat_hook_process -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_process Accroche un processus (lancé par un fork), et intercepter sa sortie. @@ -7108,7 +6937,7 @@ les paramètres dans la hashtable 'options' _(WeeChat ≥ 0.4.0)_. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_process (const char *command, int timeout, int (*callback)(void *data, @@ -7117,7 +6946,7 @@ struct t_hook *weechat_hook_process (const char *command, const char *out, const char *err), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -7182,7 +7011,7 @@ données que lorsque le code retour est positif ou nul. Exemple en C : [source,C] ----------------------------------------- +---- int my_process_cb (void *data, const char *command, int return_code, const char *out, const char *err) @@ -7213,12 +7042,12 @@ my_process_cb (void *data, const char *command, int return_code, struct t_hook *my_process_hook = weechat_hook_process ("ls", 5000, &my_process_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_process(command, timeout, callback, callback_data) @@ -7236,10 +7065,9 @@ def my_process_cb(data, command, return_code, out, err): return weechat.WEECHAT_RC_OK hook = weechat.hook_process("ls", 5000, "my_process_cb", "") ----------------------------------------- +---- -weechat_hook_process_hashtable -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_process_hashtable _WeeChat ≥ 0.3.7._ @@ -7249,7 +7077,7 @@ hashtable, et intercepter sa sortie. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_process_hashtable (const char *command, struct t_hashtable *options, int timeout, @@ -7259,7 +7087,7 @@ struct t_hook *weechat_hook_process_hashtable (const char *command, const char *out, const char *err), void *callback_data); ----------------------------------------- +---- Les paramètres sont les mêmes que ceux de la fonction <<_weechat_hook_process,weechat_hook_process>>, avec un paramètre @@ -7298,7 +7126,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_process_cb (void *data, const char *command, int return_code, const char *out, const char *err) @@ -7378,12 +7206,12 @@ if (options_cmd2) &my_process_cb, NULL); weechat_hashtable_free (options_cmd2); } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_process_hashtable(command, options, timeout, callback, callback_data) @@ -7418,17 +7246,16 @@ hook3 = weechat.hook_process_hashtable("sh", { "arg1": "-c", "arg2": "ls -l /tmp | grep something" }, 20000, "my_process_cb", "") ----------------------------------------- +---- -weechat_hook_connect -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_connect Accroche une connexion (connexion à une machine distante en tâche de fond). Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_connect (const char *proxy, const char *address, int port, @@ -7446,7 +7273,7 @@ struct t_hook *weechat_hook_connect (const char *proxy, const char *error, const char *ip_address), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -7506,7 +7333,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_connect_cb (void *data, int status, int gnutls_rc, int sock, const char *error, const char *ip_address) @@ -7556,12 +7383,12 @@ struct t_hook *my_connect_hook = weechat_hook_connect (NULL, NULL, NULL, 0, /* GnuTLS */ NULL, &my_connect_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_connect(proxy, address, port, ipv6, retry, local_hostname, callback, callback_data) @@ -7594,17 +7421,16 @@ def my_connect_cb(data, status, gnutls_rc, sock, error, ip_address): hook = weechat.hook_connect("", "my.server.org", 1234, 1, 0, "", "my_connect_cb", "") ----------------------------------------- +---- -weechat_hook_print -^^^^^^^^^^^^^^^^^^ +==== weechat_hook_print Intercepte un message affiché. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_print (struct t_gui_buffer *buffer, const char *tags, const char *message, @@ -7619,7 +7445,7 @@ struct t_hook *weechat_hook_print (struct t_gui_buffer *buffer, const char *prefix, const char *message), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -7655,7 +7481,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_print_cb (void *data, struct t_gui_buffer *buffer, time_t date, int tags_count, const char **tags, @@ -7669,12 +7495,12 @@ my_print_cb (void *data, struct t_gui_buffer *buffer, time_t date, /* intercepter tous les messages, de tous les tampons, sans couleur */ struct t_hook *my_print_hook = weechat_hook_print (NULL, NULL, NULL, 1, &my_print_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_print(buffer, tags, message, strip_colors, callback, callback_data) @@ -7685,24 +7511,23 @@ def my_print_cb(data, buffer, date, tags, displayed, highlight, prefix, message) # intercepter tous les messages, de tous les tampons, sans couleur hook = weechat.hook_print("", "", "", 1, "my_print_cb", "") ----------------------------------------- +---- -weechat_hook_signal -^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_signal S'accroche à un signal. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_signal (const char *signal, int (*callback)(void *data, const char *signal, const char *type_data, void *signal_data), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -7710,7 +7535,7 @@ Paramètres : (priorité autorisée, voir la note sur la <<hook_priority,priorité>>) : [width="100%",cols="^1,^3,^4,5",options="header"] -|======================================== +|=== | Extension | Signal | Paramètres | Description | aspell | aspell_suggest + @@ -8221,7 +8046,7 @@ Paramètres : _(WeeChat ≥ 0.3.2)_ | Pointer : infolist avec l'info xfer | Le xfer s'est terminé -|======================================== +|=== [NOTE] ^(1)^ 'xxx' est le nom du serveur IRC, 'yyy' est le nom d'une commande IRC. @@ -8250,7 +8075,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_signal_cb (void *data, const char *signal, const char *type_data, void *signal_data) @@ -8262,12 +8087,12 @@ my_signal_cb (void *data, const char *signal, const char *type_data, /* intercepter le signal "quit" */ struct t_hook *my_signal_hook = weechat_hook_signal ("quit", &my_signal_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_signal(signal, callback, callback_data) @@ -8278,20 +8103,19 @@ def my_signal_cb(data, signal, signal_data): # intercepter le signal "quit" hook = weechat.hook_signal("quit", "my_signal_cb", "") ----------------------------------------- +---- -weechat_hook_signal_send -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_signal_send Envoie un signal. Prototype : [source,C] ----------------------------------------- +---- void weechat_hook_signal_send (const char *signal, const char *type_data, void *signal_data); ----------------------------------------- +---- Paramètres : @@ -8303,24 +8127,23 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_hook_signal_send ("mon_signal", WEECHAT_HOOK_SIGNAL_STRING, ma_chaine); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.hook_signal_send(signal, type_data, signal_data) # exemple weechat.hook_signal_send("mon_signal", weechat.WEECHAT_HOOK_SIGNAL_STRING, ma_chaine) ----------------------------------------- +---- [[signal_logger_backlog]] -Signal logger_backlog -+++++++++++++++++++++ +===== Signal logger_backlog Le signal "logger_backlog" peut être envoyé pour afficher l'historique de discussion dans le tampon (par exemple si vous ouvrez votre propre tampon dans @@ -8331,20 +8154,19 @@ Le paramètre est un pointeur vers le tampon. Exemple en C : [source,C] ----------------------------------------- +---- weechat_hook_signal_send ("logger_backlog", WEECHAT_HOOK_SIGNAL_POINTER, buffer); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- weechat.hook_signal_send("logger_backlog", weechat.WEECHAT_HOOK_SIGNAL_POINTER, buffer) ----------------------------------------- +---- [[signals_xxx_script_install]] -Signaux xxx_script_install -++++++++++++++++++++++++++ +===== Signaux xxx_script_install Cinq signaux peuvent être envoyés pour installer un script, selon le langage : @@ -8370,22 +8192,21 @@ Le paramètre est une chaîne avec le chemin vers le script à installer. Exemple en C : [source,C] ----------------------------------------- +---- weechat_hook_signal_send ("python_script_install", WEECHAT_HOOK_SIGNAL_STRING, "/home/xxx/.weechat/test.py"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- weechat.hook_signal_send("python_script_install", WEECHAT_HOOK_SIGNAL_STRING, "/home/xxx/.weechat/test.py") ----------------------------------------- +---- [[signals_xxx_script_remove]] -Signaux xxx_script_remove -+++++++++++++++++++++++++ +===== Signaux xxx_script_remove Cinq signaux peuvent être envoyés pour supprimer une liste de scripts, selon le langage : @@ -8407,24 +8228,23 @@ des virgules, nom du script sans le chemin, par exemple 'script.py'). Exemple en C : [source,C] ----------------------------------------- +---- /* décharge et supprime les scripts test.py et script.py */ weechat_hook_signal_send ("python_script_remove", WEECHAT_HOOK_SIGNAL_STRING, "test.py,script.py"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # décharge et supprime les scripts test.py et script.py weechat.hook_signal_send("python_script_remove", WEECHAT_HOOK_SIGNAL_STRING, "test.py,script.py") ----------------------------------------- +---- [[signal_irc_input_send]] -Signal irc_input_send -+++++++++++++++++++++ +===== Signal irc_input_send _WeeChat ≥ 0.3.4._ @@ -8451,7 +8271,7 @@ Le paramètre est une chaîne avec le format suivant : Exemples en C : [source,C] ----------------------------------------- +---- /* dis "Bonjour !" sur le serveur freenode, canal #weechat */ weechat_hook_signal_send ("irc_input_send", WEECHAT_HOOK_SIGNAL_STRING, "freenode;#weechat;1;;Bonjour !"); @@ -8459,12 +8279,12 @@ weechat_hook_signal_send ("irc_input_send", WEECHAT_HOOK_SIGNAL_STRING, /* envoie la commande "/whois FlashCode" sur le canal freenode, en basse priorité */ weechat_hook_signal_send ("irc_input_send", WEECHAT_HOOK_SIGNAL_STRING, "freenode;;2;;/whois FlashCode"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # dis "Bonjour !" sur le serveur freenode, canal #weechat weechat.hook_signal_send("irc_input_send", weechat.WEECHAT_HOOK_SIGNAL_STRING, "freenode;#weechat;1;;Bonjour !") @@ -8472,10 +8292,9 @@ weechat.hook_signal_send("irc_input_send", weechat.WEECHAT_HOOK_SIGNAL_STRING, # envoie la commande "/whois FlashCode" sur le canal freenode, en basse priorité weechat.hook_signal_send("irc_input_send", weechat.WEECHAT_HOOK_SIGNAL_STRING, "freenode;;2;;/whois FlashCode") ----------------------------------------- +---- -weechat_hook_hsignal -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_hsignal _WeeChat ≥ 0.3.4._ @@ -8484,13 +8303,13 @@ S'accroche à un hsignal (signal avec une hashtable). Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_hsignal (const char *signal, int (*callback)(void *data, const char *signal, struct t_hashtable *hashtable), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -8498,7 +8317,7 @@ Paramètres : (priorité autorisée, voir la note sur la <<hook_priority,priorité>>) : [width="100%",cols="^1,^3,5,5",options="header"] -|======================================== +|=== | Extension | Signal | Paramètres | Description | irc | irc_redirection_xxx_yyy ^(1)^ + @@ -8547,7 +8366,7 @@ Paramètres : 'parent_group' ('struct t_gui_nick_group *') : parent + 'nick' ('struct t_gui_nick *') : pseudo | Pseudo changé dans la liste de pseudos -|======================================== +|=== [NOTE] ^(1)^ 'xxx' est l'argument "signal" utilisé dans la redirection, 'yyy' est le @@ -8573,7 +8392,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_hsignal_cb (void *data, const char *signal, struct t_hashtable *hashtable) { @@ -8583,12 +8402,12 @@ my_hsignal_cb (void *data, const char *signal, struct t_hashtable *hashtable) struct t_hook *my_hsignal_hook = weechat_hook_hsignal ("test", &my_hsignal_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_hsignal(signal, callback, callback_data) @@ -8598,10 +8417,9 @@ def my_hsignal_cb(data, signal, hashtable): return weechat.WEECHAT_RC_OK hook = weechat.hook_hsignal("test", "my_hsignal_cb", "") ----------------------------------------- +---- -weechat_hook_hsignal_send -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_hsignal_send _WeeChat ≥ 0.3.4._ @@ -8610,9 +8428,9 @@ Envoie un hsignal (signal avec hashtable). Prototype : [source,C] ----------------------------------------- +---- void weechat_hook_hsignal_send (const char *signal, struct t_hashtable *hashtable); ----------------------------------------- +---- Paramètres : @@ -8622,7 +8440,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hashtable *hashtable = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, @@ -8634,22 +8452,21 @@ if (hashtable) weechat_hook_hsignal_send ("my_hsignal", hashtable); weechat_hashtable_free (hashtable); } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.hook_hsignal_send(signal, hashtable) # exemple weechat.hook_hsignal_send("my_hsignal", { "clé": "valeur" }) ----------------------------------------- +---- [[hsignal_irc_redirect_command]] -Hsignal irc_redirect_command -++++++++++++++++++++++++++++ +===== Hsignal irc_redirect_command _WeeChat ≥ 0.3.4._ @@ -8711,7 +8528,7 @@ sont des chaînes) : Exemple en C : [source,C] ----------------------------------------- +---- int test_whois_cb (void *data, const char *signal, struct t_hashtable *hashtable) { @@ -8737,12 +8554,12 @@ if (hashtable) "freenode;;2;;/whois FlashCode"); weechat_hashtable_free (hashtable); } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- def test_whois_cb(data, signal, hashtable): weechat.prnt("", "erreur = %s" % hashtable["error"]) weechat.prnt("", "sortie = %s" % hashtable["output"]) @@ -8754,11 +8571,10 @@ weechat.hook_hsignal_send("irc_redirect_command", "string": "FlashCode" }) weechat.hook_signal_send("irc_input_send", weechat.WEECHAT_HOOK_SIGNAL_STRING, "freenode;;2;;/whois FlashCode") ----------------------------------------- +---- [[hsignal_irc_redirect_pattern]] -Hsignal irc_redirect_pattern -++++++++++++++++++++++++++++ +===== Hsignal irc_redirect_pattern _WeeChat ≥ 0.3.4._ @@ -8782,9 +8598,9 @@ Pour chaque commande dans 'cmd_start', 'cmd_stop' et 'cmd_extra', il est possible de donner un entier avec la position de la chaîne "string" qui doit être trouvée dans le message reçu, par exemple : ----------------------------------------- +---- 352:1,354,401:1 ----------------------------------------- +---- Pour les commandes 352 et 401, la chaîne "string" doit être trouvée dans le message reçu, comme premier paramètre. @@ -8797,7 +8613,7 @@ chaque redirection. Exemple en C : [source,C] ----------------------------------------- +---- struct t_hashtable *hashtable = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, @@ -8818,12 +8634,12 @@ if (hashtable) /* ... */ weechat_hashtable_free (hashtable); } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- weechat.hook_hsignal_send("irc_redirect_pattern", { "pattern": "my_whois", "timeout": "30", "cmd_start": "311:1", @@ -8832,23 +8648,22 @@ weechat.hook_hsignal_send("irc_redirect_pattern", # rediriger maintenant la commande irc whois avec le hsignal irc_redirect_command, # en utilisant le modèle "my_whois" # ... ----------------------------------------- +---- -weechat_hook_config -^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_config S'accroche à une option de configuration. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_config (const char *option, int (*callback)(void *data, const char *option, const char *value), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -8873,7 +8688,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_config_cb (void *data, const char *option, const char *value) { @@ -8884,12 +8699,12 @@ my_config_cb (void *data, const char *option, const char *value) /* intercepter les changements de l'option "weechat.look.item_time_format" */ struct t_hook *my_config_hook = weechat_hook_config ("weechat.look.item_time_format", &my_config_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_config(option, callback, callback_data) @@ -8900,17 +8715,16 @@ def my_config_cb(data, option, value): # intercepter les changements de l'option "weechat.look.item_time_format" hook = weechat.hook_config("weechat.look.item_time_format", "my_config_cb", "") ----------------------------------------- +---- -weechat_hook_completion -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_completion Accroche une complétion. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_completion (const char *completion_item, const char *description, int (*callback)(void *data, @@ -8918,7 +8732,7 @@ struct t_hook *weechat_hook_completion (const char *completion_item, struct t_gui_buffer *buffer, struct t_gui_completion *completion), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -8953,7 +8767,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_completion_cb (void *data, const char *completion_item, struct t_gui_buffer *buffer, @@ -8969,12 +8783,12 @@ my_completion_cb (void *data, const char *completion_item, struct t_hook *my_completion_hook = weechat_hook_completion ("extension_item", "ma complétion !", &my_completion_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_completion(completion_item, description, callback, callback_data) @@ -8986,10 +8800,9 @@ def my_completion_cb(data, completion_item, buffer, completion): hook = weechat.hook_completion("extension_item", "ma complétion !", "my_completion_cb", "") ----------------------------------------- +---- -weechat_hook_completion_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_completion_get_string _WeeChat ≥ 0.3.4._ @@ -8998,10 +8811,10 @@ Retourne la valeur d'une propriété de la complétion sous forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_hook_completion_get_string (struct t_gui_completion *completion, const char *property); ----------------------------------------- +---- Paramètres : @@ -9014,7 +8827,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- int my_completion_cb (void *data, const char *completion_item, struct t_gui_buffer *buffer, @@ -9028,12 +8841,12 @@ my_completion_cb (void *data, const char *completion_item, return WEECHAT_RC_OK; } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.hook_completion_get_string(completion, property) @@ -9044,22 +8857,21 @@ def my_completion_cb(data, completion_item, buffer, completion): # complétion selon les paramètres # ... return weechat.WEECHAT_RC_OK ----------------------------------------- +---- -weechat_hook_completion_list_add -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_completion_list_add Ajoute un mot pour une complétion. Prototype : [source,C] ----------------------------------------- +---- void weechat_hook_completion_list_add (struct t_gui_completion *completion, const char *word, int nick_completion, const char *where); ----------------------------------------- +---- Paramètres : @@ -9076,29 +8888,28 @@ Exemple en C : voir <<_weechat_hook_completion,weechat_hook_completion>>. Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.hook_completion_list_add(completion, word, nick_completion, where) # exemple : voir la fonction hook_completion ci-dessus ----------------------------------------- +---- -weechat_hook_modifier -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_modifier Accroche un "modifieur". Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_modifier (const char *modifier, char *(*callback)(void *data, const char *modifier, const char *modifier_data, const char *string), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -9107,7 +8918,7 @@ Paramètres : (priorité autorisée, voir la note sur la <<hook_priority,priorité>>) : [width="100%",cols="^2,3,4,4",options="header"] -|======================================== +|=== | "Modifieur" | Données du "modifieur" | Chaîne | Sortie | charset_decode | @@ -9205,7 +9016,7 @@ Paramètres : extension + ";" + nom_tampon + ";" + étiquettes | Message affiché | Nouveau message affiché -|======================================== +|=== [NOTE] ^(1)^ 'xxx' est un nom de commande IRC. + @@ -9228,7 +9039,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char * my_modifier_cb (void *data, const char *modifier, const char *modifier_data, @@ -9253,12 +9064,12 @@ my_modifier_cb (void *data, const char *modifier, struct t_hook *my_modifier_hook = weechat_hook_modifier ("weechat_print", &my_modifier_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_modifier(modifier, callback, callback_data) @@ -9267,21 +9078,20 @@ def my_modifier_cb(data, modifier, modifier_data, string): return "%s xxx" % string hook = weechat.hook_modifier("weechat_print", "my_modifier_cb", "") ----------------------------------------- +---- -weechat_hook_modifier_exec -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_modifier_exec Exécute un ou plusieurs "modifieurs". Prototype : [source,C] ----------------------------------------- +---- char *weechat_hook_modifier_exec (const char *modifier, const char *modifier_data, const char *string); ----------------------------------------- +---- Paramètres : @@ -9296,31 +9106,30 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char *new_string = weechat_hook_modifier_exec ("mon_modifier", mes_donnees, ma_chaine); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.hook_modifier_exec(modifier, modifier_data, string) # exemple weechat.hook_modifier_exec("mon_modifier", mes_donnees, ma_chaine) ----------------------------------------- +---- -weechat_hook_info -^^^^^^^^^^^^^^^^^ +==== weechat_hook_info Accroche une information (le "callback" prend et retourne une chaîne). Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_info (const char *info_name, const char *description, const char *args_description, @@ -9328,7 +9137,7 @@ struct t_hook *weechat_hook_info (const char *info_name, const char *info_name, const char *arguments), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -9353,7 +9162,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- const char * my_info_cb (void *data, const char *info_name, const char *arguments) { @@ -9366,12 +9175,12 @@ struct t_hook *my_info_hook = weechat_hook_info ("mon_info", "Une information", "Info sur les paramètres", &my_info_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_info(info_name, description, args_description, callback, callback_data) @@ -9382,10 +9191,9 @@ def my_info_cb(data, info_name, arguments): hook = weechat.hook_info("mon_info", "Une information", "Info sur les paramètres", "my_info_cb", "") ----------------------------------------- +---- -weechat_hook_info_hashtable -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_info_hashtable _WeeChat ≥ 0.3.4._ @@ -9394,7 +9202,7 @@ Accroche une information (le "callback" prend et retourne une hashtable). Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_info_hashtable (const char *info_name, const char *description, const char *args_description, @@ -9403,7 +9211,7 @@ struct t_hook *weechat_hook_info_hashtable (const char *info_name, const char *info_name, struct t_hashtable *hashtable), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -9430,7 +9238,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hashtable * my_info_hashtable_cb (void *data, const char *info_name, struct t_hashtable *hashtable) { @@ -9444,12 +9252,12 @@ struct t_hook *my_info_hook = weechat_hook_info_hashtable ("mon_info_hashtable", "Info sur la hashtable en entrée", "Info sur la hashtable en sortie", &my_info_hashtable_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_info_hashtable(info_name, description, args_description, output_description, callback, callback_data) @@ -9462,10 +9270,9 @@ hook = weechat.hook_info_hashtable("mon_info_hashtable", "Une information", "Info sur la hashtable en entrée", "Info sur la hashtable en sortie", "my_info_hashtable_cb", "") ----------------------------------------- +---- -weechat_hook_infolist -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_infolist Accroche une infolist : le "callback" retournera un pointeur vers l'infolist demandée. @@ -9473,7 +9280,7 @@ demandée. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_infolist (const char *infolist_name, const char *description, const char *pointer_description, @@ -9483,7 +9290,7 @@ struct t_hook *weechat_hook_infolist (const char *infolist_name, void *pointer, const char *arguments), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -9510,7 +9317,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_infolist * my_infolist_cb (void *data, const char *infolist_name, void *pointer, const char *arguments) @@ -9529,12 +9336,12 @@ struct t_hook *my_infolist = weechat_hook_infolist ("mon_infolist", "Info sur le pointeur", "Info sur les paramètres", &my_infolist_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_infolist(infolist_name, description, pointer_description, args_description, callback, callback_data) @@ -9548,23 +9355,22 @@ def my_infolist_cb(data, infolist_name, pointer, arguments): hook = weechat.hook_infolist("mon_infolist", "Mon infolist", "Info sur le pointeur", "Info sur les paramètres", "my_infolist_cb", "") ----------------------------------------- +---- -weechat_hook_hdata -^^^^^^^^^^^^^^^^^^ +==== weechat_hook_hdata Accroche un hdata : le "callback" retournera un pointeur vers le hdata demandé. Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_hdata (const char *hdata_name, const char *description, struct t_hdata *(*callback)(void *data, const char *hdata_name), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -9586,7 +9392,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata * my_hdata_cb (void *data, const char *hdata_name) { @@ -9602,13 +9408,12 @@ my_hdata_cb (void *data, const char *hdata_name) struct t_hook *my_hdata = weechat_hook_hdata ("mon_hdata", "Hdata pour ma structure", &my_hdata_cb, NULL); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hook_focus -^^^^^^^^^^^^^^^^^^ +==== weechat_hook_focus Accroche un focus : évènement souris ou touche du clavier pressée dans le mode "curseur" (mouvement libre du curseur). @@ -9616,12 +9421,12 @@ Accroche un focus : évènement souris ou touche du clavier pressée dans le mod Prototype : [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_focus (const char *area, struct t_hashtable *(*callback)(void *data, struct t_hashtable *info), void *callback_data); ----------------------------------------- +---- Paramètres : @@ -9652,7 +9457,7 @@ Contenu de la hashtable envoyée au "callback" (les clés et valeurs sont de typ "string) : [width="100%",cols="5m,5,8,3",options="header"] -|======================================== +|=== | Clé ^(1)^ | Description | Exemples de valeur | Valeur si non applicable | _x | Colonne sur l'écran 2+| "0" ... "n" | _y | Ligne sur l'écran 2+| "0" ... "n" @@ -9683,7 +9488,7 @@ Contenu de la hashtable envoyée au "callback" (les clés et valeurs sont de typ | _bar_item_name | Nom de l'objet de barre | "buffer_nicklist", "hotlist", ... | "" | _bar_item_line | Ligne dans l'objet de barre | "0" ... "n" | "-1" | _bar_item_col | Colonne dans l'objet de barre | "0" ... "n" | "-1" -|======================================== +|=== [NOTE] ^(1)^ Il y a les mêmes clés suffixées par "2" (c'est-à-dire : "_x2", "_y2", @@ -9698,13 +9503,13 @@ relâché). + Informations additionnelles pour l'objet de barre "buffer_nicklist" : [width="70%",cols="3m,3,8",options="header"] -|======================================== +|=== | Clé | Extension ^(1)^ | Description | nick | core | Pseudonyme | prefix | core | Préfixe du pseudonyme | group | core | Nom du groupe | irc_host | irc | Nom d'hôte pour le pseudonyme (si connu) -|======================================== +|=== [NOTE] ^(1)^ Le nom de l'extension qui définit un hook_focus pour retourner des infos @@ -9718,7 +9523,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hashtable * my_focus_nicklist_cb (void *data, struct t_hashtable *info) { @@ -9731,12 +9536,12 @@ my_focus_nicklist_cb (void *data, struct t_hashtable *info) /* ajoute le focus sur la liste des pseudos */ struct t_hook *my_focus = weechat_hook_focus ("buffer_nicklist", &my_focus_nicklist_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hook = weechat.hook_focus(area, callback, callback_data) @@ -9747,10 +9552,9 @@ def my_focus_nicklist_cb(data, info): return my_dict hook = weechat.hook_focus("buffer_nicklist", "my_focus_nicklist_cb", "") ----------------------------------------- +---- -weechat_hook_set -^^^^^^^^^^^^^^^^ +==== weechat_hook_set _WeeChat ≥ 0.3.9._ @@ -9759,10 +9563,10 @@ Affecte une valeur à une propriété d'un hook. Prototype : [source,C] ----------------------------------------- +---- void weechat_hook_set (struct t_hook *hook, const char *property, const char *value); ----------------------------------------- +---- Paramètres : @@ -9770,39 +9574,38 @@ Paramètres : * 'property' et 'value' : nom de la propriété, avec sa valeur : [width="100%",cols="^2,4,8",options="header"] -|======================================== +|=== | Nom | Valeur | Description | subplugin | toute chaîne | Nom de la sous-extension (couramment un nom de script, qui est affiché dans `/help commande` pour un hook de type 'command') -|======================================== +|=== Exemple en C : [source,C] ----------------------------------------- +---- struct t_hook *my_command_hook = weechat_hook_command ("abcd", "description", "args", "description args", "", &my_command_cb, NULL); weechat_hook_set (my_command_hook, "subplugin", "test"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_unhook -^^^^^^^^^^^^^^ +==== weechat_unhook Décroche quelque chose qui est a été accroché. Prototype : [source,C] ----------------------------------------- +---- void weechat_unhook (struct t_hook *hook); ----------------------------------------- +---- Paramètres : @@ -9811,68 +9614,65 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hook *my_hook = weechat_hook_command ( /* ... */ ); /* ... */ weechat_unhook (my_hook); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.unhook(hook) # exemple weechat.unhook(my_hook) ----------------------------------------- +---- -weechat_unhook_all -^^^^^^^^^^^^^^^^^^ +==== weechat_unhook_all Décroche tout ce qui a été accroché par l'extension courante. Prototype : [source,C] ----------------------------------------- +---- void weechat_unhook_all (); ----------------------------------------- +---- Exemple en C : [source,C] ----------------------------------------- +---- weechat_unhook_all (); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.unhook_all() # exemple weechat.unhook_all() ----------------------------------------- +---- [[buffers]] -Buffers -~~~~~~~ +=== Buffers Fonctions pour créer/interroger/fermer les tampons. -weechat_buffer_new -^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_new Ouvre un nouveau tampon. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_buffer *weechat_buffer_new (const char *name, int (*input_callback)(void *data, struct t_gui_buffer *buffer, @@ -9881,7 +9681,7 @@ struct t_gui_buffer *weechat_buffer_new (const char *name, int (*close_callback)(void *data, struct t_gui_buffer *buffer), void *close_callback_data); ----------------------------------------- +---- Paramètres : @@ -9913,7 +9713,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_input_cb (void *data, struct t_gui_buffer *buffer, const char *input_data) { @@ -9932,12 +9732,12 @@ my_close_cb (void *data, struct t_gui_buffer *buffer) struct t_gui_buffer *my_buffer = weechat_buffer_new ("mon_buffer", &my_input_cb, NULL, &my_close_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype buffer = weechat.buffer_new(name, input_callback, input_callback_data, close_callback, close_callback_data) @@ -9952,10 +9752,9 @@ def my_close_cb(data, buffer): return weechat.WEECHAT_RC_OK buffer = weechat.buffer_new("mon_buffer", "my_input_cb", "", "my_close_cb", "") ----------------------------------------- +---- -weechat_current_buffer -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_current_buffer Retourne un pointeur vers le tampon courant (le tampon affiché par la fenêtre courante). @@ -9963,9 +9762,9 @@ courante). Prototype : [source,C] ----------------------------------------- +---- struct t_gui_buffer *weechat_current_buffer (); ----------------------------------------- +---- Valeur de retour : @@ -9974,33 +9773,32 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (weechat_current_buffer (), "Texte sur le tampon courant"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype buffer = weechat.current_buffer() # exemple weechat.prnt(weechat.current_buffer(), "Texte sur le tampon courant") ----------------------------------------- +---- -weechat_buffer_search -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_search Recherche un tampon par l'extension et/ou le nom. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_buffer *weechat_buffer_search (const char *plugin, const char *name); ----------------------------------------- +---- Paramètres : @@ -10015,24 +9813,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_buffer *my_buffer = weechat_buffer_search ("mon_extension", "mon_tampon"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype buffer = weechat.buffer_search(plugin, name) # exemple buffer = weechat.buffer_search("mon_extension", "mon_tampon") ----------------------------------------- +---- -weechat_buffer_search_main -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_search_main Recherche le tampon principal de WeeChat (tampon 'core', premier tampon affiché lorsque WeeChat démarre). @@ -10040,9 +9837,9 @@ affiché lorsque WeeChat démarre). Prototype : [source,C] ----------------------------------------- +---- struct t_gui_buffer *weechat_buffer_search_main (); ----------------------------------------- +---- Valeur de retour : @@ -10051,32 +9848,31 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_buffer *weechat_buffer = weechat_buffer_search_main (); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype buffer = weechat.buffer_search_main() # exemple buffer = weechat.buffer_search_main() ----------------------------------------- +---- -weechat_buffer_clear -^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_clear Efface le contenu d'un tampon. Prototype : [source,C] ----------------------------------------- +---- void weechat_buffer_clear (struct t_gui_buffer *buffer); ----------------------------------------- +---- Paramètres : @@ -10085,19 +9881,19 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_buffer *my_buffer = weechat_buffer_search ("mon_extension", "mon_tampon"); if (my_buffer) { weechat_buffer_clear (my_buffer); } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.buffer_clear(buffer) @@ -10105,19 +9901,18 @@ weechat.buffer_clear(buffer) buffer = weechat.buffer_search("mon_extension", "mon_tampon") if buffer != "": weechat.buffer_clear(buffer) ----------------------------------------- +---- -weechat_buffer_close -^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_close Ferme un tampon. Prototype : [source,C] ----------------------------------------- +---- void weechat_buffer_close (struct t_gui_buffer *buffer); ----------------------------------------- +---- Paramètres : @@ -10126,18 +9921,18 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_buffer *my_buffer = weechat_buffer_new ("mon_tampon", &my_input_cb, NULL, &my_close_cb, NULL); /* ... */ weechat_buffer_close (my_buffer); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.buffer_close(buffer) @@ -10145,10 +9940,9 @@ weechat.buffer_close(buffer) buffer = weechat.buffer_new("mon_tampon", "my_input_cb", "", "my_close_cb", "") # ... weechat.buffer_close(buffer) ----------------------------------------- +---- -weechat_buffer_merge -^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_merge Mélange le tampon avec un autre tampon : les deux tampons continueront d'exister chacun de leur côté, mais avec le même numéro, et WeeChat affichera @@ -10157,10 +9951,10 @@ les lignes des deux tampons (lignes mélangées). Prototype : [source,C] ----------------------------------------- +---- void weechat_buffer_merge (struct t_gui_buffer *buffer, struct t_gui_buffer *target_buffer); ----------------------------------------- +---- Paramètres : @@ -10170,36 +9964,35 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- /* mélanger le tampon courant avec le tampon "core" */ weechat_buffer_merge (weechat_current_buffer (), weechat_buffer_search_main ()); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.buffer_merge(buffer, target_buffer) # exemple # mélanger le tampon courant avec le tampon "core" weechat.buffer_merge(weechat.current_buffer(), weechat.buffer_search_main()) ----------------------------------------- +---- -weechat_buffer_unmerge -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_unmerge Supprime le mélange d'un tampon. Prototype : [source,C] ----------------------------------------- +---- void weechat_buffer_unmerge (struct t_gui_buffer *buffer, int number); ----------------------------------------- +---- Paramètres : @@ -10210,33 +10003,32 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_buffer_unmerge (weechat_current_buffer (), 1); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.buffer_unmerge(buffer, number) # exemple weechat.buffer_unmerge(weechat.current_buffer(), 1) ----------------------------------------- +---- -weechat_buffer_get_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_get_integer Retourne une valeur entière pour une propriété du tampon. Prototype : [source,C] ----------------------------------------- +---- int weechat_buffer_get_integer (struct t_gui_buffer *buffer, const char *property); ----------------------------------------- +---- Paramètres : @@ -10288,34 +10080,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "mon numéro de tampon est : %d", weechat_buffer_get_integer (mon_tampon, "number")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.buffer_get_integer(buffer, property) # exemple weechat.prnt("", "mon numéro de tampon est : %d" % weechat.buffer_get_integer(my_buffer, "number")) ----------------------------------------- +---- -weechat_buffer_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_get_string Retourne la valeur d'une propriété du tampon sous forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_buffer_get_string (struct t_gui_buffer *buffer, const char *property); ----------------------------------------- +---- Paramètres : @@ -10347,16 +10138,16 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "nom / nom court du tampon sont : %s / %s", weechat_buffer_get_string (my_buffer, "name"), weechat_buffer_get_string (my_buffer, "short_name")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.buffer_get_string(buffer, property) @@ -10364,20 +10155,19 @@ value = weechat.buffer_get_string(buffer, property) weechat.prnt("", "nom / nom court du tampon sont : %s / %s" % (weechat.buffer_get_string(my_buffer, "name"), weechat.buffer_get_string(my_buffer, "short_name"))) ----------------------------------------- +---- -weechat_buffer_get_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_get_pointer Retourne la valeur d'une propriété sous forme d'un pointeur. Prototype : [source,C] ----------------------------------------- +---- void *weechat_buffer_pointer (struct t_gui_buffer *buffer, const char *property); ----------------------------------------- +---- Paramètres : @@ -10394,34 +10184,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "pointeur vers l'extension de mon tampon : %lx", weechat_buffer_get_pointer (mon_tampon, "plugin")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.buffer_get_pointer(buffer, property) # exemple weechat.prnt("", "pointeur vers l'extension de mon tampon : %s" % weechat.buffer_get_pointer(my_buffer, "plugin")) ----------------------------------------- +---- -weechat_buffer_set -^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_set Affecte une valeur à une propriété d'un tampon. Prototype : [source,C] ----------------------------------------- +---- void weechat_buffer_set (struct t_gui_buffer *buffer, const char *property, const char *value); ----------------------------------------- +---- Paramètres : @@ -10429,7 +10218,7 @@ Paramètres : * 'property' et 'value' : nom de la propriété, avec sa valeur : [width="100%",cols="^2,4,8",options="header"] -|======================================== +|=== | Nom | Valeur | Description | hotlist | "+", "-", WEECHAT_HOTLIST_LOW, WEECHAT_HOTLIST_MESSAGE, @@ -10549,12 +10338,12 @@ Paramètres : | localvar_del_xxx | - | Supprime la variable locale 'xxx' -|======================================== +|=== Exemple en C : [source,C] ----------------------------------------- +---- /* désactiver la hotlist (pour tous les tampons) */ weechat_buffer_set (NULL, "hotlist", "-"); @@ -10569,12 +10358,12 @@ weechat_buffer_set (mon_tampon, "localvar_set_toto", "abc"); /* supprimer la variable locale "toto" */ weechat_buffer_set (mon_tampon, "localvar_del_toto", NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.buffer_set(buffer, property, value) @@ -10594,20 +10383,19 @@ weechat.buffer_set(my_buffer, "localvar_set_toto", "abc") # supprimer la variable locale "toto" weechat.buffer_set(my_buffer, "localvar_del_toto", "") ----------------------------------------- +---- -weechat_buffer_set_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_set_pointer Affecte un pointeur à une propriété d'un tampon. Prototype : [source,C] ----------------------------------------- +---- void weechat_buffer_set_pointer (struct t_gui_buffer *buffer, const char *property, void *pointer); ----------------------------------------- +---- Paramètres : @@ -10629,18 +10417,18 @@ Paramètres : Prototypes pour les "callbacks" : [source,C] ----------------------------------------- +---- int close_callback (void *data, struct t_gui_buffer *buffer); int input_callback (void *data, struct t_gui_buffer *buffer, const char *input_data); int nickcmp_callback (void *data, struct t_gui_buffer *buffer, const char *nick1, const char *nick2); ----------------------------------------- +---- Exemple en C : [source,C] ----------------------------------------- +---- int my_close_cb (void *data, struct t_gui_buffer *buffer) { @@ -10649,13 +10437,12 @@ my_close_cb (void *data, struct t_gui_buffer *buffer) } weechat_buffer_set_pointer (mon_tampon, "close_callback", &my_close_cb); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_buffer_string_replace_local_var -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_string_replace_local_var Remplace les variables locales dans une chaîne par leurs valeurs, en utilisant les variables locales du tampon. @@ -10663,10 +10450,10 @@ les variables locales du tampon. Prototype : [source,C] ----------------------------------------- +---- char *weechat_buffer_string_replace_local_var (struct t_gui_buffer *buffer, const char *string); ----------------------------------------- +---- Paramètres : @@ -10680,18 +10467,18 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_buffer_set (mon_tampon, "localvar_set_toto", "abc"); char *str = weechat_buffer_string_replace_local_var (mon_tampon, "test avec $toto"); /* str contient "test avec abc" */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.buffer_string_replace_local_var(buffer, string) @@ -10699,10 +10486,9 @@ value = weechat.buffer_string_replace_local_var(buffer, string) weechat.buffer_set(my_buffer, "localvar_set_toto", "abc") str = weechat.buffer_string_replace_local_var(my_buffer, "test avec $toto") # str contient "test avec abc" ----------------------------------------- +---- -weechat_buffer_match_list -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_match_list _WeeChat ≥ 0.3.5._ @@ -10711,9 +10497,9 @@ Vérifie si le tampon correspond à la liste de tampons. Prototype : [source,C] ----------------------------------------- +---- int weechat_buffer_match_list (struct t_gui_buffer *buffer, const char *string); ----------------------------------------- +---- Paramètres : @@ -10731,7 +10517,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_buffer *buffer = weechat_buffer_search ("irc", "freenode.#weechat"); if (buffer) { @@ -10740,12 +10526,12 @@ if (buffer) weechat_printf (NULL, "%d", weechat_buffer_match_list (buffer, "irc.freenode.*")); /* 1 */ weechat_printf (NULL, "%d", weechat_buffer_match_list (buffer, "irc.oftc.*,python.*")); /* 0 */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype match = weechat.buffer_match_list(buffer, string) @@ -10756,25 +10542,23 @@ if buffer: weechat.prnt("", "%d" % weechat.buffer_match_list(buffer, "*,!*#weechat*")) # 0 weechat.prnt("", "%d" % weechat.buffer_match_list(buffer, "irc.freenode.*")) # 1 weechat.prnt("", "%d" % weechat.buffer_match_list(buffer, "irc.oftc.*,python.*")) # 0 ----------------------------------------- +---- [[windows]] -Fenêtres -~~~~~~~~ +=== Fenêtres Fonctions pour interroger les fenêtres. -weechat_current_window -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_current_window Retourne le pointeur vers la fenêtre courante. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_window *weechat_current_window (); ----------------------------------------- +---- Valeur de retour : @@ -10783,23 +10567,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_window *current_window = weechat_current_window (); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype window = weechat.current_window() # exemple current_window = weechat.current_window() ----------------------------------------- +---- -weechat_window_search_with_buffer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_window_search_with_buffer _WeeChat ≥ 0.3.5._ @@ -10808,9 +10591,9 @@ Retourne le pointeur vers la fenêtre affichant un tampon. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_window *weechat_window_search_with_buffer (struct t_gui_buffer *buffer); ----------------------------------------- +---- Paramètre : @@ -10824,36 +10607,35 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "fenêtre affichant le tampon core: %lx", weechat_window_search_with_buffer (weechat_buffer_search_main ())); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype window = weechat.window_search_with_buffer(buffer) # exemple weechat.prnt("", "fenêtre affichant le tampon core: %s" % weechat.window_search_with_buffer(weechat.buffer_search_main())) ----------------------------------------- +---- -weechat_window_get_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_window_get_integer Retourne la valeur entière d'une propriété de la fenêtre. Prototype : [source,C] ----------------------------------------- +---- int weechat_window_get_integer (struct t_gui_window *window, const char *property); ----------------------------------------- +---- Paramètres : @@ -10892,16 +10674,16 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "la fenêtre courante est en position (x,y) : (%d,%d)", weechat_window_get_integer (weechat_current_window (), "win_x"), weechat_window_get_integer (weechat_current_window (), "win_y")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.window_get_integer(window, property) @@ -10909,10 +10691,9 @@ value = weechat.window_get_integer(window, property) weechat.prnt("", "la fenêtre courante est en position (x,y) : (%d,%d)" % (weechat.window_get_integer(weechat.current_window(), "win_x"), weechat.window_get_integer(weechat.current_window(), "win_y"))) ----------------------------------------- +---- -weechat_window_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_window_get_string Retourne la valeur d'une propriété de la fenêtre sous forme d'une chaîne. @@ -10923,10 +10704,10 @@ version future. Prototype : [source,C] ----------------------------------------- +---- int weechat_window_get_string (struct t_gui_window *window, const char *property); ----------------------------------------- +---- Paramètres : @@ -10937,18 +10718,17 @@ Valeur de retour : * valeur de la propriété, sous forme de chaîne -weechat_window_get_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_window_get_pointer Retourne la valeur d'une propriété, sous forme d'un pointeur. Prototype : [source,C] ----------------------------------------- +---- void *weechat_window_get_pointer (struct t_gui_window *window, const char *property); ----------------------------------------- +---- Paramètres : @@ -10964,35 +10744,34 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "tampon affiché dans la fenêtre courante : %lx", weechat_window_get_pointer (weechat_current_window (), "buffer")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.window_get_pointer(window, property) # exemple weechat.prnt("", "tampon affiché dans la fenêtre courante : %s" % weechat.window_get_pointer(weechat.current_window(), "buffer")) ----------------------------------------- +---- -weechat_window_set_title -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_window_set_title Définit le titre du terminal. Prototype : [source,C] ----------------------------------------- +---- void weechat_window_set_title (const char *title); ----------------------------------------- +---- Paramètres : @@ -11001,42 +10780,40 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_window_set_title ("nouveau titre ici"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.window_set_title(window, title) # exemple weechat.window_set_title("nouveau titre ici") ----------------------------------------- +---- [[nicklist]] -Nicklist -~~~~~~~~ +=== Nicklist Fonctions pour la liste des pseudos. -weechat_nicklist_add_group -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_add_group Ajoute un groupe dans la liste des pseudos. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_nick_group *weechat_nicklist_add_group (struct t_gui_buffer *buffer, struct t_gui_nick_group *parent_group, const char *name, const char *color, int visible); ----------------------------------------- +---- Paramètres : @@ -11069,40 +10846,39 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_nick_group *my_group = weechat_nicklist_add_group (my_buffer, my_parent_group, "groupe_test", "weechat.color.nicklist_group", 1); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype group = weechat.nicklist_add_group(buffer, parent_group, name, color, visible) # exemple group = weechat.nicklist_add_group(my_buffer, my_parent_group, "groupe_test", "weechat.color.nicklist_group", 1) ----------------------------------------- +---- -weechat_nicklist_search_group -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_search_group Recherche un groupe dans la liste des pseudos. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_nick_group *weechat_nicklist_search_group (struct t_gui_buffer *buffer, struct t_gui_nick_group *from_group, const char *name); ----------------------------------------- +---- Paramètres : @@ -11118,31 +10894,30 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_nick_group *ptr_group = weechat_nicklist_search_group (my_buffer, NULL, "groupe_test"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype group = weechat.nicklist_search_group(buffer, from_group, name) # exemple group = weechat.nicklist_search_group(my_buffer, "", "groupe_test") ----------------------------------------- +---- -weechat_nicklist_add_nick -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_add_nick Ajoute un pseudo dans un groupe. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_nick_group *weechat_nicklist_add_nick (struct t_gui_buffer *buffer, struct t_gui_nick_group *group, const char *name, @@ -11150,7 +10925,7 @@ struct t_gui_nick_group *weechat_nicklist_add_nick (struct t_gui_buffer *buffer, const char *prefix, const char *prefix_color, int visible); ----------------------------------------- +---- Paramètres : @@ -11183,19 +10958,19 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_nick *my_nick = weechat_nicklist_add_nick (my_buffer, my_group, "test_nick", (nick_away) ? "weechat.color.nicklist_away" : "bar_fg", "@", "lightgreen", 1); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype nick = weechat.nicklist_add_nick(buffer, group, name, color, prefix, prefix_color, visible) @@ -11205,21 +10980,20 @@ if nick_away: else: color = "bar_fg" nick = weechat.nicklist_add_nick(my_buffer, my_group, "test_nick", color, "@", "lightgreen", 1) ----------------------------------------- +---- -weechat_nicklist_search_nick -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_search_nick Recherche un pseudo dans la liste des pseudos. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_nick *weechat_nicklist_search_nick (struct t_gui_buffer *buffer, struct t_gui_nick_group *from_group, const char *name); ----------------------------------------- +---- Paramètres : @@ -11235,34 +11009,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_nick *ptr_nick = weechat_nicklist_search_nick (my_buffer, NULL, "test_nick"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype nick = weechat.nicklist_search_nick(buffer, from_group, name) # exemple nick = weechat.nicklist_search_nick(my_buffer, "", "test_nick") ----------------------------------------- +---- -weechat_nicklist_remove_group -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_remove_group Supprime un groupe de la liste des pseudos. Prototype : [source,C] ----------------------------------------- +---- void weechat_nicklist_remove_group (struct t_gui_buffer *buffer, struct t_gui_nick_group *group); ----------------------------------------- +---- Paramètres : @@ -11273,33 +11046,32 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_nicklist_remove_group (my_buffer, my_group); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.nicklist_remove_group(buffer, group) # exemple weechat.nicklist_remove_group(my_buffer, my_group) ----------------------------------------- +---- -weechat_nicklist_remove_nick -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_remove_nick Supprime un pseudo de la liste des pseudos. Prototype : [source,C] ----------------------------------------- +---- void weechat_nicklist_remove_nick (struct t_gui_buffer *buffer, struct t_gui_nick *nick); ----------------------------------------- +---- Paramètres : @@ -11309,32 +11081,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_nicklist_remove_nick (my_buffer, my_nick); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.nicklist_remove_nick(buffer, nick) # exemple weechat.nicklist_remove_nick(my_buffer, my_nick) ----------------------------------------- +---- -weechat_nicklist_remove_all -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_remove_all Supprime tous les groupes/pseudos de la liste des pseudos. Prototype : [source,C] ----------------------------------------- +---- void weechat_nicklist_remove_all (struct t_gui_buffer *buffer); ----------------------------------------- +---- Paramètres : @@ -11343,23 +11114,22 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_nicklist_remove_all (my_buffer); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.nicklist_remove_all(buffer) # exemple weechat.nicklist_remove_all(my_buffer) ----------------------------------------- +---- -weechat_nicklist_get_next_item -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_get_next_item _WeeChat ≥ 0.3.7._ @@ -11369,11 +11139,11 @@ principalement pour afficher la liste des pseudos). Prototype : [source,C] ----------------------------------------- +---- void weechat_nicklist_get_next_item (struct t_gui_buffer *buffer, struct t_gui_nick_group **group, struct t_gui_nick **nick); ----------------------------------------- +---- Paramètres : @@ -11384,7 +11154,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_nick_group *ptr_group; struct t_gui_nick *ptr_nick; @@ -11405,13 +11175,12 @@ while (ptr_group || ptr_nick) } weechat_nicklist_get_next_item (buffer, &ptr_group, &ptr_nick); } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_nicklist_group_get_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_group_get_integer _WeeChat ≥ 0.3.4._ @@ -11420,11 +11189,11 @@ Retourne une valeur entière pour une propriété du groupe. Prototype : [source,C] ----------------------------------------- +---- int weechat_nicklist_group_get_integer (struct t_gui_buffer *buffer, struct t_gui_nick_group *group, const char *property); ----------------------------------------- +---- Paramètres : @@ -11441,23 +11210,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int visible = weechat_nicklist_group_get_integer (buffer, group, "visible"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.nicklist_group_get_integer(buffer, group, property) # exemple visible = weechat.nicklist_group_get_integer(buffer, group, "visible") ----------------------------------------- +---- -weechat_nicklist_group_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_group_get_string _WeeChat ≥ 0.3.4._ @@ -11466,11 +11234,11 @@ Retourne la valeur d'une propriété du groupe sous forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_nicklist_group_get_string (struct t_gui_buffer *buffer, struct t_gui_nick_group *group, const char *property); ----------------------------------------- +---- Paramètres : @@ -11487,23 +11255,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- const char *color = weechat_nicklist_group_get_string (buffer, group, "color"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.nicklist_group_get_string(buffer, group, property) # exemple color = weechat.nicklist_group_get_string(buffer, group, "color") ----------------------------------------- +---- -weechat_nicklist_group_get_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_group_get_pointer _WeeChat ≥ 0.3.4._ @@ -11512,11 +11279,11 @@ Retourne la valeur d'une propriété du groupe sous forme d'un pointeur. Prototype : [source,C] ----------------------------------------- +---- void *weechat_nicklist_group_get_pointer (struct t_gui_buffer *buffer, struct t_gui_nick_group *group, const char *property); ----------------------------------------- +---- Paramètres : @@ -11532,23 +11299,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_nick_group *parent = weechat_nicklist_group_get_pointer (buffer, group, "parent"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.nicklist_group_get_pointer(buffer, group, property) # exemple parent = weechat.nicklist_group_get_pointer(buffer, group, "parent") ----------------------------------------- +---- -weechat_nicklist_group_set -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_group_set _WeeChat ≥ 0.3.4._ @@ -11557,12 +11323,12 @@ Affecte une valeur à une propriété d'un groupe. Prototype : [source,C] ----------------------------------------- +---- void weechat_nicklist_group_set (struct t_gui_buffer *buffer, struct t_gui_nick_group *group, const char *property, const char *value); ----------------------------------------- +---- Paramètres : @@ -11571,7 +11337,7 @@ Paramètres : * 'property' et 'value' : nom de la propriété, avec sa valeur : [width="100%",cols="^2,4,8",options="header"] -|======================================== +|=== | Nom | Valeur | Description | color | nom d'option de couleur WeeChat | @@ -11580,12 +11346,12 @@ Paramètres : | visible | "0", "1" | "0" = groupe caché, "1" = groupe visible -|======================================== +|=== Exemples en C : [source,C] ----------------------------------------- +---- /* changer la couleur du groupe en "bar_fg" */ weechat_nicklist_group_set (buffer, group, "color", "bar_fg"); @@ -11594,12 +11360,12 @@ weechat_nicklist_group_set (buffer, group, "color", "yellow"); /* cacher le groupe dans la liste des pseudos */ weechat_nicklist_group_set (buffer, group, "visible", "0"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.nicklist_group_set(buffer, group, property, value) @@ -11613,10 +11379,9 @@ weechat.nicklist_group_set(buffer, group, "color", "yellow") # cacher le groupe dans la liste des pseudos weechat.nicklist_group_set(buffer, group, "visible", "0") ----------------------------------------- +---- -weechat_nicklist_nick_get_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_nick_get_integer _WeeChat ≥ 0.3.4._ @@ -11625,11 +11390,11 @@ Retourne une valeur entière pour une propriété du pseudo. Prototype : [source,C] ----------------------------------------- +---- int weechat_nicklist_nick_get_integer (struct t_gui_buffer *buffer, struct t_gui_nick *nick, const char *property); ----------------------------------------- +---- Paramètres : @@ -11645,23 +11410,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int visible = weechat_nicklist_nick_get_integer (buffer, nick, "visible"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.nicklist_nick_get_integer(buffer, nick, property) # exemple visible = weechat.nicklist_nick_get_integer(buffer, nick, "visible") ----------------------------------------- +---- -weechat_nicklist_nick_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_nick_get_string _WeeChat ≥ 0.3.4._ @@ -11670,11 +11434,11 @@ Retourne la valeur d'une propriété du pseudo sous forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_nicklist_nick_get_string (struct t_gui_buffer *buffer, struct t_gui_nick *nick, const char *property); ----------------------------------------- +---- Paramètres : @@ -11693,23 +11457,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- const char *color = weechat_nicklist_nick_get_string (buffer, nick, "color"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.nicklist_nick_get_string(buffer, nick, property) # exemple color = weechat.nicklist_nick_get_string(buffer, nick, "color") ----------------------------------------- +---- -weechat_nicklist_nick_get_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_nick_get_pointer _WeeChat ≥ 0.3.4._ @@ -11718,11 +11481,11 @@ Retourne la valeur d'une propriété du pseudo sous forme d'un pointeur. Prototype : [source,C] ----------------------------------------- +---- void *weechat_nicklist_nick_get_pointer (struct t_gui_buffer *buffer, struct t_gui_nick *nick, const char *property); ----------------------------------------- +---- Paramètres : @@ -11738,23 +11501,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_nick_group *group = weechat_nicklist_nick_get_pointer (buffer, nick, "group"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.nicklist_nick_get_pointer(buffer, nick, property) # exemple group = weechat.nicklist_nick_get_pointer(buffer, nick, "group") ----------------------------------------- +---- -weechat_nicklist_nick_set -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_nick_set _WeeChat ≥ 0.3.4._ @@ -11763,12 +11525,12 @@ Affecte une valeur à une propriété d'un pseudo. Prototype : [source,C] ----------------------------------------- +---- void weechat_nicklist_nick_set (struct t_gui_buffer *buffer, struct t_gui_nick *nick, const char *property, const char *value); ----------------------------------------- +---- Paramètres : @@ -11777,7 +11539,7 @@ Paramètres : * 'property' et 'value' : nom de la propriété, avec sa valeur : [width="100%",cols="^2,4,8",options="header"] -|======================================== +|=== | Nom | Valeur | Description | color | nom d'option de couleur WeeChat | @@ -11793,12 +11555,12 @@ Paramètres : | visible | "0", "1" | "0" = pseudo caché, "1" = pseudo visible -|======================================== +|=== Exemples en C : [source,C] ----------------------------------------- +---- /* changer la couleur du pseudo en cyan */ weechat_nicklist_nick_set (buffer, nick, "color", "cyan"); @@ -11810,12 +11572,12 @@ weechat_nicklist_nick_set (buffer, nick, "prefix_color", "yellow"); /* cacher le pseudo dans la liste des pseudos */ weechat_nicklist_nick_set (buffer, nick, "visible", "0"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.nicklist_nick_set(buffer, nick, property, value) @@ -11832,25 +11594,23 @@ weechat.nicklist_nick_set(buffer, nick, "prefix_color", "yellow") # cacher le pseudo dans la liste des pseudos weechat.nicklist_nick_set(buffer, nick, "visible", "0") ----------------------------------------- +---- [[bars]] -Barres -~~~~~~ +=== Barres Fonctions pour les barres. -weechat_bar_item_search -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_bar_item_search Recherche un objet de barre. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_bar_item *weechat_bar_item_search (const char *name); ----------------------------------------- +---- Paramètres : @@ -11863,23 +11623,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_bar_item *bar_item = weechat_bar_item_search ("myitem"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype bar_item = weechat.bar_item_search(name) # exemple bar_item = weechat.bar_item_search("myitem") ----------------------------------------- +---- -weechat_bar_item_new -^^^^^^^^^^^^^^^^^^^^ +==== weechat_bar_item_new _Mis à jour dans la version 0.4.2._ @@ -11888,7 +11647,7 @@ Créé un nouvel objet de barre. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_bar_item *weechat_bar_item_new (const char *name, char *(*build_callback)(void *data, struct t_gui_bar_item *item, @@ -11896,7 +11655,7 @@ struct t_gui_bar_item *weechat_bar_item_new (const char *name, struct t_gui_buffer *buffer, struct t_hashtable *extra_info), void *build_callback_data); ----------------------------------------- +---- Paramètres : @@ -11923,7 +11682,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char * my_build_callback (void *data, struct t_gui_bar_item *item, @@ -11937,7 +11696,7 @@ my_build_callback (void *data, struct t_gui_bar_item *my_item = weechat_bar_item_new ("myitem", &my_build_callback, NULL); ----------------------------------------- +---- Script (Python) : @@ -11950,7 +11709,7 @@ avant le nom, voir l'exemple ci-dessous (supporté seulement dans WeeChat ≥ 0.4.2). [source,python] ----------------------------------------- +---- # prototype bar_item = weechat.bar_item_new(name, build_callback, build_callback_data) @@ -11965,10 +11724,9 @@ def my_build_callback2(data, item, window, buffer, extra_info): return "mon contenu" bar_item2 = weechat.bar_item_new("(extra)myitem2", "my_build_callback2", "") # WeeChat ≥ 0.4.2 ----------------------------------------- +---- -weechat_bar_item_update -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_bar_item_update Met à jour le contenu d'un objet de barre, en appelant son "callback" de construction. @@ -11976,9 +11734,9 @@ construction. Prototype : [source,C] ----------------------------------------- +---- void weechat_bar_item_update (const char *name); ----------------------------------------- +---- Paramètres : @@ -11987,32 +11745,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_bar_item_update ("myobjet"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.bar_item_update(name) # exemple weechat.bar_item_update("myitem") ----------------------------------------- +---- -weechat_bar_item_remove -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_bar_item_remove Supprime un objet de barre. Prototype : [source,C] ----------------------------------------- +---- void weechat_bar_item_remove (struct t_gui_bar_item *item); ----------------------------------------- +---- Paramètres : @@ -12021,32 +11778,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_bar_item_remove (&my_item); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.bar_item_remove(item) # exemple weechat.bar_item_remove(myitem) ----------------------------------------- +---- -weechat_bar_search -^^^^^^^^^^^^^^^^^^ +==== weechat_bar_search Recherche une barre. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_bar *weechat_bar_search (const char *name); ----------------------------------------- +---- Paramètres : @@ -12059,30 +11815,29 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_bar *bar = weechat_bar_search ("my_barre"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype bar = weechat.bar_search(name) # exemple bar = weechat.bar_search("mybar") ----------------------------------------- +---- -weechat_bar_new -^^^^^^^^^^^^^^^ +==== weechat_bar_new Créé une nouvelle barre. Prototype : [source,C] ----------------------------------------- +---- struct t_gui_bar *weechat_bar_new (const char *name, const char *hidden, const char *priority, @@ -12098,7 +11853,7 @@ struct t_gui_bar *weechat_bar_new (const char *name, const char *color_bg, const char *separator, const char *items); ----------------------------------------- +---- Paramètres : @@ -12153,7 +11908,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_gui_bar *my_bar = weechat_bar_new ("mybar", "off", "100", @@ -12169,12 +11924,12 @@ struct t_gui_bar *my_bar = weechat_bar_new ("mybar", "blue", "off", "time,buffer_number+buffer_name"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype bar = weechat.bar_new(name, hidden, priority, type, condition, position, filling_top_bottom, filling_left_right, size, size_max, @@ -12183,20 +11938,19 @@ bar = weechat.bar_new(name, hidden, priority, type, condition, position, # exemple bar = weechat.bar_new("mybar", "off", "100", "window", "", "top", "horizontal", "vertical", "0", "5", "default", "cyan", "blue", "off", "time,buffer_number+buffer_name") ----------------------------------------- +---- -weechat_bar_set -^^^^^^^^^^^^^^^ +==== weechat_bar_set Affecte une nouvelle valeur pour une propriété de la barre. Prototype : [source,C] ----------------------------------------- +---- int weechat_bar_set (struct t_gui_bar *bar, const char *property, const char *value); ----------------------------------------- +---- Paramètres : @@ -12213,32 +11967,31 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_bar_set (my_bar, "position", "bottom"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.bar_set(bar, property, value) # exemple weechat.bar_set(my_bar, "position", "bottom") ----------------------------------------- +---- -weechat_bar_update -^^^^^^^^^^^^^^^^^^ +==== weechat_bar_update Met à jour le contenu d'une barre à l'écran. Prototype : [source,C] ----------------------------------------- +---- void weechat_bar_update (const char *name); ----------------------------------------- +---- Paramètres : @@ -12247,32 +12000,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_bar_update ("mybar"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.bar_update(name) # exemple weechat.bar_update("mybar") ----------------------------------------- +---- -weechat_bar_remove -^^^^^^^^^^^^^^^^^^ +==== weechat_bar_remove Supprime une barre. Prototype : [source,C] ----------------------------------------- +---- void weechat_bar_remove (struct t_gui_bar *bar); ----------------------------------------- +---- Paramètres : @@ -12281,38 +12033,36 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_bar_remove (my_bar); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.bar_remove(bar) # exemple weechat.bar_remove(my_bar) ----------------------------------------- +---- [[commands]] -Commandes -~~~~~~~~~ +=== Commandes Fonctions pour exécuter des commandes WeeChat. -weechat_command -^^^^^^^^^^^^^^^ +==== weechat_command Exécute une commande. Prototype : [source,C] ----------------------------------------- +---- void weechat_command (struct t_gui_buffer *buffer, const char *command); ----------------------------------------- +---- Paramètres : @@ -12324,30 +12074,28 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_command (weechat_buffer_search ("irc", "freenode.#weechat"), "/whois FlashCode"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.command(buffer, command) # exemple weechat.command(weechat.buffer_search("irc", "freenode.#weechat"), "/whois FlashCode") ----------------------------------------- +---- [[network]] -Réseau -~~~~~~ +=== Réseau Fonctions pour le réseau. -weechat_network_pass_proxy -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_network_pass_proxy Établit une connexion/authentification avec un proxy. @@ -12358,12 +12106,12 @@ appelée sans un processus issu d'un "fork", pour ne pas bloquer WeeChat. Prototype : [source,C] ----------------------------------------- +---- int weechat_network_pass_proxy (const char *proxy, int sock, const char *address, int port); ----------------------------------------- +---- Paramètres : @@ -12379,7 +12127,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_network_pass_proxy ("mon_proxy", sock, "irc.freenode.net", 6667)) { /* OK */ @@ -12388,13 +12136,12 @@ else { /* erreur */ } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_network_connect_to -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_network_connect_to Établit une connexion à une machine distante. @@ -12405,12 +12152,12 @@ appelée sans un processus issu d'un "fork", pour ne pas bloquer WeeChat. Prototype : [source,C] ----------------------------------------- +---- int weechat_network_connect_to (const char *proxy, int sock, unsigned long address, int port); ----------------------------------------- +---- Paramètres : @@ -12426,7 +12173,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct sockaddr_in addr; socklen_t length; unsigned long address; @@ -12445,28 +12192,26 @@ else { /* erreur */ } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. [[infos]] -Infos -~~~~~ +=== Infos Fonctions pour obtenir des informations. -weechat_info_get -^^^^^^^^^^^^^^^^ +==== weechat_info_get Retourne une information, sous forme de chaîne, de WeeChat ou d'une extension. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_info_get (const char *info_name, const char *arguments); ----------------------------------------- +---- Paramètres : @@ -12482,18 +12227,18 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "La version de WeeChat est : %s (compilée le %s)", weechat_info_get ("version", NULL), weechat_info_get ("date", NULL)); weechat_printf (NULL, "Le répertoire de WeeChat est : %s", weechat_info_get ("weechat_dir", NULL)); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.info_get(info_name, arguments) @@ -12501,10 +12246,9 @@ value = weechat.info_get(info_name, arguments) weechat.prnt("", "La version de WeeChat est : %s (compilée le %s)" % (weechat.info_get("version", ""), weechat.info_get("date", "")) weechat.prnt("", "Le répertoire de WeeChat est : %s" % weechat.info_get("weechat_dir", "")) ----------------------------------------- +---- -weechat_info_get_hashtable -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_info_get_hashtable _WeeChat ≥ 0.3.4._ @@ -12513,10 +12257,10 @@ Retourne une information, sous forme de hashtable, de WeeChat ou d'une extension Prototype : [source,C] ----------------------------------------- +---- struct t_hashtable *weechat_info_get_hashtable (const char *info_name, struct t_hashtable *hashtable); ----------------------------------------- +---- Paramètres : @@ -12532,7 +12276,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hashtable *hashtable_in, *hashtable_out; hashtable_in = weechat_hashtable_new (8, @@ -12557,12 +12301,12 @@ if (hashtable_in) weechat_hashtable_free (hashtable_in); weechat_hashtable_free (hashtable_out); } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype dict = weechat.info_get_hashtable(info_name, dict_in) @@ -12570,11 +12314,10 @@ dict = weechat.info_get_hashtable(info_name, dict_in) dict_in = { "message": ":nick!user@host PRIVMSG #weechat :message ici" } weechat.prnt("", "message analysé: %s" % weechat.info_get_hashtable("irc_message_parse", dict_in)) ----------------------------------------- +---- [[infolists]] -Infolists -~~~~~~~~~ +=== Infolists Une "infolist" est une liste composée d'objets ("items"). Chaque objet contient des variables. @@ -12592,17 +12335,16 @@ Chaque variable a un type et une valeur. Les types possibles sont : de données * 'time' : date/heure -weechat_infolist_new -^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new Créé une "infolist". Prototype : [source,C] ----------------------------------------- +---- struct t_infolist *weechat_infolist_new (); ----------------------------------------- +---- Valeur de retour : @@ -12611,32 +12353,31 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_infolist *infolist = weechat_infolist_new (); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype infolist = weechat.infolist_new() # exemple infolist = weechat.infolist_new() ----------------------------------------- +---- -weechat_infolist_new_item -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new_item Ajoute un objet dans l'infolist. Prototype : [source,C] ----------------------------------------- +---- struct t_infolist_item *weechat_infolist_new_item (struct t_infolist *infolist); ----------------------------------------- +---- Paramètres : @@ -12649,34 +12390,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_infolist_item *item = weechat_infolist_new_item (infolist); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype item = weechat.infolist_new_item(infolist) # exemple item = weechat.infolist_new_item(infolist) ----------------------------------------- +---- -weechat_infolist_new_var_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new_var_integer Ajoute une variable de type "integer" dans l'objet de l'infolist. Prototype : [source,C] ----------------------------------------- +---- struct t_infolist_var *weechat_infolist_new_var_integer (struct t_infolist_item *item, const char *name, int value); ----------------------------------------- +---- Paramètres : @@ -12691,36 +12431,35 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_infolist_var *var = weechat_infolist_new_var_integer (item, "mon_entier", 123); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype var = weechat.infolist_new_var_integer(item, name, value) # exemple var = weechat.infolist_new_var_integer(item, "mon_entier", 123) ----------------------------------------- +---- -weechat_infolist_new_var_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new_var_string Ajoute une variable de type "string" dans l'objet de l'infolist. Prototype : [source,C] ----------------------------------------- +---- struct t_infolist_var *weechat_infolist_new_var_string (struct t_infolist_item *item, const char *name, const char *value); ----------------------------------------- +---- Paramètres : @@ -12735,36 +12474,35 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_infolist_var *var = weechat_infolist_new_var_string (item, "ma_chaine", "valeur"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype var = weechat.infolist_new_var_string(item, name, value) # exemple var = weechat.infolist_new_var_string(item, "ma_chaine", "valeur") ----------------------------------------- +---- -weechat_infolist_new_var_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new_var_pointer Ajoute une variable de type "pointer" dans l'objet de l'infolist. Prototype : [source,C] ----------------------------------------- +---- struct t_infolist_var *weechat_infolist_new_var_pointer (struct t_infolist_item *item, const char *name, void *pointer); ----------------------------------------- +---- Paramètres : @@ -12779,37 +12517,36 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_infolist_var *var = weechat_infolist_new_var_pointer (item, "mon_pointeur", &pointer); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype var = weechat.infolist_new_var_pointer(item, name, pointer) # exemple var = weechat.infolist_new_var_pointer(item, "mon_pointeur", pointer) ----------------------------------------- +---- -weechat_infolist_new_var_buffer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new_var_buffer Ajoute une variable de type "buffer" dans l'objet de l'infolist. Prototype : [source,C] ----------------------------------------- +---- struct t_infolist_var *weechat_infolist_new_var_buffer (struct t_infolist_item *item, const char *name, void *pointer, int size); ----------------------------------------- +---- Paramètres : @@ -12825,31 +12562,30 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- char buffer[256]; /* ... */ struct t_infolist_var *var = weechat_infolist_new_var_buffer (item, "mon_buffer", buffer, sizeof (buffer)); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_infolist_new_var_time -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new_var_time Ajoute une variable de type "time" dans l'objet de l'infolist. Prototype : [source,C] ----------------------------------------- +---- struct t_infolist_var *weechat_infolist_new_var_time (struct t_infolist_item *item, const char *name, time_t time); ----------------------------------------- +---- Paramètres : @@ -12864,25 +12600,24 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_infolist_var *var = weechat_infolist_new_var_time (item, "mon_time", time (NULL)); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype var = weechat.infolist_new_var_time(item, name, time) # exemple var = weechat.infolist_new_var_time(item, "mon_time", int(time.time())) ----------------------------------------- +---- -weechat_infolist_get -^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_get Retourne une "infolist" de WeeChat ou d'une extension. @@ -12898,11 +12633,11 @@ données brutes), voir <<hdata,hdata>>. Prototype : [source,C] ----------------------------------------- +---- struct t_infolist *weechat_infolist_get (const char *infolist_name, void *pointer, const char *arguments); ----------------------------------------- +---- Paramètres : @@ -12920,23 +12655,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_infolist *infolist = weechat_infolist_get ("irc_server", NULL, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype infolist = weechat.infolist_get(infolist_name, pointer, arguments) # exemple infolist = weechat.infolist_get("irc_server", "", "") ----------------------------------------- +---- -weechat_infolist_next -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_next Déplace le "curseur" vers l'objet suivant dans l'infolist. Le premier appel à cette fonction sur une infolist déplace le curseur sur le premier objet de @@ -12945,9 +12679,9 @@ l'infolist. Prototype : [source,C] ----------------------------------------- +---- int weechat_infolist_next (struct t_infolist *infolist); ----------------------------------------- +---- Paramètres : @@ -12961,7 +12695,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_infolist_next (infolist)) { /* lecture des variables dans l'objet... */ @@ -12970,12 +12704,12 @@ else { /* pas d'autre objet disponible */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.infolist_next(infolist) @@ -12985,10 +12719,9 @@ if rc: # lecture des variables dans l'objet... else: # pas d'autre objet disponible ----------------------------------------- +---- -weechat_infolist_prev -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_prev Déplace le "curseur" vers l'objet précédent dans l'infolist. Le premier appel à cette fonction sur une infolist déplace le curseur sur le dernier objet de @@ -12997,9 +12730,9 @@ l'infolist. Prototype : [source,C] ----------------------------------------- +---- int weechat_infolist_prev (struct t_infolist *infolist); ----------------------------------------- +---- Paramètres : @@ -13013,7 +12746,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_infolist_prev (infolist)) { /* lecture des variables dans l'objet... */ @@ -13022,12 +12755,12 @@ else { /* pas d'autre objet disponible */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.infolist_prev(infolist) @@ -13037,19 +12770,18 @@ if rc: # lecture des variables dans l'objet else: # pas d'autre objet disponible ----------------------------------------- +---- -weechat_infolist_reset_item_cursor -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_reset_item_cursor Réinitialise le "curseur" de l'infolist. Prototype : [source,C] ----------------------------------------- +---- void weechat_infolist_reset_item_cursor (struct t_infolist *infolist); ----------------------------------------- +---- Paramètres : @@ -13058,32 +12790,31 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_infolist_reset_item_cursor (infolist); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.infolist_reset_item_cursor(infolist) # exemple weechat.infolist_reset_item_cursor(infolist) ----------------------------------------- +---- -weechat_infolist_fields -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_fields Retourne la liste des champs pour l'objet courant de l'infolist. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_infolist_fields (struct t_infolist *infolist); ----------------------------------------- +---- Paramètres : @@ -13099,16 +12830,16 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- const char *fields = weechat_infolist_fields (infolist); /* fields contient quelque chose comme : "i:mon_entier,s:ma_chaine,p:mon_pointeur,b:mon_buffer,t:ma_date" */ ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype fields = weechat.infolist_fields(infolist) @@ -13116,10 +12847,9 @@ fields = weechat.infolist_fields(infolist) fields = weechat.infolist_fields(infolist) # fields contient quelque chose comme : # "i:mon_entier,s:ma_chaine,p:mon_pointeur,b:mon_buffer,t:ma_date" ----------------------------------------- +---- -weechat_infolist_integer -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_integer Retourne la valeur de la variable de l'objet courant de l'infolist, sous forme d'entier. @@ -13127,9 +12857,9 @@ d'entier. Prototype : [source,C] ----------------------------------------- +---- int weechat_infolist_integer (struct t_infolist *infolist, const char *var); ----------------------------------------- +---- Paramètres : @@ -13143,24 +12873,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "entier = %d", weechat_infolist_integer (infolist, "mon_entier")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.infolist_integer(infolist, var) # exemple weechat.prnt("", "entier = %d" % weechat.infolist_integer(infolist, "mon_entier")) ----------------------------------------- +---- -weechat_infolist_string -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_string Retourne la valeur de la variable de l'objet courant de l'infolist, sous forme de chaîne de caractères. @@ -13168,9 +12897,9 @@ de chaîne de caractères. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_infolist_string (struct t_infolist *infolist, const char *var); ----------------------------------------- +---- Paramètres : @@ -13184,24 +12913,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "chaîne = %s", weechat_infolist_string (infolist, "ma_chaine")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.infolist_string(infolist, var) # exemple weechat.prnt("", "chaîne = %s" % weechat.infolist_string(infolist, "ma_chaine")) ----------------------------------------- +---- -weechat_infolist_pointer -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_pointer Retourne la valeur de la variable de l'objet courant de l'infolist, sous forme de pointeur. @@ -13209,9 +12937,9 @@ de pointeur. Prototype : [source,C] ----------------------------------------- +---- void *weechat_infolist_pointer (struct t_infolist *infolist, const char *var); ----------------------------------------- +---- Paramètres : @@ -13225,24 +12953,23 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "pointeur = 0x%lx", weechat_infolist_pointer (infolist, "mon_pointeur")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.infolist_pointer(infolist, var) # exemple weechat.prnt("", "pointeur = 0x%s" % weechat.infolist_pointer(infolist, "mon_pointeur")) ----------------------------------------- +---- -weechat_infolist_buffer -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_buffer Retourne la valeur de la variable de l'objet courant de l'infolist, sous forme de buffer. @@ -13250,10 +12977,10 @@ de buffer. Prototype : [source,C] ----------------------------------------- +---- void *weechat_infolist_buffer (struct t_infolist *infolist, const char *var, int *size); ----------------------------------------- +---- Paramètres : @@ -13269,18 +12996,17 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int size; void *pointer = weechat_infolist_buffer (infolist, "mon_buffer", &size); weechat_printf (NULL, "buffer = 0x%lx, taille = %d", pointer, size); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_infolist_time -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_time Retourne la valeur de la variable de l'objet courant de l'infolist, sous forme de date/heure. @@ -13288,9 +13014,9 @@ de date/heure. Prototype : [source,C] ----------------------------------------- +---- time_t weechat_infolist_time (struct t_infolist *infolist, const char *var); ----------------------------------------- +---- Paramètres : @@ -13304,33 +13030,32 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "date/heure = %ld", weechat_infolist_time (infolist, "mon_time")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.infolist_time(infolist, var) # exemple weechat.prnt("", "date/heure = %ld" % weechat.infolist_time(infolist, "mon_time")) ----------------------------------------- +---- -weechat_infolist_free -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_free Libère une infolist. Prototype : [source,C] ----------------------------------------- +---- void weechat_infolist_free (struct t_infolist *infolist); ----------------------------------------- +---- Paramètres : @@ -13339,24 +13064,23 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_infolist_free (infolist); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.infolist_free(infolist) # exemple weechat.infolist_free(infolist) ----------------------------------------- +---- [[hdata]] -Hdata -~~~~~ +=== Hdata Fonctions pour les hdata (accès brut aux données de WeeChat ou des extensions). @@ -13365,8 +13089,7 @@ Le "hdata" fournit seulement un accès en lecture seule aux données. Il est *STRICTEMENT INTERDIT* d'écrire quelque chose dans une zone mémoire pointée par les variables du hdata. -weechat_hdata_new -^^^^^^^^^^^^^^^^^ +==== weechat_hdata_new _WeeChat ≥ 0.3.6, mis à jour dans la 0.3.9 et 0.4.0._ @@ -13374,7 +13097,7 @@ Créé un "hdata". [NOTE] .hdata vs infolist -======================================== +==== Le "hdata" est un moyen rapide de lire des données de WeeChat ou des extensions. Il est similaire à l'infolist, mais il y a quelques différences : @@ -13383,12 +13106,12 @@ Il est similaire à l'infolist, mais il y a quelques différences : * il peut contenir des informations différentes de l'infolist : il contient seulement les données brutes des structures (l'infolist peut ajouter des données supplémentaires pour plus de commodité) -======================================== +==== Prototype : [source,C] ----------------------------------------- +---- struct t_hdata *weechat_hdata_new (const char *hdata_name, const char *var_prev, const char *var_next, int create_allowed, int delete_allowed, int (*callback_update)(void *data, @@ -13396,7 +13119,7 @@ struct t_hdata *weechat_hdata_new (const char *hdata_name, const char *var_prev, void *pointer, struct t_hashtable *hashtable), void *callback_update_data); ----------------------------------------- +---- Paramètres : @@ -13429,15 +13152,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_new ("myplugin_list", "prev", "next", 0, 0, &callback_update, NULL); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hdata_new_var -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_new_var _WeeChat ≥ 0.3.6._ @@ -13446,10 +13168,10 @@ Créé une nouvelle variable dans le hdata. Prototype : [source,C] ----------------------------------------- +---- void weechat_hdata_new_var (struct t_hdata *hdata, const char *name, int offset, int type, int update_allowed, const char *array_size, const char *hdata_name); ----------------------------------------- +---- Paramètres : @@ -13481,7 +13203,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- struct t_myplugin_list { char *name; @@ -13503,12 +13225,12 @@ weechat_hdata_new_var (hdata, "tags_array", offsetof (struct t_myplugin_list, ta weechat_hdata_new_var (hdata, "string_split", offsetof (struct t_myplugin_list, string_split), WEECHAT_HDATA_STRING, 0, "*", NULL); weechat_hdata_new_var (hdata, "prev", offsetof (struct t_myplugin_list, prev), WEECHAT_HDATA_POINTER, 0, NULL, "myplugin_list"); weechat_hdata_new_var (hdata, "next", offsetof (struct t_myplugin_list, next), WEECHAT_HDATA_POINTER, 0, NULL, "myplugin_list"); ----------------------------------------- +---- La macro "WEECHAT_HDATA_VAR" peut être utilisée pour raccourcir le code : [source,C] ----------------------------------------- +---- WEECHAT_HDATA_VAR(struct t_myplugin_list, name, STRING, 0, NULL, NULL); WEECHAT_HDATA_VAR(struct t_myplugin_list, buffer, POINTER, 0, NULL, NULL); WEECHAT_HDATA_VAR(struct t_myplugin_list, tags_count, INTEGER, 0, NULL, NULL); @@ -13516,13 +13238,12 @@ WEECHAT_HDATA_VAR(struct t_myplugin_list, tags_array, STRING, 0, "tags_count", N WEECHAT_HDATA_VAR(struct t_myplugin_list, string_split, STRING, 0, "*", NULL); WEECHAT_HDATA_VAR(struct t_myplugin_list, prev, POINTER, 0, NULL, "myplugin_list"); WEECHAT_HDATA_VAR(struct t_myplugin_list, next, POINTER, 0, NULL, "myplugin_list"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hdata_new_list -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_new_list _WeeChat ≥ 0.3.6._ @@ -13531,9 +13252,9 @@ Créé un nouveau pointer vers une liste dans le hdata. Prototype : [source,C] ----------------------------------------- +---- void weechat_hdata_new_list (struct t_hdata *hdata, const char *name, void *pointer); ----------------------------------------- +---- Paramètres : @@ -13544,7 +13265,7 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- struct t_myplugin_list { char *name; @@ -13569,21 +13290,20 @@ weechat_hdata_new_var (hdata, "next", offsetof (struct t_myplugin_list, next), W weechat_hdata_new_list (hdata, "buffers", &buffers); weechat_hdata_new_list (hdata, "last_buffer", &last_buffer); ----------------------------------------- +---- La macro "WEECHAT_HDATA_LIST" peut être utilisée pour raccourcir le code : [source,C] ----------------------------------------- +---- WEECHAT_HDATA_LIST(buffers); WEECHAT_HDATA_LIST(last_buffer); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hdata_get -^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get _WeeChat ≥ 0.3.6._ @@ -13598,9 +13318,9 @@ extension pour lire des données. Prototype : [source,C] ----------------------------------------- +---- struct t_hdata *weechat_hdata_get (const char *hdata_name); ----------------------------------------- +---- Paramètres : @@ -13617,23 +13337,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("irc_server"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hdata = weechat.hdata_get(hdata_name) # exemple hdata = weechat.hdata_get("irc_server") ----------------------------------------- +---- -weechat_hdata_get_var_offset -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_offset _WeeChat ≥ 0.3.6._ @@ -13642,9 +13361,9 @@ Retourne la position (offset) de la variable dans le hdata. Prototype : [source,C] ----------------------------------------- +---- int weechat_hdata_get_var_offset (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Paramètres : @@ -13658,23 +13377,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int offset = weechat_hdata_get_var_offset (hdata, "name"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype offset = weechat.hdata_get_var_offset(hdata, name) # exemple offset = weechat.hdata_get_var_offset(hdata, "name") ----------------------------------------- +---- -weechat_hdata_get_var_type -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_type _WeeChat ≥ 0.3.6._ @@ -13683,9 +13401,9 @@ Retourne le type de la variable dans le hdata (sous forme d'entier). Prototype : [source,C] ----------------------------------------- +---- int weechat_hdata_get_var_type (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Paramètres : @@ -13699,7 +13417,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int type = weechat_hdata_get_var_type (hdata, "name"); switch (type) { @@ -13731,13 +13449,12 @@ switch (type) /* variable non trouvée */ break; } ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hdata_get_var_type_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_type_string _WeeChat ≥ 0.3.6._ @@ -13746,9 +13463,9 @@ Retourne le type de la variable dans le hdata (sous forme de chaîne). Prototype : [source,C] ----------------------------------------- +---- const char *weechat_hdata_get_var_type_string (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Paramètres : @@ -13762,23 +13479,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "type = %s", weechat_hdata_get_var_type_string (hdata, "name")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype type = weechat.hdata_get_var_type_string(hdata, name) # exemple weechat.prnt("", "type = %s" % weechat.hdata_get_var_type_string(hdata, "name")) ----------------------------------------- +---- -weechat_hdata_get_var_array_size -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_array_size _WeeChat ≥ 0.3.9._ @@ -13787,9 +13503,9 @@ Retourne la taille du tableau pour la variable dans le hdata. Prototype : [source,C] ----------------------------------------- +---- int weechat_hdata_get_var_array_size (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -13805,23 +13521,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int array_size = weechat_hdata_get_var_array_size (hdata, pointer, "name"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype array_size = weechat.hdata_get_var_array_size(hdata, pointer, name) # exemple array_size = weechat.hdata_get_var_array_size(hdata, pointer, "name") ----------------------------------------- +---- -weechat_hdata_get_var_array_size_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_array_size_string _WeeChat ≥ 0.3.9._ @@ -13831,10 +13546,10 @@ chaîne). Prototype : [source,C] ----------------------------------------- +---- const char *weechat_hdata_get_var_count_array_size (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -13850,23 +13565,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- const char *array_size = weechat_hdata_get_var_array_size_string (hdata, pointer, "name"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype array_size = weechat.hdata_get_var_array_size_string(hdata, pointer, name) # exemple array_size = weechat.hdata_get_var_array_size_string(hdata, pointer, "name") ----------------------------------------- +---- -weechat_hdata_get_var_hdata -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_hdata _WeeChat ≥ 0.3.6._ @@ -13875,9 +13589,9 @@ Retourne le hdata pour la variable dans le hdata. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_hdata_get_var_hdata (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Paramètres : @@ -13891,23 +13605,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "hdata = %s", weechat_hdata_get_var_hdata (hdata, "name")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hdata_name = weechat.hdata_get_var_hdata(hdata, name) # exemple weechat.prnt("", "hdata = %s" % weechat.hdata_get_var_hdata(hdata, "name")) ----------------------------------------- +---- -weechat_hdata_get_var -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var _WeeChat ≥ 0.3.6._ @@ -13916,9 +13629,9 @@ Retourne un pointeur vers le contenu de la variable dans le hdata. Prototype : [source,C] ----------------------------------------- +---- void *weechat_hdata_get_var (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -13933,17 +13646,16 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); void *pointer = weechat_hdata_get_var (hdata, buffer, "name"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hdata_get_var_at_offset -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_at_offset _WeeChat ≥ 0.3.6._ @@ -13953,9 +13665,9 @@ une position (offset). Prototype : [source,C] ----------------------------------------- +---- void *weechat_hdata_get_var_at_offset (struct t_hdata *hdata, void *pointer, int offset); ----------------------------------------- +---- Paramètres : @@ -13970,18 +13682,17 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); int offset = weechat_hdata_get_var_offset (hdata, "name"); void *pointer = weechat_hdata_get_var_at_offset (hdata, buffer, offset); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hdata_get_list -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_list _WeeChat ≥ 0.3.6._ @@ -13990,9 +13701,9 @@ Retourne un pointeur de liste du hdata. Prototype : [source,C] ----------------------------------------- +---- void *weechat_hdata_get_list (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Paramètres : @@ -14006,25 +13717,24 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffers = weechat_hdata_get_list (hdata, "gui_buffers"); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype list = weechat.hdata_get_list(hdata, name) # exemple hdata = weechat.hdata_get("buffer") buffers = weechat.hdata_get_list(hdata, "gui_buffers") ----------------------------------------- +---- -weechat_hdata_check_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_check_pointer _WeeChat ≥ 0.3.7._ @@ -14033,9 +13743,9 @@ Vérifie si un pointeur est valide pour un hdata et un pointeur de liste. Prototype : [source,C] ----------------------------------------- +---- int weechat_hdata_check_pointer (struct t_hdata *hdata, void *list, void *pointer); ----------------------------------------- +---- Paramètres : @@ -14050,7 +13760,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- /* vérifie si le pointeur vers le tampon est valide */ struct t_hdata *hdata = weechat_hdata_get ("buffer"); if (weechat_hdata_check_pointer (hdata, @@ -14063,12 +13773,12 @@ else { /* pointeur invalide */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.hdata_check_pointer(hdata, list, pointer) @@ -14080,10 +13790,9 @@ if weechat.hdata_check_pointer(hdata, weechat.hdata_get_list(hdata, "gui_buffers else: # pointeur invalide # ... ----------------------------------------- +---- -weechat_hdata_move -^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_move _WeeChat ≥ 0.3.6._ @@ -14092,9 +13801,9 @@ Déplace le pointeur vers un autre élément dans la liste. Prototype : [source,C] ----------------------------------------- +---- void *weechat_hdata_move (struct t_hdata *hdata, void *pointer, int count); ----------------------------------------- +---- Paramètres : @@ -14110,7 +13819,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); @@ -14120,12 +13829,12 @@ buffer = weechat_hdata_move (hdata, buffer, 2); /* se déplacer au tampon précédent */ if (buffer) buffer = weechat_hdata_move (hdata, buffer, -1); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype pointer = weechat.hdata_move(hdata, pointer, count) @@ -14139,10 +13848,9 @@ buffer = weechat.hdata_move(hdata, buffer, 2) # se déplacer au tampon précédent if buffer: buffer = weechat.hdata_move(hdata, buffer, -1) ----------------------------------------- +---- -weechat_hdata_search -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_search _WeeChat ≥ 0.4.1._ @@ -14152,9 +13860,9 @@ Cherche un élément dans la liste: l'expression 'search' est évaluée pour cha Prototype : [source,C] ----------------------------------------- +---- void *weechat_hdata_search (struct t_hdata *hdata, void *pointer, const char *search, int move); ----------------------------------------- +---- Paramètres : @@ -14174,7 +13882,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("irc_server"); void *servers = weechat_hdata_get (hdata, "irc_servers"); @@ -14184,12 +13892,12 @@ if (server) { /* ... */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype pointer = weechat.hdata_search(hdata, pointer, search, count) @@ -14201,10 +13909,9 @@ servers = weechat.hdata_get_list(hdata, "irc_servers") server = weechat.hdata_search(hdata, servers, "${irc_server.name} == freenode", 1) if server: # ... ----------------------------------------- +---- -weechat_hdata_char -^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_char _WeeChat ≥ 0.3.7._ @@ -14214,9 +13921,9 @@ forme de caractère. Prototype : [source,C] ----------------------------------------- +---- char weechat_hdata_char (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -14233,23 +13940,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "letter = %c", weechat_hdata_char (hdata, pointer, "letter")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.hdata_char(hdata, pointer, name) # exemple weechat.prnt("", "letter = %c" % weechat.hdata_char(hdata, pointer, "letter")) ----------------------------------------- +---- -weechat_hdata_integer -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_integer _WeeChat ≥ 0.3.6._ @@ -14259,9 +13965,9 @@ forme d'entier. Prototype : [source,C] ----------------------------------------- +---- int weechat_hdata_integer (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -14278,16 +13984,16 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); weechat_printf (NULL, "number = %d", weechat_hdata_integer (hdata, buffer, "number")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.hdata_integer(hdata, pointer, name) @@ -14295,10 +14001,9 @@ value = weechat.hdata_integer(hdata, pointer, name) hdata = weechat.hdata_get("buffer") buffer = weechat.buffer_search_main() weechat.prnt("", "number = %d" % weechat.hdata_integer(hdata, buffer, "number")) ----------------------------------------- +---- -weechat_hdata_long -^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_long _WeeChat ≥ 0.3.6._ @@ -14308,9 +14013,9 @@ forme d'entier long. Prototype : [source,C] ----------------------------------------- +---- long weechat_hdata_long (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -14327,23 +14032,22 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "longvar = %ld", weechat_hdata_long (hdata, pointer, "longvar")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.hdata_long(hdata, pointer, name) # exemple weechat.prnt("", "longvar = %ld" % weechat.hdata_long(hdata, pointer, "longvar")) ----------------------------------------- +---- -weechat_hdata_string -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_string _WeeChat ≥ 0.3.6._ @@ -14353,9 +14057,9 @@ forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_hdata_string (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -14372,16 +14076,16 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); weechat_printf (NULL, "name = %s", weechat_hdata_string (hdata, buffer, "name")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.hdata_string(hdata, pointer, name) @@ -14389,10 +14093,9 @@ value = weechat.hdata_string(hdata, pointer, name) hdata = weechat.hdata_get("buffer") buffer = weechat.buffer_search_main() weechat.prnt("", "name = %s" % weechat.hdata_string(hdata, buffer, "name")) ----------------------------------------- +---- -weechat_hdata_pointer -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_pointer _WeeChat ≥ 0.3.6._ @@ -14402,9 +14105,9 @@ forme de pointeur. Prototype : [source,C] ----------------------------------------- +---- void *weechat_hdata_pointer (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -14421,16 +14124,16 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); weechat_printf (NULL, "lines = %lx", weechat_hdata_pointer (hdata, buffer, "lines")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.hdata_pointer(hdata, pointer, name) @@ -14438,10 +14141,9 @@ value = weechat.hdata_pointer(hdata, pointer, name) hdata = weechat.hdata_get("buffer") buffer = weechat.buffer_search_main() weechat.prnt("", "lines = %lx" % weechat.hdata_pointer(hdata, buffer, "lines")) ----------------------------------------- +---- -weechat_hdata_time -^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_time _WeeChat ≥ 0.3.6._ @@ -14451,9 +14153,9 @@ forme de date/heure. Prototype : [source,C] ----------------------------------------- +---- time_t weechat_hdata_time (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -14470,7 +14172,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *ptr = weechat_buffer_search_main (); ptr = weechat_hdata_pointer (hdata, ptr, "lines"); @@ -14490,12 +14192,12 @@ if (ptr) } } } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.hdata_time(hdata, pointer, name) @@ -14509,10 +14211,9 @@ if ptr: if ptr: date = weechat.hdata_time(weechat.hdata_get("line_data"), ptr, "date") weechat.prnt("", "heure de la première ligne affichée = %s" % time.strftime("%F %T", time.localtime(int(date)))) ----------------------------------------- +---- -weechat_hdata_hashtable -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_hashtable _WeeChat ≥ 0.3.7._ @@ -14522,9 +14223,9 @@ forme de hashtable. Prototype : [source,C] ----------------------------------------- +---- struct t_hashtable *weechat_hdata_hashtable (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Paramètres : @@ -14541,18 +14242,18 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); struct t_hashtable *hashtable = weechat_hdata_hashtable (hdata, buffer, "local_variables"); weechat_printf (NULL, "%d variables locales dans le tampon principal", weechat_hashtable_get_integer (hashtable, "items_count")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype hashtable = weechat.hdata_hashtable(hdata, pointer, name) @@ -14563,10 +14264,9 @@ hash = weechat.hdata_hashtable(hdata, buffer, "local_variables") weechat.prnt("", "variables locales dans le tampon principal :") for key in hash: weechat.prnt("", " %s == %s" % (key, hash[key])) ----------------------------------------- +---- -weechat_hdata_set -^^^^^^^^^^^^^^^^^ +==== weechat_hdata_set _WeeChat ≥ 0.3.9._ @@ -14581,9 +14281,9 @@ jour. Prototype : [source,C] ----------------------------------------- +---- int weechat_hdata_set (struct t_hdata *hdata, void *pointer, const char *name, const char *value); ----------------------------------------- +---- Paramètres : @@ -14600,15 +14300,14 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_hdata_set (hdata, pointer, "message", "test"); ----------------------------------------- +---- [NOTE] Cette fonction n'est pas disponible dans l'API script. -weechat_hdata_update -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_update _WeeChat ≥ 0.3.9._ @@ -14617,9 +14316,9 @@ Met à jour des données dans le hdata. Prototype : [source,C] ----------------------------------------- +---- int weechat_hdata_update (struct t_hdata *hdata, void *pointer, struct t_hashtable *hashtable); ----------------------------------------- +---- Paramètres : @@ -14646,7 +14345,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- /* soustrait une heure sur le dernier message affiché dans le tampon courant */ struct t_gui_lines *own_lines; @@ -14678,12 +14377,12 @@ if (own_lines) } } } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype count = weechat.hdata_update(hdata, pointer, hashtable) @@ -14695,10 +14394,9 @@ if own_lines: line_data = weechat.hdata_pointer(weechat.hdata_get('line'), line, 'data') hdata = weechat.hdata_get('line_data') weechat.hdata_update(hdata, line_data, { 'date': str(weechat.hdata_time(hdata, line_data, 'date') - 3600) }) ----------------------------------------- +---- -weechat_hdata_get_string -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_string _WeeChat ≥ 0.3.6._ @@ -14707,9 +14405,9 @@ Retourne une valeur pour une propriété d'un hdata sous forme de chaîne. Prototype : [source,C] ----------------------------------------- +---- const char *weechat_hdata_get_string (struct t_hdata *hdata, const char *property); ----------------------------------------- +---- Paramètres : @@ -14739,40 +14437,38 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- weechat_printf (NULL, "variables dans le hdata: %s", weechat_hdata_get_string (hdata, "var_keys")); weechat_printf (NULL, "listes dans le hdata: %s", weechat_hdata_get_string (hdata, "list_keys")); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype value = weechat.hdata_get_string(hdata, property) # exemple weechat.prnt("", "variables dans le hdata: %s" % weechat.hdata_get_string(hdata, "var_keys")) weechat.prnt("", "listes dans le hdata: %s" % weechat.hdata_get_string(hdata, "list_keys")) ----------------------------------------- +---- [[upgrade]] -Mise à jour -~~~~~~~~~~~ +=== Mise à jour Fonctions pour la mise à jour de WeeChat (commande "/upgrade"). -weechat_upgrade_new -^^^^^^^^^^^^^^^^^^^ +==== weechat_upgrade_new Créé ou lit un fichier pour la mise à jour. Prototype : [source,C] ----------------------------------------- +---- struct t_upgrade_file *weechat_upgrade_new (const char *filename, int write); ----------------------------------------- +---- Paramètres : @@ -14789,34 +14485,33 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- struct t_upgrade_file *upgrade_file = weechat_upgrade_new ("mon_fichier", 1); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype upgrade_file = weechat.upgrade_new(filename, write) # exemple upgrade_file = weechat.upgrade_new("mon_fichier", 1) ----------------------------------------- +---- -weechat_upgrade_write_object -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_upgrade_write_object Écrit un objet dans le fichier de mise à jour. Prototype : [source,C] ----------------------------------------- +---- int weechat_upgrade_write_object (struct t_upgrade_file *upgrade_file, int object_id, struct t_infolist *infolist); ----------------------------------------- +---- Paramètres : @@ -14831,7 +14526,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- if (weechat_upgrade_write_object (upgrade_file, 1, &infolist)) { /* ok */ @@ -14840,35 +14535,34 @@ else { /* erreur */ } ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.upgrade_write_object(upgrade_file, object_id, infolist) # exemple weechat.upgrade_write_object(upgrade_file, 1, infolist) ----------------------------------------- +---- -weechat_upgrade_read -^^^^^^^^^^^^^^^^^^^^ +==== weechat_upgrade_read Lit un fichier de mise à jour. Prototype : [source,C] ----------------------------------------- +---- int weechat_upgrade_read (struct t_upgrade_file *upgrade_file, int (*callback_read)(void *data, struct t_upgrade_file *upgrade_file, int object_id, struct t_infolist *infolist), void *callback_read_data); ----------------------------------------- +---- Paramètres : @@ -14892,7 +14586,7 @@ Valeur de retour : Exemple en C : [source,C] ----------------------------------------- +---- int my_upgrade_read_cb (struct t_upgrade_file *upgrade_file, int object_id, @@ -14903,12 +14597,12 @@ my_upgrade_read_cb (struct t_upgrade_file *upgrade_file, } weechat_upgrade_read (upgrade_file, &my_upgrade_read_cb, NULL); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype rc = weechat.upgrade_read(upgrade_file, callback_read, callback_read_data) @@ -14918,19 +14612,18 @@ def my_upgrade_read_cb(upgrade_file, object_id, infolist): return weechat.WEECHAT_RC_OK weechat.upgrade_read(upgrade_file, "my_upgrade_read_cb", "")) ----------------------------------------- +---- -weechat_upgrade_close -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_upgrade_close Ferme un fichier de mise à jour. Prototype : [source,C] ----------------------------------------- +---- void weechat_upgrade_close (struct t_upgrade_file *upgrade_file); ----------------------------------------- +---- Paramètres : @@ -14939,17 +14632,17 @@ Paramètres : Exemple en C : [source,C] ----------------------------------------- +---- weechat_upgrade_close (upgrade_file); ----------------------------------------- +---- Script (Python) : [source,python] ----------------------------------------- +---- # prototype weechat.upgrade_close(upgrade_file) # exemple weechat.upgrade_close(upgrade_file) ----------------------------------------- +---- diff --git a/doc/fr/weechat_quickstart.fr.txt b/doc/fr/weechat_quickstart.fr.txt index 5fe6517e2..6e8c7cc51 100644 --- a/doc/fr/weechat_quickstart.fr.txt +++ b/doc/fr/weechat_quickstart.fr.txt @@ -1,11 +1,9 @@ -Guide de Démarrage Rapide WeeChat -================================= += Guide de Démarrage Rapide WeeChat Sébastien Helleu <flashcode@flashtux.org> [[start]] -Démarrer WeeChat ----------------- +== Démarrer WeeChat Un émulateur de terminal recommandé pour X (mais pas obligatoire) est rxvt-unicode (il a un bon support UTF-8, et aucun problème avec les @@ -13,32 +11,31 @@ touches par défaut). Lancer depuis votre shell : ----------------------------------------- +---- $ weechat ----------------------------------------- +---- [[help_options]] -Aide en ligne / options ------------------------ +== Aide en ligne / options WeeChat dispose d'aide pour toutes les commandes, tapez simplement : ----------------------------------------- +---- /help ----------------------------------------- +---- Pour avoir de l'aide sur une commande, tapez : ----------------------------------------- +---- /help commande ----------------------------------------- +---- Pour modifier des options, tapez : ----------------------------------------- +---- /set config.section.option valeur ----------------------------------------- +---- (où `config` est le nom de la configuration (`weechat` pour le cœur, ou un nom d'extension), `section` la section de cette configuration et @@ -55,27 +52,27 @@ Par exemple : * afficher toutes les options (WeeChat et extensions) : ----------------------------------------- +---- /set ----------------------------------------- +---- * afficher les options WeeChat : ----------------------------------------- +---- /set weechat.* ----------------------------------------- +---- * afficher les options de l'extension IRC : ----------------------------------------- +---- /set irc.* ----------------------------------------- +---- Vous pouvez afficher de l'aide sur une option avec `/help`, par exemple : ----------------------------------------- +---- /help weechat.look.highlight ----------------------------------------- +---- Toutes les options sont sauvées quand WeeChat quitte (ou avec la commande `/save` pour forcer une écriture des options). @@ -86,8 +83,7 @@ commande `/set`. [[core_vs_plugins]] -Cœur vs extensions ------------------- +== Cœur vs extensions Le cœur de WeeChat ("core") ne fait qu'afficher les données à l'écran et interagir avec l'utilisateur, cela signifie que le cœur sans extension @@ -101,25 +97,23 @@ devriez voir "irc" et d'autres extensions dans cette liste. [[create_irc_server]] -Créer un serveur IRC --------------------- +== Créer un serveur IRC Vous pouvez ajouter un serveur IRC par la commande `/server`, par exemple : ----------------------------------------- +---- /server add oftc irc.oftc.net/6667 ----------------------------------------- +---- Comme d'habitude, de l'aide est disponible si vous êtes perdus : ----------------------------------------- +---- /help server ----------------------------------------- +---- [[irc_server_options]] -Définir les options du serveur IRC ----------------------------------- +== Définir les options du serveur IRC WeeChat utilise des valeurs par défaut pour tous les serveurs, si vous ne spécifiez pas de valeur spécifique pour une option de serveur. @@ -132,72 +126,71 @@ définie (non "null"). Sinon WeeChat utilise la valeur par défaut Par exemple il y a des pseudos par défaut (basés sur votre login un*x), et vous pouvez les écraser pour le serveur oftc avec la commande suivante : ----------------------------------------- +---- /set irc.server.oftc.nicks "pseudo,pseudo2,pseudo3,pseudo4,pseudo5" ----------------------------------------- +---- Pour modifier le nom d'utilisateur et nom réel : ----------------------------------------- +---- /set irc.server.oftc.username "Mon nom d'utilisateur" /set irc.server.oftc.realname "Mon nom réel" ----------------------------------------- +---- Pour activer la connexion automatique au serveur lors du démarrage : ----------------------------------------- +---- /set irc.server.oftc.autoconnect on ----------------------------------------- +---- Si SASL est disponible sur le serveur, vous pouvez l'utiliser pour l'authentification (vous serez identifié avant de rejoindre les canaux) : ----------------------------------------- +---- /set irc.server_default.sasl_mechanism dh-blowfish /set irc.server.oftc.sasl_username "pseudo" /set irc.server.oftc.sasl_password "xxxxxxx" ----------------------------------------- +---- Pour lancer une commande après connexion au serveur, par exemple pour s'authentifier auprès de nickserv (seulement si vous n'utilisez pas SASL pour l'authentification) : ----------------------------------------- +---- /set irc.server.oftc.command "/msg nickserv identify xxxxxxx" ----------------------------------------- +---- [NOTE] Plusieurs commandes peuvent être séparées par ';' (point-virgule). Pour rejoindre automatiquement des canaux lors de la connexion au serveur : ----------------------------------------- +---- /set irc.server.oftc.autojoin "#canal1,#canal2" ----------------------------------------- +---- Pour supprimer la valeur d'une option du serveur et utiliser sa valeur par défaut à la place, par exemple pour utiliser les pseudos par défaut (irc.server_default.nicks) : ----------------------------------------- +---- /set irc.server.oftc.nicks null ----------------------------------------- +---- Autres options : vous pouvez modifier les autres options avec la commande suivante ("xxx" est le nom d'une option) : ----------------------------------------- +---- /set irc.server.oftc.xxx valeur ----------------------------------------- +---- [[connect_to_irc_server]] -Se connecter au serveur IRC et rejoindre les canaux ---------------------------------------------------- +== Se connecter au serveur IRC et rejoindre les canaux ----------------------------------------- +---- /connect oftc ----------------------------------------- +---- [NOTE] Cette commande peut aussi être utilisée pour créer et se connecter au serveur @@ -211,38 +204,36 @@ faut utiliser la touche ctrl-X. Il est possible de désactiver le mélange des tampons serveurs pour avoir un tampon distinct par serveur : ----------------------------------------- +---- /set irc.look.server_buffer independent ----------------------------------------- +---- [[join_part_irc_channels]] -Rejoindre/quitter les canaux IRC ------------------------------- +== Rejoindre/quitter les canaux IRC Rejoindre un canal : ----------------------------------------- +---- /join #channel ----------------------------------------- +---- Quitter un canal (en laissant le tampon ouvert) : ----------------------------------------- +---- /part [message de fin] ----------------------------------------- +---- quitter un canal et fermer le tampon (`/close` est un alias sur `/buffer close`) : ----------------------------------------- +---- /close ----------------------------------------- +---- [[buffer_window]] -Gérer les tampons/fenêtres --------------------------- +== Gérer les tampons/fenêtres Un tampon ("buffer") est un composant lié à une extension, avec une catégorie et un nom. Le tampon contient les données affichées à l'écran. @@ -253,10 +244,10 @@ alors plusieurs fenêtres avec plusieurs tampons en même temps. Commandes pour gérer les tampons et les fenêtres : ----------------------------------------- +---- /buffer /window ----------------------------------------- +---- (je ne répéterai pas que vous pouvez avoir de l'aide sur ces commandes avec /help) @@ -264,14 +255,13 @@ avec /help) Par exemple, pour découper verticalement l'écran en une petite fenêtre (1/3 de la largeur) et une large (2/3), utilisez la commande : ----------------------------------------- +---- /window splitv 33 ----------------------------------------- +---- [[key_bindings]] -Raccourcis clavier ------------------- +== Raccourcis clavier WeeChat utilise un certain nombre de touches par défaut. Toutes ces touches sont dans la documentation, mais vous devriez connaître au moins @@ -291,26 +281,25 @@ Une touche utile est meta-k (alt-k) pour trouver le code des touches. Par exemple, pour associer meta-y (alt-y) à la commande `/buffer close` : ----------------------------------------- +---- /key bind (pressez meta-k) (pressez meta-y) /buffer close ----------------------------------------- +---- Vous aurez une ligne de commande qui ressemble à ceci : ----------------------------------------- +---- /key bind meta-y /buffer close ----------------------------------------- +---- Pour enlever la touche : ----------------------------------------- +---- /key unbind meta-y ----------------------------------------- +---- [[plugins_scripts]] -Extensions/scripts ------------------- +== Extensions/scripts Sur certaines distributions comme Debian, les extensions sont disponibles via un paquet séparé (par exemple weechat-plugins). @@ -326,8 +315,7 @@ Vous pouvez gérer les scripts dans WeeChat avec la commande `/script` (voir [[more_doc]] -Plus de documentation ---------------------- +== Plus de documentation Vous pouvez maintenant utiliser WeeChat et lire la FAQ/documentation pour toute autre question : http://weechat.org/doc diff --git a/doc/fr/weechat_scripting.fr.txt b/doc/fr/weechat_scripting.fr.txt index 03966bd11..d33e7130a 100644 --- a/doc/fr/weechat_scripting.fr.txt +++ b/doc/fr/weechat_scripting.fr.txt @@ -1,5 +1,4 @@ -WeeChat Guide pour Scripts -========================== += WeeChat Guide pour Scripts Sébastien Helleu <flashcode@flashtux.org> @@ -11,8 +10,7 @@ http://weechat.org/doc [[introduction]] -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. @@ -32,28 +30,23 @@ 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 --------------------- +== Scripts dans WeeChat [[languages_specifities]] -Spécificités des langages -~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Spécificités des langages -Python -^^^^^^ +==== 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 -^^^^ +==== Perl * Les fonctions sont appelées par `weechat::xxx(arg1, arg2, ...);` -Ruby -^^^^ +==== Ruby * Vous devez définir 'weechat_init' et appeler 'register' dedans * Les fonctions sont appelées par `Weechat.xxx(arg1, arg2, ...)` @@ -63,23 +56,20 @@ Ruby cette fonction ressemble à ceci : [source,ruby] ----------------------------------------- +---- Weechat.config_new_option(config, section, "name", "string", "description of option", "", 0, 0, "value", "value", 0, ["check_cb", "", "change_cb", "", "delete_cb", ""]) ----------------------------------------- +---- -Lua -^^^ +==== Lua * Les fonctions sont appelées par `weechat.xxx(arg1, arg2, ...)` -Tcl -^^^ +==== Tcl * Les fonctions sont appelées par `weechat::xxx arg1 arg2 ...` -Guile (scheme) -^^^^^^^^^^^^^^ +==== 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 @@ -90,8 +80,7 @@ Guile (scheme) ** bar_new [[register_function]] -Fonction register -~~~~~~~~~~~~~~~~~ +=== 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. @@ -99,9 +88,9 @@ 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 : @@ -121,100 +110,98 @@ 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 -~~~~~~~~~~~~~~~~~~~~ +=== Chargement du script Il est recommandé d'utiliser l'extension "script" pour charger les scripts, par exemple : ----------------------------------------- +---- /script load script.py /script load script.pl /script load script.rb /script load script.lua /script load script.tcl /script load script.scm ----------------------------------------- +---- Chaque langage a également sa propre commande : ----------------------------------------- +---- /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 ----------------------------------------- +---- [NOTE] Lors de l'installation d'un script avec la commande `/script install` le lien dans le répertoire 'autoload' est automatiquement créé. [[differences_with_c_api]] -Différences avec l'API C ------------------------- +== 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 @@ -228,28 +215,27 @@ extension comme 'python' par la commande `/python`. Quand votre script 'test.py' appelle une fonction de l'API WeeChat, le chemin est le suivant : -........................................ +.... ┌──────────────────────┐ ╔══════════════════╗ │ extension python │ ║ WeeChat "core" ║ ├────────────┬─────────┤ ╟─────────┐ ║ test.py ─────► │ API script │ API C │ ─────► ║ API C │ ║ └────────────┴─────────┘ ╚═════════╧════════╝ -........................................ +.... Quand WeeChat appelle un "callback" dans votre script 'test.py', le chemin est inversé : -........................................ +.... ╔══════════════════╗ ┌──────────────────────┐ ║ WeeChat "core" ║ │ extension python │ ║ ┌─────────╢ ├─────────┬────────────┤ ║ │ API C ║ ─────► │ API C │ API script │ ─────► test.py ╚════════╧═════════╝ └─────────┴────────────┘ -........................................ +.... [[pointers]] -Pointeurs -~~~~~~~~~ +=== 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 @@ -267,9 +253,9 @@ 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 @@ -278,8 +264,7 @@ vérifier que vous donnez un pointeur valide, sinon vous pourriez voir un joli rapport de crash ;) [[callbacks]] -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 @@ -294,18 +279,18 @@ Exemple de callback, pour chaque langage : * python: [source,python] ----------------------------------------- +---- def timer_cb(data, remaining_calls): weechat.prnt("", "timer! data=%s" % data) return weechat.WEECHAT_RC_OK weechat.hook_timer(1000, 0, 1, "timer_cb", "test") ----------------------------------------- +---- * perl: [source,perl] ----------------------------------------- +---- sub timer_cb { my ($data, $remaining_calls) = @_; weechat::print("", "timer! data=$data"); @@ -313,71 +298,69 @@ sub timer_cb { } weechat::hook_timer(1000, 0, 1, "timer_cb", "test"); ----------------------------------------- +---- * ruby: [source,ruby] ----------------------------------------- +---- def timer_cb(data, remaining_calls) Weechat.print("", "timer! data=#{data}"); return Weechat::WEECHAT_RC_OK end Weechat.hook_timer(1000, 0, 1, "timer_cb", "test"); ----------------------------------------- +---- * lua: [source,lua] ----------------------------------------- +---- function timer_cb(data, remaining_calls) weechat.print("", "timer! data="..data) return weechat.WEECHAT_RC_OK end weechat.hook_timer(1000, 0, 1, "timer_cb", "test") ----------------------------------------- +---- * tcl: [source,tcl] ----------------------------------------- +---- proc timer_cb { data remaining_calls } { weechat::print {} "timer! data=$data" return $::weechat::WEECHAT_RC_OK } weechat::hook_timer 1000 0 1 timer_cb test ----------------------------------------- +---- * guile (scheme): [source,lisp] ----------------------------------------- +---- (define (timer_cb data remaining_calls) (weechat:print "" (string-append "timer! data=" data)) weechat:WEECHAT_RC_OK ) (weechat:hook_timer 1000 0 1 "timer_cb" "test") ----------------------------------------- +---- [[script_api]] -API script ----------- +== 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 -~~~~~~~~~ +=== Fonctions Liste des fonctions de l'API script : [width="100%",cols="^1,10",options="header"] -|======================================== +|=== | Catégorie | Fonctions | général | register @@ -454,16 +437,15 @@ Liste des fonctions de l'API script : hdata_pointer, hdata_time, hdata_hashtable, hdata_update, hdata_get_string | mise à jour | upgrade_new, upgrade_write_object, upgrade_read, upgrade_close -|======================================== +|=== [[script_api_constants]] -Constantes -~~~~~~~~~~ +=== 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 @@ -491,23 +473,20 @@ Liste des constantes de l'API script : WEECHAT_HOOK_CONNECT_SOCKET_ERROR | hook signal | WEECHAT_HOOK_SIGNAL_STRING, WEECHAT_HOOK_SIGNAL_INT, WEECHAT_HOOK_SIGNAL_POINTER -|======================================== +|=== [[common_tasks]] -Tâches courantes ----------------- +== 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 -~~~~~~~ +=== Tampons [[buffers_display_messages]] -Afficher des 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, @@ -516,7 +495,7 @@ voir <<pointers,pointeurs>>). Exemples : [source,python] ----------------------------------------- +---- # afficher "bonjour" sur le tampon core weechat.prnt("", "bonjour") @@ -543,15 +522,14 @@ weechat.prnt(buffer, "message sur le canal #weechat") # (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 -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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]. @@ -559,18 +537,17 @@ 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 courant (le résultat est 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 -^^^^^^^^^^^^^^^^^^^^^^^ +==== Créer un nouveau tampon Vous pouvez créer un nouveau tampon dans votre script, et l'utiliser pour afficher des messages. @@ -582,7 +559,7 @@ 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): # ... @@ -601,11 +578,10 @@ 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 -^^^^^^^^^^^^^^^^^^^^ +==== Propriétés du tampon Vous pouvez lire des propriétés du tampon, sous forme de chaîne, entier ou pointeur. @@ -613,19 +589,19 @@ 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") @@ -634,22 +610,20 @@ 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 -~~~~~ +=== Hooks [[hook_command]] -Ajouter une nouvelle commande -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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. @@ -657,7 +631,7 @@ 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 @@ -672,37 +646,35 @@ hook = weechat.hook_command("monfiltre", "description de mon filtre", " || 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 -^^^^^^^^^^^^^^^^ +==== 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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é @@ -714,7 +686,7 @@ positive, c'est le code retour de la commande. Exemple : [source,python] ----------------------------------------- +---- process_output = "" def my_process_cb(data, command, rc, out, err): @@ -726,11 +698,10 @@ def my_process_cb(data, command, rc, out, err): return weechat.WEECHAT_RC_OK weechat.hook_process("/bin/ls -l /etc", 10 * 1000, "my_process_cb", "") ----------------------------------------- +---- [[url_transfer]] -Transfert d'URL -^^^^^^^^^^^^^^^ +==== Transfert d'URL _Nouveau dans la version 0.3.7._ @@ -742,7 +713,7 @@ 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 stable courante de WeeChat. weechat_version = "" @@ -756,7 +727,7 @@ def weechat_process_cb(data, command, rc, out, err): weechat.hook_process("url:http://weechat.org/dev/info/stable/", 30 * 1000, "weechat_process_cb", "") ----------------------------------------- +---- [TIP] Toutes les infos disponibles à propos de WeeChat sont sur la page @@ -766,7 +737,7 @@ 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) @@ -775,19 +746,17 @@ def my_process_cb(data, command, rc, out, err): 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 [[config_options_set_script]] -Définir des options pour le 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. @@ -795,7 +764,7 @@ définie ou pas, et `config_set_plugin` pour définir une option. Exemple : [source,python] ----------------------------------------- +---- script_options = { "option1" : "valeur1", "option2" : "valeur2", @@ -804,11 +773,10 @@ script_options = { for option, default_value in script_options.items(): if not weechat.config_is_set_plugin(option): weechat.config_set_plugin(option, default_value) ----------------------------------------- +---- [[config_options_detect_changes]] -Détecter des changements -^^^^^^^^^^^^^^^^^^^^^^^^ +==== Détecter des changements Vous devez utiliser `hook_config` pour être notifié si l'utilisateur modifie certaines options du script. @@ -816,7 +784,7 @@ certaines options du script. Exemple : [source,python] ----------------------------------------- +---- SCRIPT_NAME = "monscript" # ... @@ -831,18 +799,17 @@ def config_cb(data, option, value): weechat.hook_config("plugins.var.python." + SCRIPT_NAME + ".*", "config_cb", "") # pour les autres langages, remplacez "python" par le langage ("perl", "ruby", "lua" ou "tcl") ----------------------------------------- +---- [[config_options_weechat]] -Lire les 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")))) @@ -858,15 +825,13 @@ weechat.prnt("", "la valeur de l'option weechat.look.scroll_page_percent est : % # 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 [[irc_catch_messages]] -Intercepter des 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, @@ -879,7 +844,7 @@ 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" @@ -894,32 +859,30 @@ def join_cb(data, signal, signal_data): # 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 -^^^^^^^^^^^^^^^^^^^^^ +==== 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 -^^^^^^^^^^^^^^^^^^^ +==== Analyser un message _Nouveau dans la version 0.3.4._ @@ -927,22 +890,20 @@ 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 [[infos_weechat_version]] -Version de WeeChat -^^^^^^^^^^^^^^^^^^ +==== 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 @@ -951,13 +912,13 @@ 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 @@ -967,38 +928,35 @@ 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 -^^^^^^^^^^^^ +==== 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 [[infolists_read]] -Lire une infolist -^^^^^^^^^^^^^^^^^ +==== 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: @@ -1006,7 +964,7 @@ if 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 diff --git a/doc/fr/weechat_tester.fr.txt b/doc/fr/weechat_tester.fr.txt index fcfe0d15d..280686318 100644 --- a/doc/fr/weechat_tester.fr.txt +++ b/doc/fr/weechat_tester.fr.txt @@ -1,11 +1,9 @@ -Guide du testeur WeeChat -======================== += Guide du testeur WeeChat Sébastien Helleu <flashcode@flashtux.org> [[purpose]] -Objet ------ +== Objet Beaucoup d'utilisateurs nous demandent comment aider WeeChat. La façon la plus facile (et aussi la plus rusée) consiste à le tester ! @@ -29,8 +27,7 @@ fonctionnalités (et à corriger des anciens bugs). [[prepare_system]] -Préparez votre système ----------------------- +== Préparez votre système Cela nous aiderait beaucoup si vous activiez les fichiers 'core' Linux : si WeeChat se plante, Linux écrit un fichier 'core'. Ce fichier contient des @@ -39,14 +36,13 @@ se situe dans WeeChat). Si vous utilisez le shell 'bash', ajoutez cette ligne dans votre `~/.bashrc` : ----------------------------------------- +---- ulimit -c unlimited ----------------------------------------- +---- [[download]] -Téléchargement de la version devel ----------------------------------- +== Téléchargement de la version devel Le code tout frais (avec les derniers bugs et fonctionnalités) est stocké dans GIT. @@ -59,56 +55,54 @@ Vous pouvez décider de le construire manuellement (méthode recommandée) : WeeChat. [[get_sources]] -Obtenir et compiler les sources -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Obtenir et compiler les sources Créez tout d'abord un répertoire, par exemple 'weechat-git' : ----------------------------------------- +---- $ mkdir ~/weechat-git $ cd ~/weechat-git ----------------------------------------- +---- Si vous avez git installé, vous pouvez cloner la base GIT (recommandé) : ----------------------------------------- +---- $ git clone git://git.sv.gnu.org/weechat.git $ cd weechat ----------------------------------------- +---- NOTE: Plus tard, vous pourrez utiliser la commande "`git pull`" dans ce répertoire pour obtenir juste les deltas avec la version d'aujourd'hui. Sinon vous pouvez installer le paquet 'devel' : ----------------------------------------- +---- $ wget http://www.weechat.org/files/src/weechat-devel.tar.bz2 $ tar xvjf weechat-devel.tar.bz2 $ cd weechat-devel ----------------------------------------- +---- Pour compiler les sources, cmake est recommandé : ----------------------------------------- +---- $ mkdir build $ cd build $ cmake .. -DPREFIX=$HOME/weechat-git -DWEECHAT_HOME=~/.weechat-dev -DCMAKE_BUILD_TYPE=Debug $ make $ make install ----------------------------------------- +---- Si vous n'avez pas cmake, il est toujours possible d'utiliser les autotools : ----------------------------------------- +---- $ ./autogen.sh $ ./configure --prefix=$HOME/weechat-git WEECHAT_HOME=~/.weechat-dev $ make $ make install ----------------------------------------- +---- [[install_binary_package]] -Obtenir un paquet binaire -~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Obtenir un paquet binaire Selon votre distribution Linux : @@ -119,17 +113,16 @@ Selon votre distribution Linux : [[run]] -Lancer WeeChat --------------- +== Lancer WeeChat Il est conseillé de lancer WeeChat avec un répertoire différent de la version stable, avec l'option `--dir`. La commande est : ----------------------------------------- +---- $ ~/weechat-git/bin/weechat ----------------------------------------- +---- Si vous êtes encore éveillé, vous devriez voir une interface familière et pouvoir vous vanter d'utiliser la version la plus récente possible de WeeChat ;) @@ -142,8 +135,7 @@ retour et de vos impressions ! [[links]] -Liens intéressants ------------------- +== Liens intéressants * Base GIT : http://git.savannah.gnu.org/gitweb/?p=weechat.git * Bug tracker : https://savannah.nongnu.org/bugs/?group=weechat diff --git a/doc/fr/weechat_user.fr.txt b/doc/fr/weechat_user.fr.txt index 5bf982e39..efc328be2 100644 --- a/doc/fr/weechat_user.fr.txt +++ b/doc/fr/weechat_user.fr.txt @@ -1,5 +1,4 @@ -Guide Utilisateur WeeChat -========================= += Guide Utilisateur WeeChat Sébastien Helleu <flashcode@flashtux.org> @@ -11,15 +10,13 @@ http://weechat.org/doc [[introduction]] -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. [[features]] -Fonctionnalités -~~~~~~~~~~~~~~~ +=== Fonctionnalités Ses principales fonctionnalités sont les suivantes : @@ -38,8 +35,7 @@ Ses principales fonctionnalités sont les suivantes : La page d'accueil de WeeChat est ici : http://weechat.org/ [[pre-requisites]] -Prérequis -~~~~~~~~~ +=== Prérequis Pour installer WeeChat, vous devez avoir : @@ -49,12 +45,10 @@ Pour installer WeeChat, vous devez avoir : * la bibliothèque ncurses [[install]] -Installation ------------- +== Installation [[binary_packages]] -Paquets binaires -~~~~~~~~~~~~~~~~ +=== Paquets binaires Les paquets binaires sont disponibles pour beaucoup de distributions, dont : @@ -73,21 +67,19 @@ Pour les autres distributions supportées, merci de vous référer au manuel de la distribution pour la méthode d'installation. [[source_package]] -Paquet source -~~~~~~~~~~~~~ +=== Paquet source WeeChat peut être compilé avec cmake ou les autotools (cmake est la méthode recommandée). [[dependencies]] -Dépendances -^^^^^^^^^^^ +==== Dépendances Le tableau suivant liste les paquets qui sont requis ou optionnels pour compiler WeeChat. [width="100%",cols="5,^3,^3,13",options="header"] -|======================================== +|=== | Paquet ^(1)^ | Version | Requis | Fonctionnalité | cmake | | *oui* | Construction (autotools toujours possible, mais cmake est recommandé) | libncursesw5-dev ^(2)^ | | *oui* | Interface ncurses @@ -108,7 +100,7 @@ compiler WeeChat. | source-highlight | | | Coloration des sources dans la documentation | xsltproc, docbook-xml, docbook-xsl | | | Construction de la page de manuel -|======================================== +|=== [NOTE] ^(1)^ Le nom provient de la distribution GNU/Linux Debian, la version dans le @@ -119,35 +111,34 @@ nom du paquet peut être différente. + avec la version 2.7, mais pas avec les versions ≤ 2.6 ou ≥ 3.0). [[compile_with_cmake]] -Compilation avec cmake -^^^^^^^^^^^^^^^^^^^^^^ +==== Compilation avec cmake * Installation dans les répertoires systèmes (nécessite les droits 'root') : ----------------------------------------- +---- $ mkdir build $ cd build $ cmake .. $ make % make install (en root) ----------------------------------------- +---- * Installation dans un répertoire spécifique : ----------------------------------------- +---- $ mkdir build $ cd build $ cmake .. -DPREFIX=/chemin/vers/répertoire $ make $ make install ----------------------------------------- +---- Des options peuvent être utilisées pour cmake, avec le format: "-DOPTION=VALUE". Liste des options couramment utilisées : [width="100%",cols="2m,2,5m,12",options="header"] -|======================================== +|=== | Option | Valeurs | Valeur par défaut | Description | CMAKE_BUILD_TYPE | `Debug`, `Release`, `RelWithDebInfo`, `MinSizeRel` | | @@ -243,23 +234,22 @@ Liste des options couramment utilisées : | ENABLE_XFER | `ON`, `OFF` | ON | Compiler <<xfer_plugin,l'extension Xfer>>. -|======================================== +|=== Les autres options peuvent être affichées avec cette commande : ----------------------------------------- +---- $ cmake -LA ----------------------------------------- +---- Ou avec l'interface Curses : ----------------------------------------- +---- $ ccmake .. ----------------------------------------- +---- [[compile_with_autotools]] -Compilation avec autotools -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Compilation avec autotools [WARNING] Seulement cmake est officiellement supporté pour construire WeeChat. Vous ne @@ -270,52 +260,50 @@ qu'avec cmake. * Installation dans les répertoires systèmes (nécessite les droits 'root') : ----------------------------------------- +---- $ ./autogen.sh $ mkdir build $ cd build $ ../configure $ make % make install (en root) ----------------------------------------- +---- * Installation dans un répertoire spécifique : ----------------------------------------- +---- $ ./autogen.sh $ mkdir build $ cd build $ ../configure --prefix=/chemin/vers/répertoire $ make $ make install ----------------------------------------- +---- Des options peuvent être utilisées pour le script 'configure', elles peuvent être affichées avec cette commande : ----------------------------------------- +---- $ ./configure --help ----------------------------------------- +---- [[git_sources]] -Sources Git -~~~~~~~~~~~ +=== Sources Git Attention : les sources git sont réservés aux utilisateurs avancés : il se peut que WeeChat ne compile pas et qu'il soit très instable. Vous êtes prévenus ! Pour récupérer les sources git, tapez cette commande : ----------------------------------------- +---- $ git clone git://git.sv.gnu.org/weechat.git ----------------------------------------- +---- Suivez alors les instructions du paquet source (voir <<source_package,paquet source>>). [[report_crashes]] -Rapporter les plantages -~~~~~~~~~~~~~~~~~~~~~~~ +=== Rapporter les plantages Si vous avez eu des plantages, ou si vous souhaitez rapporter tout plantage futur de WeeChat, vous devez : @@ -326,14 +314,13 @@ futur de WeeChat, vous devez : * installer gdb [[debug_info]] -Infos de debug -^^^^^^^^^^^^^^ +==== Infos de debug Si vous compilez avec cmake : ----------------------------------------- +---- $ cmake .. -DCMAKE_BUILD_TYPE=Debug ----------------------------------------- +---- Si vous compilez avec les autotools, le debug est par défaut (`--with-debug=1`). @@ -341,15 +328,14 @@ Si vous avez installé un paquet binaire, alors installez le paquet 'weechat-dbg'. [[core_files]] -Fichiers core -^^^^^^^^^^^^^ +==== Fichiers core Pour activer les fichiers 'core', vous pouvez utiliser l'option <<option_weechat.startup.sys_rlimit,weechat.startup.sys_rlimit>>: ----------------------------------------- +---- /set weechat.startup.sys_rlimit "core:-1" ----------------------------------------- +---- Pour WeeChat ≤ 0.3.8 ou si vous voulez activer les fichiers core avant que WeeChat ne démarre, vous pouvez utiliser la commande `ulimit`. @@ -357,19 +343,18 @@ WeeChat ne démarre, vous pouvez utiliser la commande `ulimit`. Par exemple sous Linux avec le shell 'bash', ajoutez cette ligne dans votre `~/.bashrc`: ----------------------------------------- +---- ulimit -c unlimited ----------------------------------------- +---- Ou une taille maximum : ----------------------------------------- +---- ulimit -c 200000 ----------------------------------------- +---- [[gdb_backtrace]] -Obtenir la trace avec gdb -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Obtenir la trace avec gdb Lorsque WeeChat se plante, votre système génère un fichier 'core' ou 'core.12345' ('12345' est l'identifiant du processus). @@ -379,9 +364,9 @@ Ce fichier est créé dans le répertoire où vous avez lancé WeeChat (ce n'est Par exemple si 'weechat' est installé dans '/usr/bin/' et que le fichier 'core' est dans '/home/xxx/', alors lancez gdb avec cette commande : ----------------------------------------- +---- gdb /usr/bin/weechat /home/xxx/core ----------------------------------------- +---- [NOTE] Si vous avez installé le paquet binaire 'weechat-dbg' (par exemple sous Debian), @@ -391,7 +376,7 @@ alors vous pouvez utiliser ce chemin pour l'exécutable WeeChat : Puis sous gdb, utilisez la commande `bt full` pour afficher la trace. Vous verrez quelque chose comme ceci : ----------------------------------------- +---- (gdb) set logging file /tmp/crash.txt (gdb) set logging on Copying output to /tmp/crash.txt. @@ -418,7 +403,7 @@ Copying output to /tmp/crash.txt. write_fds = {fds_bits = {0 <repeats 16 times>}} except_fds = {fds_bits = {0 <repeats 16 times>}} max_fd = <value optimized out> ----------------------------------------- +---- Vous devez envoyer cette trace aux développeurs, et leur indiquer quelle action a été la cause de ce plantage. @@ -426,30 +411,27 @@ a été la cause de ce plantage. Merci pour votre aide ! [[debug_running_weechat]] -Debug de WeeChat qui tourne -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Debug de WeeChat qui tourne Pour déboguer WeeChat qui tourne (par exemple si WeeChat semble bloqué), vous pouvez utiliser gdb avec l'identifiant du processus (remplacez '12345' par le PID du processus weechat) : ----------------------------------------- +---- gdb /usr/bin/weechat 12345 ----------------------------------------- +---- Ensuite comme pour un crash, utilisez la commande `bt full` : ----------------------------------------- +---- (gdb) bt full ----------------------------------------- +---- [[usage]] -Utilisation ------------ +== Utilisation [[running_weechat]] -Lancer WeeChat -~~~~~~~~~~~~~~ +=== Lancer WeeChat Paramètres de ligne de commande : @@ -457,9 +439,9 @@ include::cmdline_options.fr.txt[] Pour lancer WeeChat, tapez cette commande : ----------------------------------------- +---- $ weechat ----------------------------------------- +---- Lorsque vous lancez WeeChat pour la première fois, un fichier de configuration par défaut est créé, avec les options par défaut. @@ -470,12 +452,11 @@ vous pouvez modifier les paramètres dans WeeChat avec la commande `/set` (voir <<weechat_commands,commandes WeeChat>>). [[screen_layout]] -Organisation de l'écran -~~~~~~~~~~~~~~~~~~~~~~~ +=== Organisation de l'écran Exemple de terminal avec WeeChat : -........................................ +.... ▼ barre "title" ┌───────────────────────────────────────────────────────────────────────────┐ │Bienvenue sur #test, canal de test │ @@ -500,7 +481,7 @@ Exemple de terminal avec WeeChat : │[@Flashy(i)] hi peter!█ │ └───────────────────────────────────────────────────────────────────────────┘ ▲ barres "status" et "input" barre "nicklist" ▲ -........................................ +.... L'écran est composé des zones suivantes : @@ -518,7 +499,7 @@ L'écran est composé des zones suivantes : La barre 'status' contient les objets (items) suivants par défaut : [width="100%",cols="^3,^3,10",options="header"] -|======================================== +|=== | Objet (item) | Exemple | Description | time | `[12:55]` | Heure | buffer_count | `[6]` | Nombre de tampons ouverts @@ -532,23 +513,22 @@ La barre 'status' contient les objets (items) suivants par défaut : | hotlist | `[H: 4:#abc(2,5), 6]` | Liste des tampons où il y a de l'activité (messages non lus) (dans cet exemple, 2 highlights et 5 messages non lus sur '#abc', un message non lu sur le tampon numéro 6) | completion | `abc(2) def(5)` | Liste des mots pour la complétion, avec le nombre de complétions possibles pour chaque mot | scroll | `-PLUS(50)-` | Indicateur de scroll, avec le nombre de lignes sous la dernière ligne affichée -|======================================== +|=== La barre 'input' contient les objets (items) suivants par défaut : [width="100%",cols="^3,^6,8",options="header"] -|======================================== +|=== | Objet (item) | Exemple | Description | input_paste | `[Coller 7 lignes ? [ctrl-Y] Oui [ctrl-N] Non]` | Question à l'utilisateur pour coller des lignes | input_prompt | `[@Flashy(i)]` | Prompt, pour irc: pseudo et modes (le mode "+i" signifie invisible sur freenode) | away | `(absent)` | Indicateur d'absence | input_search | `[Recherche (~ str,msg)]` | Indicateur de recherche de texte ("`~`" : insensible à la casse, "`==`" : sensible à la casse, "`str`" : recherche de chaîne, "`regex`" : recherche d'expression régulière, "`msg`" : recherche dans les messages, "`pre`" : recherche dans les préfixes, "`pre\|msg`" : recherche dans les préfixes et messages) | input_text | `salut peter !` | Texte entré -|======================================== +|=== [[buffers_and_windows]] -Tampons et fenêtres -~~~~~~~~~~~~~~~~~~~ +=== Tampons et fenêtres Un tampon ('buffer') est composé d'un numéro, un nom, des lignes affichées (ainsi que d'autres données). @@ -569,7 +549,7 @@ aucune fenêtre) ou affiché par une ou plusieurs fenêtres. Exemple de découpage horizontal (`/window splith`) : -........................................ +.... ▼ fenêtre n°2 (tampon n°4) ┌───────────────────────────────────────────────────────────────────────────┐ │Bienvenue sur #abc │ @@ -597,11 +577,11 @@ Exemple de découpage horizontal (`/window splith`) : │[@Flashy] hi peter!█ │ └───────────────────────────────────────────────────────────────────────────┘ ▲ fenêtre n°1 (tampon n°3) -........................................ +.... Exemple de découpage vertical (`/window splitv`) : -........................................ +.... ┌───────────────────────────────────────────────────────────────────────────┐ │Bienvenue sur #test │Bienvenue sur #abc │ │12:54:15 peter | ohé ! │@Flashy│12:55:12 Max | bonjour │@Flashy│ @@ -625,11 +605,11 @@ Exemple de découpage vertical (`/window splitv`) : │[@Flashy] hi peter!█ │[@Flashy] │ └───────────────────────────────────────────────────────────────────────────┘ ▲ fenêtre n°1 (tampon n°3) ▲ fenêtre n°2 (tampon n°4) -........................................ +.... Exemple de découpage vertical + horizontal : -........................................ +.... ▼ fenêtre n°3 (tampon n°5) ┌───────────────────────────────────────────────────────────────────────────┐ │Bienvenue sur #test │Bienvenue sur #def │ @@ -657,11 +637,10 @@ Exemple de découpage vertical + horizontal : │[@Flashy] salut peter !█ │[@Flashy] │ └───────────────────────────────────────────────────────────────────────────┘ ▲ fenêtre n°1 (tampon n°3) ▲ fenêtre n°2 (tampon n°4) -........................................ +.... [[bars]] -Barres -~~~~~~ +=== Barres Une 'barre' est une zone à côté de la discussion qui peut contenir tout type de texte. @@ -672,7 +651,7 @@ Les options de barre sont définies avec les options `weechat.bar.nom.option` o Liste des options de barre : [width="100%",cols="2m,2,10",options="header"] -|======================================== +|=== | Option | Valeurs | Description | type | `root`, `window` | @@ -740,11 +719,10 @@ Liste des options de barre : | conditions | chaîne | Les conditions pour afficher la barre (voir <<bar_conditions,conditions>> pour plus d'infos). -|======================================== +|=== [[bar_items]] -Objets -^^^^^^ +==== Objets L'option 'items' est une chaîne avec une liste d'objets de barre, séparés par une virgule (espace entre les objets à l'écran) ou un "+" (objets collés). @@ -759,11 +737,11 @@ de barre avec la couleur des délimiteurs définie dans la barre (option Exemple de barre avec les objets "[time],buffer_number+:+buffer_plugin+.+buffer_name" : -........................................ +.... ┌───────────────────────────────────────────────────────────────────────────┐ │[12:55] 3:irc/freenode.#weechat │ └───────────────────────────────────────────────────────────────────────────┘ -........................................ +.... Une syntaxe spéciale peut être utilisée pour forcer le tampon utilisé lors de l'affichage de l'objet de barre : "@tampon:objet" (où "tampon" est le nom @@ -776,13 +754,12 @@ affiché du tout). Exemple : liste de pseudos de bitlbee dans une barre "root" (si la barre s'appelle 'bitlist' et si le serveur bitlbee s'appelle 'bitlbee') : ----------------------------------------- +---- /set weechat.bar.bitlist.items "@irc.bitlbee.&bitlbee:buffer_nicklist" ----------------------------------------- +---- [[bar_filling]] -Remplissage -^^^^^^^^^^^ +==== Remplissage Il y a quatre types de remplissage : @@ -804,7 +781,7 @@ Les barres par défaut 'title', 'status' et 'input' ont un remplissage Quelques exemples de remplissage pour la barre 'nicklist' : -........................................ +.... ┌──────────────────────────────────────────────────┐ │Welcome to #test, this is a test channel │ │12:54:15 peter | hey! │@carl │ @@ -858,11 +835,10 @@ Quelques exemples de remplissage pour la barre 'nicklist' : │───────────────────────────────────────────────────────────────────────│ │ │ filling_top_bottom = columns_horizontal ▲ -........................................ +.... [[bar_conditions]] -Conditions -^^^^^^^^^^ +==== Conditions L'option 'conditions' est une chaîne évaluée pour savoir si la barre doit être affichée ou non dans la fenêtre (elle est utilisée seulement pour les barres @@ -891,20 +867,19 @@ Les pointeurs suivants sont disponibles : Exemple pour afficher la liste de pseudos dans tous les tampons possédant une liste de pseudos, et seulement si la largeur de fenêtre est supérieurs à 100 : ----------------------------------------- +---- /set weechat.bar.nicklist.conditions "${nicklist} && ${window.win_width} > 100" ----------------------------------------- +---- Même condition, mais afficher toujours la liste de pseudos sur le tampon '&bitlbee' (même si la fenêtre est petite) : ----------------------------------------- +---- /set weechat.bar.nicklist.conditions "${nicklist} && (${window.win_width} > 100 || ${buffer.full_name} == irc.bitlbee.&bitlbee)" ----------------------------------------- +---- [[notify_levels]] -Niveaux de notification -~~~~~~~~~~~~~~~~~~~~~~~ +=== Niveaux de notification Quatre niveaux sont possibles dans les messages affichés dans les tampons, du moins important au plus important : @@ -922,46 +897,44 @@ Le niveau de notification par défaut peut être défini avec l'option la valeur par défaut est 'all'. [width="50%",cols="3m,10",options="header"] -|======================================== +|=== | Niveau de notification | Niveau des messages ajoutés à la hotlist | none | (aucun) | highlight | 'highlight' + 'private' | message | 'highlight' + 'private' + 'message' | all | 'highlight' + 'private' + 'message' + 'low' -|======================================== +|=== Le niveau de notification peut être défini pour un ensemble de tampons, par exemple tous les tampons du serveur irc "freenode" : ----------------------------------------- +---- /set weechat.notify.irc.freenode message ----------------------------------------- +---- Définir le niveau de notification 'highlight' sur le canal "#weechat" seulement : ----------------------------------------- +---- /set weechat.notify.irc.freenode.#weechat highlight ----------------------------------------- +---- Le niveau de notification pour un tampon peut aussi être défini avec la commande `/buffer` : ----------------------------------------- +---- /buffer notify highlight ----------------------------------------- +---- [[key_bindings]] -Raccourcis clavier par défaut -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +=== Raccourcis clavier par défaut // 'C-' = ctrl, 'A-' = alt, 'S-' = shift [[key_bindings_command_line]] -Touches pour la ligne de commande -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Touches pour la ligne de commande [width="100%",cols="^.^3,.^10,.^5",options="header"] -|======================================== +|=== | Touche | Description | Commande | @k(←) .2+| Aller au caractère précédent sur la ligne de commande .2+| `/input move_previous_char` | @k(C-)@k(b) @@ -1006,14 +979,13 @@ Touches pour la ligne de commande | @k(A-)@k(k) | Capturer une touche et insérer son code (et la commande associée si la commande existe) sur la ligne de commande | `/input grab_key_command` | @k(A-)@k(r) | Effacer entièrement la ligne de commande | `/input delete_line` | @k(A-)@k(s) | Activer/désactiver aspell | `/mute aspell toggle` -|======================================== +|=== [[key_bindings_buffers_windows]] -Touches pour les tampons / fenêtres -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Touches pour les tampons / fenêtres [width="100%",cols="^.^3,.^10,.^5",options="header"] -|======================================== +|=== | Touche | Description | Commande | @k(C-)@k(l) | Réafficher toute la fenêtre | `/window refresh` | @k(C-)@k(s) , @k(C-)@k(u) | Positionner le marqueur de données non lues sur tous les tampons | `/input set_unread` @@ -1063,17 +1035,16 @@ Touches pour les tampons / fenêtres | @k(A-)@k(>) | Sauter au tampon suivant dans la liste des tampons visités | `/input jump_next_visited_buffer` | @k(A-)@k(/) | Sauter au dernier tampon affiché (avant le dernier saut vers un tampon) | `/input jump_last_buffer_displayed` | @k(A-)@k(=) | Activer/désactiver les filtres | `/filter toggle` -|======================================== +|=== [[key_bindings_search_context]] -Touches pour le contexte "search" -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Touches pour le contexte "search" Ces touches sont utilisées dans le contexte "search" (lorsque @k(C-)@k(r) est pressé pour chercher du texte dans le tampon). [width="100%",cols="^.^3,.^10,.^5",options="header"] -|======================================== +|=== | Touche | Description | Commande | @k(C-)@k(r) | Basculer le type de recherche : chaîne (par défaut), expression régulière | `/input search_switch_regex` | @k(A-)@k(c) | Basculer la casse exacte pour la recherche | `/input search_switch_case` @@ -1083,17 +1054,16 @@ pressé pour chercher du texte dans le tampon). | @k(Enter) .3+| Arrêter la recherche .3+| `/input search_stop` | @k(C-)@k(j) | @k(C-)@k(m) -|======================================== +|=== [[key_bindings_cursor_context]] -Touches pour le contexte "cursor" -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Touches pour le contexte "cursor" Ces touches sont utilisées dans le contexte "cursor" (mouvement libre du curseur à l'écran). [width="100%",cols="^.^3,^.^3,.^10,.^8",options="header"] -|======================================== +|=== | Touche | Zone | Description | Commande | @k(↑) | - | Déplacer le curseur d'une ligne vers le haut | `/cursor move up` | @k(↓) | - | Déplacer le curseur d'une ligne vers le bas | `/cursor move down` @@ -1114,17 +1084,16 @@ Ces touches sont utilisées dans le contexte "cursor" (mouvement libre du curseu | @k(Enter) .3+| - .3+| Arrêter le mode curseur ("cursor") .3+| `/cursor stop` | @k(C-)@k(j) | @k(C-)@k(m) -|======================================== +|=== [[key_bindings_mouse_context]] -Touches pour le contexte "mouse" -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Touches pour le contexte "mouse" Ces touches sont utilisées dans le contexte "mouse", c'est-à-dire lorsqu'un évènement de la souris se produit. [width="100%",cols="^.^3,^.^3,^.^3,.^10,.^8",options="header"] -|======================================== +|=== | Bouton ^(1)^ | Geste | Zone | Description | Commande | ◾◽◽ | - | chat | Aller à la fenêtre | `/window ${_window_number}` | ◾◽◽ | left | chat | Aller au tampon précédent | `/window ${_window_number};/buffer +1` @@ -1152,42 +1121,40 @@ Ces touches sont utilisées dans le contexte "mouse", c'est-à-dire lorsqu'un | ⇑ | - | toute barre | Faire défiler la barre de -20% | `/bar scroll ${_bar_name} ${_window_number} -20%` | ⇓ | - | toute barre | Faire défiler la barre de +20% | `/bar scroll ${_bar_name} ${_window_number} +20%` | ◽◾◽ | - | n'importe où | Démarrer le mode curseur ("cursor") à ce point | `/cursor go ${_x},${_y}` -|======================================== +|=== [NOTE] ^(1)^ "⇑" et "⇓" sont la roulette vers le haut et le bas. [[mouse]] -Support souris -~~~~~~~~~~~~~~ +=== Support souris WeeChat supporte les clics et mouvements avec la souris. Cela fonctionne avec un terminal local, et à distance via une connexion ssh, avec ou sans screen/tmux. [[mouse_enable]] -Activer la souris -^^^^^^^^^^^^^^^^^ +==== Activer la souris Pour activer la souris au démarrage : ----------------------------------------- +---- /set weechat.look.mouse on ----------------------------------------- +---- Pour activer la souris maintenant, appuyez sur @k(A-)@k(m) ou lancez la commande suivante : ----------------------------------------- +---- /mouse enable ----------------------------------------- +---- Il est possible de désactiver temporairement la souris, et associer ça à une touche. Par exemple la touche @k(A-)@k(x) pour désactiver la souris pendant 10 secondes : ----------------------------------------- +---- /key bind meta-x /mouse toggle 10 ----------------------------------------- +---- Lorsque la souris est activée dans WeeChat, vous pouvez utiliser la touche @k(-S-) pour sélectionner ou cliquer dans le terminal, comme si la souris était @@ -1198,8 +1165,7 @@ lieu de @k(-S-)). Pour tout problème avec la souris, merci de consulter la 'FAQ WeeChat'. [[mouse_bind_events]] -Associer des évènements souris à des commandes -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Associer des évènements souris à des commandes De nombreux évènements souris sont déjà définis par WeeChat (voir <<key_bindings_mouse_context,les touches pour le contexte "mouse">>). @@ -1214,17 +1180,17 @@ un geste (facultatif). Les différents éléments sont séparés par "-". Liste des modifieurs : [width="50%",cols="3m,4",options="header"] -|======================================== +|=== | Modifieur | Description | ctrl | Touche @k(-C-) | alt | Touche @k(-A-) | ctrl-alt | Touches @k(-C-) et @k(-A-) -|======================================== +|=== Liste des boutons/roulette : [width="50%",cols="3m,4",options="header"] -|======================================== +|=== | Bouton/roulette | Description | button1 | Clic sur le bouton gauche | button2 | Clic sur le bouton droit @@ -1232,12 +1198,12 @@ Liste des boutons/roulette : | button4 ... button9 | Clic sur un bouton additionnel | wheelup | Roulette (haut) | wheeldown | Roulette (bas) -|======================================== +|=== Liste des gestes (seulement pour les boutons, pas la roulette) : [width="50%",cols="3m,4",options="header"] -|======================================== +|=== | Geste | Distance | gesture-up | 3 ... 19 | gesture-up-long | ≥ 20 @@ -1247,17 +1213,17 @@ Liste des gestes (seulement pour les boutons, pas la roulette) : | gesture-left-long | ≥ 40 | gesture-right | 3 ... 39 | gesture-right-long | ≥ 40 -|======================================== +|=== Liste des évènements incomplets (seulement pour les boutons, pratique pour les extensions/scripts) : [width="50%",cols="3m,4",options="header"] -|======================================== +|=== | Évènement | Description | event-down | Le bouton a été pressé mais pas encore relâché | event-drag | La souris a bougé avec le bouton pressé -|======================================== +|=== Exemples d'évènements : @@ -1283,40 +1249,37 @@ puis en faisant l'action avec la souris. Cela insérera le nom de l'évènement sur la ligne de commande. [[command_line]] -Ligne de commande -~~~~~~~~~~~~~~~~~ +=== Ligne de commande La ligne de commande WeeChat (située en bas de la fenêtre) permet d'exécuter des commandes ou d'envoyer du texte vers le tampon. [[command_line_syntax]] -Syntaxe -^^^^^^^ +==== Syntaxe Les commandes débutent par un caractère "/", suivi du nom de la commande. Par exemple pour afficher la liste de toutes les options : ----------------------------------------- +---- /set ----------------------------------------- +---- Le texte envoyé à un tampon est tout texte ne commençant pas par le caractère "/", par exemple pour envoyer 'bonjour' sur le tampon courant : ----------------------------------------- +---- bonjour ----------------------------------------- +---- Il est cependant possible de faire débuter un texte par "/" en le doublant. Par exemple pour envoyer le texte '/set' sur le tampon courant : ----------------------------------------- +---- //set ----------------------------------------- +---- [[command_line_colors]] -Codes couleurs -^^^^^^^^^^^^^^ +==== Codes couleurs Pour certaines extensions comme IRC, il est possible d'utiliser des codes couleur et attributs comme suit (appuyer sur @k(C-)@k(c) puis sur la lettre qui @@ -1351,7 +1314,7 @@ stopper l'attribut défini. Les codes couleur pour @k(C-)@k(c) , @k(c) sont : [width="50%",cols="^1m,3,3",options="header"] -|======================================== +|=== | Code | IRC | WeeChat (curses) | 00 | blanc | white | 01 | noir | black @@ -1369,22 +1332,21 @@ Les codes couleur pour @k(C-)@k(c) , @k(c) sont : | 13 | violet clair | lightmagenta | 14 | gris | gray | 15 | gris clair | white -|======================================== +|=== Exemple : affichage de "bonjour tout le monde !" avec "bonjour" en bleu clair gras, et "tout le monde" en rouge clair souligné : ----------------------------------------- +---- ^Cc12^Cbbonjour ^Cb^Cc04^Cutout le monde^Cu^Cc ! ----------------------------------------- +---- [NOTE] Dans l'extension irc, vous pouvez réassigner les couleurs en utilisant l'option <<option_irc.color.mirc_remap,irc.color.mirc_remap>>. [[colors]] -Couleurs -~~~~~~~~ +=== Couleurs WeeChat peut utiliser jusqu'à 256 paires de couleur pour afficher le texte dans les barres et la zone de discussion (votre terminal doit supporter 256 couleurs @@ -1394,13 +1356,13 @@ Selon la valeur de la variable d'environnement 'TERM', vous pouvez avoir les limites suivantes pour les couleurs dans WeeChat : [width="50%",cols="8,>2,>2",options="header"] -|======================================== +|=== | $TERM | Couleurs | Paires ^(1)^ | "rxvt-unicode", "xterm", ... | 88 | 256 | "rxvt-256color", "xterm-256color", ... | 256 | 32767 | "screen" | 8 | 64 | "screen-256color" | 256 | 32767 -|======================================== +|=== [NOTE] ^(1)^ Même si votre terminal supporte plus de 256 paires, seules 256 paires @@ -1420,27 +1382,26 @@ Si vous utilisez screen, vous pouvez ajouter cette ligne dans votre '~/.screenrc Vous devrez peut-être installer le paquet "ncurses-term" pour utiliser ces valeurs dans la variable 'TERM'. ----------------------------------------- +---- term screen-256color ----------------------------------------- +---- Si votre variable 'TERM' a une valeur erronée et que WeeChat est déjà lancé, ne paniquez pas ! Vous pouvez la changer sans redémarrer, grâce au script 'shell.py' : ----------------------------------------- +---- /shell setenv TERM=screen-256color /upgrade ----------------------------------------- +---- [[colors_basic]] -Couleurs de base -^^^^^^^^^^^^^^^^ +==== Couleurs de base Les couleurs de base dans WeeChat sont : [width="50%",cols="^3m,8",options="header"] -|======================================== +|=== | Nom | Couleur | default | Couleur par défaut du terminal (transparent pour le fond) | black | Noir @@ -1459,11 +1420,10 @@ Les couleurs de base dans WeeChat sont : | lightcyan | Cyan clair | gray | Gris | white | Blanc -|======================================== +|=== [[colors_extended]] -Couleurs étendues -^^^^^^^^^^^^^^^^^ +==== Couleurs étendues WeeChat alloue dynamiquement les paires de couleurs quand elles sont utilisées sur l'écran (pour afficher les tampons et les barres). @@ -1478,33 +1438,31 @@ terminal pour choisir une couleur. Par exemple si vous souhaitez afficher l'heure en orange dans le tampon, faites : ----------------------------------------- +---- /set weechat.color.chat_time 214 ----------------------------------------- +---- Ou si vous voulez un fond vert très foncé pour la barre de statut : ----------------------------------------- +---- /set weechat.bar.status.color_bg 22 ----------------------------------------- +---- [[colors_aliases]] -Alias -^^^^^ +==== Alias Vous pouvez ajouter des alias de couleur avec la commande `/color alias` puis utiliser cet alias dans n'importe quelle option de couleur. Par exemple : ----------------------------------------- +---- /color alias 214 orange /set weechat.color.chat_delimiters orange ----------------------------------------- +---- [[colors_attributes]] -Attributs -^^^^^^^^^ +==== Attributs Il est possible d'utiliser des attributs pour les couleurs. Un ou plusieurs attributs peuvent être ajoutés avant le nom ou le numéro de la couleur : @@ -1518,15 +1476,15 @@ attributs peuvent être ajoutés avant le nom ou le numéro de la couleur : Par exemple si vous voulez votre pseudo en blanc souligné, faites : ----------------------------------------- +---- /set weechat.color.chat_nick_self _white ----------------------------------------- +---- Ou si vous voulez l'heure dans la barre de statut en orange souligné avec gras : ----------------------------------------- +---- /set weechat.color.status_time *_214 ----------------------------------------- +---- Pour utiliser un attribut avec la couleur par défaut du terminal (-1), vous devez utiliser un nombre supérieur à la dernière couleur du terminal, par @@ -1534,39 +1492,36 @@ exemple la couleur maximum de WeeChat : 99999. Exemple de gras avec la couleur de texte du terminal : ----------------------------------------- +---- /set weechat.color.status_time *99999 ----------------------------------------- +---- [[options_and_commands]] -Options et commandes -~~~~~~~~~~~~~~~~~~~~ +=== Options et commandes [[sec_options]] -Options des données sécurisées (sec.conf) -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Options des données sécurisées (sec.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | crypt | /set sec.crypt.* | Options pour le chiffrement | data | <<command_weechat_secure,/secure>> | Données sécurisées -|======================================== +|=== Options : include::autogen/user/sec_options.txt[] [[weechat_options]] -Options WeeChat (weechat.conf) -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Options WeeChat (weechat.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | debug | <<command_weechat_debug,/debug set>> + /set weechat.debug.* | Niveau de debug, pour le Debug level, pour le cœur et les extensions (les options peuvent être ajoutées/supprimées dans la section) @@ -1589,21 +1544,19 @@ Sections : | key_search | <<command_weechat_key,/key>> | Touches pour le contexte "search" | key_cursor | <<command_weechat_key,/key>> | Touches pour le contexte "cursor" | key_mouse | <<command_weechat_key,/key>> | Touches pour le contexte "mouse" -|======================================== +|=== Options : include::autogen/user/weechat_options.txt[] [[weechat_commands]] -Commandes WeeChat -^^^^^^^^^^^^^^^^^ +==== Commandes WeeChat include::autogen/user/weechat_commands.txt[] [[plugins]] -Extensions ----------- +== Extensions Une extension est une bibliothèque dynamique, écrite en C et compilée, qui est chargée par WeeChat. @@ -1625,16 +1578,16 @@ extension sont automatiquement fermés. Exemples pour charger, décharger et afficher les extensions : ----------------------------------------- +---- /plugin load irc /plugin unload irc /plugin list ----------------------------------------- +---- Les extensions par défaut sont : [width="50%",cols="^1,5",options="header"] -|======================================== +|=== | Extension | Description | alias | Définir des alias pour les commandes | aspell | Vérification orthographique de la ligne de commande @@ -1652,61 +1605,55 @@ Les extensions par défaut sont : | tcl | Interface (API) pour scripts Tcl | guile | Interface (API) pour scripts Guile (scheme) | xfer | Transfert de fichier et discussion directe -|======================================== +|=== Pour en apprendre plus sur le développement d'extension ou de script (via l'API), merci de consulter la 'Référence API Extension WeeChat' ou le 'Guide pour Scripts WeeChat'. [[alias_plugin]] -Extension Alias -~~~~~~~~~~~~~~~ +=== Extension Alias L'extension Alias permet de définir des alias pour des commandes (WeeChat ou d'autres extensions). [[alias_commands]] -Commandes -^^^^^^^^^ +==== Commandes include::autogen/user/alias_commands.txt[] [[aspell_plugin]] -Extension Aspell -~~~~~~~~~~~~~~~~ +=== Extension Aspell L'extension Aspell permet de vérifier l'orthographe de la ligne de commande. Il est possible d'utiliser plusieurs langages par tampon. [[aspell_options]] -Options (aspell.conf) -^^^^^^^^^^^^^^^^^^^^^ +==== Options (aspell.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | color | /set aspell.color.* | Couleurs | check | /set aspell.check.* | Options pour contrôler la vérification orthographique | dict | <<command_aspell_aspell,/aspell setdict>> + /set aspell.dict.* | Dictionnaires utilisés par tampon (les options peuvent être ajoutées/supprimées dans la section) | option | /set aspell.option.* | <<aspell_speller_options,Options du vérificateur d'orthographe>> (les options peuvent être ajoutées/supprimées dans la section) -|======================================== +|=== Options : include::autogen/user/aspell_options.txt[] [[aspell_commands]] -Commandes -^^^^^^^^^ +==== Commandes include::autogen/user/aspell_commands.txt[] [[aspell_speller_options]] -Options du vérificateur d'orthographe -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Options du vérificateur d'orthographe Les options du vérificateur d'orthographe peuvent être définies en ajoutant des options dans la section "option" de la configuration aspell. @@ -1714,19 +1661,18 @@ options dans la section "option" de la configuration aspell. Le nom de l'option est une option de configuration aspell. La liste des options peut être trouvée par la commande suivante sous le shell : ----------------------------------------- +---- $ aspell config ----------------------------------------- +---- Par exemple, pour activer l'option "ignore-case": ----------------------------------------- +---- /set aspell.option.ignore-case "true" ----------------------------------------- +---- [[aspell_suggestions]] -Suggestions -^^^^^^^^^^^ +==== Suggestions Les suggestions sont affichées dans un objet de barre appelé "aspell_suggest". Le nombre de suggestions est défini dans l'option 'aspell.check.suggestions'. @@ -1737,23 +1683,22 @@ Pour activer les suggestions, vous devez modifier l'option Exemple de suggestions avec un dictionnaire anglais (`en`) : -........................................ +.... │[12:55] [6] [irc/freenode] 3:#test(+n){4} [print,prone,prune] │ │[@Flashy] prinr █ │ └─────────────────────────────────────────────────────────────────────────────────┘ -........................................ +.... Exemple de suggestions avec des dictionnaires anglais et français (`en,fr`) : -........................................ +.... │[12:55] [6] [irc/freenode] 3:#test(+n){4} [print,prone,prune/prime,primer,primé] │ │[@Flashy] prinr █ │ └─────────────────────────────────────────────────────────────────────────────────┘ -........................................ +.... [[charset_plugin]] -Extension Charset -~~~~~~~~~~~~~~~~~ +=== Extension Charset L'extension Charset vous permet de décoder et encoder les données en utilisant un jeu de caractères. @@ -1767,15 +1712,15 @@ WeeChat pourra uniquement lire/écrire des données UTF-8. L'extension Charset devrait être automatiquement chargée par WeeChat au démarrage. Pour s'assurer que l'extension est bien chargée, essayez : ----------------------------------------- +---- /charset ----------------------------------------- +---- Si la commande n'est pas trouvée, alors chargez l'extension avec la commande : ----------------------------------------- +---- /plugin load charset ----------------------------------------- +---- Si l'extension n'est pas trouvée, alors vous devriez recompiler WeeChat avec les extensions et le support de Charset. @@ -1787,49 +1732,46 @@ UTF-8. Par exemple : -........................................ +.... charset: terminal: ISO-8859-15, interne: UTF-8 -........................................ +.... [[charset_options]] -Options (charset.conf) -^^^^^^^^^^^^^^^^^^^^^^ +==== Options (charset.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | default | /set charset.default.* | Jeu de caractère d'encodage/décodage par défaut | decode | <<command_charset_charset,/charset decode>> + /set charset.decode.* | Jeu de caractère d'encodage par tampon (les options peuvent être ajoutées/supprimées dans la section) | encode | <<command_charset_charset,/charset encode>> + /set charset.encode.* | Jeu de caractère de décodage par tampon (les options peuvent être ajoutées/supprimées dans la section) -|======================================== +|=== Options : include::autogen/user/charset_options.txt[] [[charset_commands]] -Commandes -^^^^^^^^^ +==== Commandes include::autogen/user/charset_commands.txt[] [[charset_set]] -Définir le jeu de caractère -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Définir le jeu de caractère Pour modifier les jeux de caractères de décodage et d'encodage globaux, utilisez la commande `/set`. Par exemple : ----------------------------------------- +---- /set charset.default.decode ISO-8859-15 /set charset.default.encode ISO-8859-15 ----------------------------------------- +---- Si le jeu de caractères de décodage global n'est pas renseigné (par exemple pendant le premier chargement de Charset), il sera renseigné automatiquement @@ -1846,16 +1788,16 @@ modifiez en même temps les valeurs de décodage et d'encodage. Par exemple : ----------------------------------------- +---- /charset ISO-8859-15 ----------------------------------------- +---- Ce qui est équivalent à : ----------------------------------------- +---- /charset decode ISO-8859-15 /charset encode ISO-8859-15 ----------------------------------------- +---- Pour modifier le jeu de caractères d'un canal IRC (ou d'une conversation privée), utilisez la même commande que pour le serveur, mais sur le tampon du @@ -1863,20 +1805,18 @@ canal (ou du privé). Pour voir tous les jeux de caractères utilisés, utilisez la commande suivante : ----------------------------------------- +---- /set charset.* ----------------------------------------- +---- [[charset_troubleshooting]] -En cas de problème -^^^^^^^^^^^^^^^^^^ +==== En cas de problème Pour tout problème avec les jeux de caractères, merci de consulter la 'FAQ WeeChat'. [[fifo_plugin]] -Extension Fifo -~~~~~~~~~~~~~~ +=== Extension Fifo Vous pouvez contrôler WeeChat à distance, en envoyant des commandes ou du texte dans un tube FIFO (si l'option 'plugins.var.fifo.fifo' est activée, @@ -1889,43 +1829,43 @@ tourne). La syntaxe pour envoyer des commandes ou du texte dans le tube FIFO est une des suivantes : -........................................ +.... plugin.buffer *texte ou commande ici *texte ou commande ici -........................................ +.... Quelques exemples : * changement du pseudo sur freenode en "autrepseudo" : ----------------------------------------- +---- $ echo 'irc.server.freenode */nick autrepseudo' >~/.weechat/weechat_fifo_12345 ----------------------------------------- +---- * affichage de texte sur le canal IRC #weechat : ----------------------------------------- +---- $ echo 'irc.freenode.#weechat *bonjour !' >~/.weechat/weechat_fifo_12345 ----------------------------------------- +---- * affichage de texte sur le tampon courant : ----------------------------------------- +---- $ echo '*bonjour !' >~/.weechat/weechat_fifo_12345 ----------------------------------------- +---- * envoyer deux commandes pour décharger/recharger les scripts Python (vous devez les séparer par "\n") : ----------------------------------------- +---- $ echo -e '*/python unload\n*/python autoload' >~/.weechat/weechat_fifo_12345 ----------------------------------------- +---- Vous pouvez écrire un script qui envoie les commandes à tous les WeeChat qui tournent en même temps, par exemple : [source,shell] ----------------------------------------- +---- #!/bin/sh if [ $# -eq 1 ]; then for fifo in ~/.weechat/weechat_fifo_* @@ -1933,17 +1873,16 @@ if [ $# -eq 1 ]; then echo -e "$1" >$fifo done fi ----------------------------------------- +---- Si le script s'appelle "auto_weechat_command", vous pouvez le lancer ainsi : ----------------------------------------- +---- $ ./auto_weechat_command 'irc.freenode.#weechat *bonjour' ----------------------------------------- +---- [[irc_plugin]] -Extension IRC -~~~~~~~~~~~~~ +=== Extension IRC L'extension IRC permet de dialoguer avec d'autres personnes via le protocole IRC. @@ -1953,30 +1892,28 @@ compris la discussion directe (DCC chat) et le transfert de fichier DCC (via l'extension xfer, voir <<xfer_plugin,extension Xfer>>). [[irc_command_line_options]] -Options de ligne de commande -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Options de ligne de commande Il est possible de passer une URL pour un ou plusieurs serveurs, comme suit : ----------------------------------------- +---- irc[6][s]://[pseudo[:mot_passe]@]irc.example.org[:port][/canal][,canal[...]] ----------------------------------------- +---- Exemple pour rejoindre '#weechat' et '#toto' sur le serveur 'irc.freenode.net', port par défaut (6667), avec le pseudo 'nono' : ----------------------------------------- +---- $ weechat irc://nono@irc.freenode.net/#weechat,#toto ----------------------------------------- +---- [[irc_options]] -Options (irc.conf) -^^^^^^^^^^^^^^^^^^ +==== Options (irc.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | look | /set irc.look.* | Look and feel | color | /set irc.color.* | Couleurs @@ -1987,21 +1924,19 @@ Sections : | server_default | /set irc.server_default.* | Valeurs par défaut pour serveurs (les options peuvent être ajoutées/supprimées dans la section) | server | <<command_irc_server,/server>> + /set irc.server.* | Serveurs -|======================================== +|=== Options : include::autogen/user/irc_options.txt[] [[irc_commands]] -Commandes -^^^^^^^^^ +==== Commandes include::autogen/user/irc_commands.txt[] [[irc_ssl_certificates]] -Certificats SSL -^^^^^^^^^^^^^^^ +==== Certificats SSL Lors de la connexion à un serveur IRC avec SSL, WeeChat vérifie par défaut que la connexion est entièrement de confiance. @@ -2030,50 +1965,47 @@ et peut échouer, même si cela pouvait être OK dans les versions inférieures 0.3.1. [[irc_connect_oftc_with_certificate]] -Premier exemple : se connecter à oftc en vérifiant le certificat -++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +===== Premier exemple : se connecter à oftc en vérifiant le certificat * Importer le certificat sous le shell : ----------------------------------------- +---- $ mkdir -p ~/.weechat/ssl $ wget -O ~/.weechat/ssl/CAs.pem http://www.spi-inc.org/ca/spi-cacert.crt ----------------------------------------- +---- Note: il est possible de concaténer plusieurs certificats dans une le fichier CAs.pem. * Sous WeeChat, avec le serveur "oftc" déjà créé : ----------------------------------------- +---- /connect oftc ----------------------------------------- +---- [[irc_connect_oftc_with_certfp]] -Second exemple : se connecter à oftc en utilisant CertFP -++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +===== Second exemple : se connecter à oftc en utilisant CertFP * Créer le certificat sous le shell : ----------------------------------------- +---- $ mkdir -p ~/.weechat/ssl $ cd ~/.weechat/ssl $ openssl req -nodes -newkey rsa:2048 -keyout nick.pem -x509 -days 365 -out nick.pem ----------------------------------------- +---- * Sous WeeChat, avec le serveur "oftc" déjà créé : ----------------------------------------- +---- /set irc.server.oftc.ssl_cert "%h/ssl/nick.pem" /connect oftc /msg nickserv cert add ----------------------------------------- +---- Pour plus d'informations, consulter http://www.oftc.net/oftc/NickServ/CertFP [[irc_sasl_authentication]] -Authentification avec SASL -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Authentification avec SASL WeeChat supporte l'authentification avec SASL, en utilisant différents mécanismes : @@ -2092,17 +2024,16 @@ Les options dans le serveur sont : Si vous voulez utiliser "dh-blowfish" par défaut pour tous les serveurs : ----------------------------------------- +---- /set irc.server_default.sasl_mechanism dh-blowfish ----------------------------------------- +---- [NOTE] La librairie "gcrypt" est requise lors de la compilation de WeeChat pour utiliser le mécanisme "dh-blowfish" (voir <<dependencies,les dépendances>>). [[irc_tor_freenode]] -Connexion à Freenode avec TOR/SASL -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Connexion à Freenode avec TOR/SASL En plus du SSL, les serveurs Freenode supportent les connexions avec TOR (https://www.torproject.org/), un réseau de tunnels virtuels qui permet aux @@ -2115,49 +2046,48 @@ l'authentification "plain" avec SASL. En premier lieu, installez TOR. Pour Debian (et dérivés) : ----------------------------------------- +---- $ sudo apt-get install tor ----------------------------------------- +---- Sous WeeChat vous devez créer un proxy socks5 pour le service TOR (le nom/IP et port dépend de votre configuration de TOR) : ----------------------------------------- +---- /proxy add tor socks5 127.0.0.1 9050 ----------------------------------------- +---- Maintenant, créez un nouveau serveur, par exemple : ----------------------------------------- +---- /server add freenode-tor p4fsi4ockecnea7l.onion ----------------------------------------- +---- Définissez le proxy pour TOR : ----------------------------------------- +---- /set irc.server.freenode-tor.proxy "tor" ----------------------------------------- +---- Définissez l'authentification SASL : ----------------------------------------- +---- /set irc.server.freenode-tor.sasl_mechanism dh-blowfish /set irc.server.freenode-tor.sasl_username "votre_pseudo" /set irc.server.freenode-tor.sasl_password "votre_mot_de_passe" ----------------------------------------- +---- Et enfin, la connexion au serveur : ----------------------------------------- +---- /connect freenode-tor ----------------------------------------- +---- Pour plus d'informations à propos de Freenode et TOR : http://freenode.net/irc_servers.shtml#tor [[irc_smart_filter_join_part_quit]] -Filtre intelligent pour les messages join/part/quit -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Filtre intelligent pour les messages join/part/quit Un filtre intelligent est disponible pour filtrer les messages join/part/quit lorsque le pseudo n'a rien dit durant les X dernières minutes sur le canal. @@ -2165,37 +2095,36 @@ lorsque le pseudo n'a rien dit durant les X dernières minutes sur le canal. Le filtre intelligent est activé par défaut, mais vous devez ajouter un filtre pour cacher les lignes sur les tampons, par exemple : ----------------------------------------- +---- /filter add irc_smart * irc_smart_filter * ----------------------------------------- +---- Il est possible de créer un filtre pour un canal seulement ou plusieurs canaux commençant par le même nom (voir `/help filter`) : ----------------------------------------- +---- /filter add irc_smart_weechat irc.freenode.#weechat irc_smart_filter * /filter add irc_smart_weechats irc.freenode.#weechat* irc_smart_filter * ----------------------------------------- +---- Vous pouvez cacher seulement les join ou part/quit avec les options suivantes : ----------------------------------------- +---- /set irc.look.smart_filter_join on /set irc.look.smart_filter_quit on ----------------------------------------- +---- Vous pouvez modifier le délai (en minutes) : ----------------------------------------- +---- /set irc.look.smart_filter_delay 5 ----------------------------------------- +---- Si le pseudo n'a pas parlé durant les 5 dernières minutes, ses join et/ou part/quit seront cachés sur le canal. [[irc_ctcp_replies]] -Réponses CTCP -^^^^^^^^^^^^^ +==== Réponses CTCP Il est possible de personnaliser les réponses CTCP, ou de bloquer certaines demandes CTCP (ne pas y répondre). @@ -2203,42 +2132,42 @@ demandes CTCP (ne pas y répondre). Par exemple, pour personnaliser la réponse au CTCP "VERSION", utilisez la commande suivante : ----------------------------------------- +---- /set irc.ctcp.version "Je suis sous WeeChat $version, ça déchire !" ----------------------------------------- +---- Si vous voulez bloquer le CTCP "VERSION" (ne pas répondre à une demande), alors affectez une chaîne vide : ----------------------------------------- +---- /set irc.ctcp.version "" ----------------------------------------- +---- Même un CTCP inconnu peut être personnalisé, par exemple vous pouvez répondre au CTCP "BLABLA" : ----------------------------------------- +---- /set irc.ctcp.blabla "C'est ma réponse au CTCP BLABLA" ----------------------------------------- +---- Il est possible de personnaliser le CTCP pour un seul serveur, en utilisant son nom interne avant le nom du CTCP : ----------------------------------------- +---- /set irc.ctcp.freenode.version "WeeChat $version (pour freenode)" ----------------------------------------- +---- Si vous voulez restaurer la réponse CTCP standard, alors supprimez l'option : ----------------------------------------- +---- /unset irc.ctcp.version ----------------------------------------- +---- Les codes suivants peuvent être utilisés dans les chaînes et sont automatiquement remplacées par WeeChat lors de la réponse au CTCP : [width="100%",cols="^2l,4,8",options="header"] -|======================================== +|=== | Code | Description | Valeur / exemple | $clientinfo | Liste des CTCP supportés | `ACTION DCC CLIENTINFO FINGER PING SOURCE TIME USERINFO VERSION` | $version | Version de WeeChat | `0.4.0-dev` @@ -2251,7 +2180,7 @@ automatiquement remplacées par WeeChat lors de la réponse au CTCP : | $time | Date/heure courante | `Sun, 16 Dec 2012 10:40:48 +0100` | $username | Nom d'utilisateur sur le serveur | `nom` | $realname | Nom réel sur le serveur | `John Doe` -|======================================== +|=== [NOTE] ^(1)^ La version git est la sortie de la commande `git describe`. Elle est @@ -2261,7 +2190,7 @@ installé. Si les options CTCP ne sont pas définies (par défaut), les réponses CTCP sont : [width="100%",cols="^2,4,8",options="header"] -|======================================== +|=== | CTCP | Format de réponse | Exemple | CLIENTINFO | `$clientinfo` | `ACTION DCC CLIENTINFO FINGER PING SOURCE TIME USERINFO VERSION` | FINGER | `WeeChat $versiongit` | `WeeChat 0.4.0-dev (git: v0.3.9-104-g7eb5cc4)` @@ -2269,11 +2198,10 @@ Si les options CTCP ne sont pas définies (par défaut), les réponses CTCP sont | TIME | `$time` | `Sun, 16 Dec 2012 10:40:48 +0100` | USERINFO | `$username ($realname)` | `nom (John Doe)` | VERSION | `WeeChat $versiongit ($compilation)` | `WeeChat 0.4.0-dev (git: v0.3.9-104-g7eb5cc4) (Dec 16 2012)` -|======================================== +|=== [[irc_target_buffer]] -Tampon cible pour les messages IRC -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Tampon cible pour les messages IRC Il est possible de personnaliser le tampon cible pour les messages IRC (le tampon utilisé pour afficher le message) avec les options `irc.msgbuffer.*`. @@ -2300,7 +2228,7 @@ le tampon approprié, généralement le tampon du serveur ou du canal. Liste non exhaustive des messages ou alias que vous pouvez paramétrer : [width="60%",cols="^1m,^3m,8",options="header"] -|======================================== +|=== | message | alias | description | error | | erreur | invite | | invité sur un canal @@ -2368,7 +2296,7 @@ Liste non exhaustive des messages ou alias que vous pouvez paramétrer : | 728 | quietlist | liste des "quiet" | 729 | quietlist | fin de la liste des "quiet" | 901 | | vous êtes maintenant identifié -|======================================== +|=== Les autres messages numériques peuvent être paramétrés de la même manière. @@ -2379,65 +2307,61 @@ Quelques exemples: * afficher le résultat de `/whois` sur le tampon privé: ----------------------------------------- +---- /set irc.msgbuffer.whois private ----------------------------------------- +---- * restaurer le tampon par défaut pour whois (tampon du serveur): ----------------------------------------- +---- /unset irc.msgbuffer.whois ----------------------------------------- +---- * afficher une invitation sur le tampon courant, pour le serveur "freenode" seulement : ----------------------------------------- +---- /set irc.msgbuffer.freenode.invite current ----------------------------------------- +---- * afficher le message "303" (ison) sur le tampon "core" WeeChat: ----------------------------------------- +---- /set irc.msgbuffer.303 weechat ----------------------------------------- +---- [[logger_plugin]] -Extension Logger -~~~~~~~~~~~~~~~~ +=== Extension Logger L'extension Logger permet de sauvegarder le contenu des tampons dans des fichiers, avec des options sur comment et quoi sauvegarder. [[logger_options]] -Options (logger.conf) -^^^^^^^^^^^^^^^^^^^^^ +==== Options (logger.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | look | /set logger.look.* | Look and feel | color | /set logger.color.* | Couleurs | file | /set logger.file.* | Options pour les fichiers de log | level | /set logger.level.* | Niveau de log par tampon (les options peuvent être ajoutées/supprimées dans la section) | mask | /set logger.mask.* | Masque de nom de fichier par tampon (les options peuvent être ajoutées/supprimées dans la section) -|======================================== +|=== Options : include::autogen/user/logger_options.txt[] [[logger_commands]] -Commandes -^^^^^^^^^ +==== Commandes include::autogen/user/logger_commands.txt[] [[logger_log_levels]] -Niveaux d'enregistrement -^^^^^^^^^^^^^^^^^^^^^^^^ +==== Niveaux d'enregistrement L'enregistrement est fait selon un niveau pour chaque tampon. Le niveau par défaut est 9 (enregistrer tous les messages affichés dans le tampon). @@ -2461,68 +2385,66 @@ Quelques exemples : * affecter le niveau 3 pour le canal IRC #weechat : ----------------------------------------- +---- /set logger.level.irc.freenode.#weechat 3 ----------------------------------------- +---- * affecter le niveau 3 pour le tampon serveur freenode : ----------------------------------------- +---- /set logger.level.irc.server.freenode 3 ----------------------------------------- +---- * affecter le niveau 3 pour tous les canaux sur le serveur freenode : ----------------------------------------- +---- /set logger.level.irc.freenode 3 ----------------------------------------- +---- * affecter le niveau 2 pour tous les tampons IRC : ----------------------------------------- +---- /set logger.level.irc 2 ----------------------------------------- +---- [[logger_filenames_masks]] -Masques de noms de fichiers -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Masques de noms de fichiers Il est possible de définir un masque de nom de fichier pour chaque tampon, et d'utiliser les variables locales du tampon pour construire le nom de fichier. Pour voir les variables du tampon courant : ----------------------------------------- +---- /buffer localvar ----------------------------------------- +---- Par exemple, sur le tampon "irc.freenode.#weechat", WeeChat cherchera un masque avec le nom de l'option, dans cet ordre : ----------------------------------------- +---- logger.mask.irc.freenode.#weechat logger.mask.irc.freenode logger.mask.irc logger.file.mask ----------------------------------------- +---- Cela signifie que vous pouvez avoir un masque spécifique pour certaines serveurs IRC ("logger.mask.irc.freenode") ou pour une extension ("logger.mask.irc"). [[logger_files_by_date]] -Fichiers de log par date -++++++++++++++++++++++++ +===== Fichiers de log par date Pour avoir des fichiers de log par date, vous pouvez utiliser des marqueurs dans le masque (voir `man strftime` pour le format), par exemple : ----------------------------------------- +---- /set logger.file.mask "%Y/%m/$plugin.$name.weechatlog" ----------------------------------------- +---- Vous obtiendrez les fichiers suivants : -........................................ +.... ~/.weechat/ |--- logs/ |--- 2010/ @@ -2533,21 +2455,20 @@ Vous obtiendrez les fichiers suivants : |--- 12/ | irc.server.freenode.weechatlog | irc.freenode.#weechat.weechatlog -........................................ +.... [[logger_irc_files_by_server_channel]] -Fichiers de log IRC par serveur et canal -++++++++++++++++++++++++++++++++++++++++ +===== Fichiers de log IRC par serveur et canal Si vous voulez un répertoire par serveur IRC et un fichier par canal dedans : ----------------------------------------- +---- /set logger.mask.irc "irc/$server/$channel.weechatlog" ----------------------------------------- +---- Vous obtiendrez les fichiers suivants : -........................................ +.... ~/.weechat/ |--- logs/ |--- irc/ @@ -2559,11 +2480,10 @@ Vous obtiendrez les fichiers suivants : | oftc.weechatlog | #chan1.weechatlog | #chan2.weechatlog -........................................ +.... [[relay_plugin]] -Extension Relay -~~~~~~~~~~~~~~~ +=== Extension Relay L'extension Relay est utilisée pour relayer des données via le réseau, en utilisant divers protocoles : @@ -2574,13 +2494,12 @@ utilisant divers protocoles : QWeeChat ou weechat-android). [[relay_options]] -Options (relay.conf) -^^^^^^^^^^^^^^^^^^^^ +==== Options (relay.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | look | /set relay.look.* | Look and feel | color | /set relay.color.* | Couleurs @@ -2588,34 +2507,31 @@ Sections : | irc | /set relay.irc.* | Options spécifiques au protocole irc (proxy irc) | port | <<command_relay_relay,/relay add>> + /set relay.port.* | Ports utilisés pour le relai (protocoles irc et weechat) (les options peuvent être ajoutées/supprimées dans la section) -|======================================== +|=== Options : include::autogen/user/relay_options.txt[] [[relay_commands]] -Commandes -^^^^^^^^^ +==== Commandes include::autogen/user/relay_commands.txt[] [[relay_password]] -Mot de passe -^^^^^^^^^^^^ +==== Mot de passe Il est fortement recommandé de définir un mot de passe pour le relai, avec la commande : ----------------------------------------- +---- /set relay.network.password "motdepasse" ----------------------------------------- +---- Ce mot de passe sera utilisé pour les protocoles 'irc' et 'weechat'. [[relay_ssl]] -SSL -^^^ +==== SSL Vous pouvez utiliser SSL en créant un certificat et clé privée et en utilisant le préfixe "ssl." dans le nom du protocole. @@ -2625,22 +2541,21 @@ Le fichier par défaut pour le certificat/clé est '~/.weechat/ssl/relay.pem' Vous pouvez créer le certificat et la clé privée avec les commandes suivantes : ----------------------------------------- +---- $ mkdir -p ~/.weechat/ssl $ cd ~/.weechat/ssl $ openssl req -nodes -newkey rsa:2048 -keyout relay.pem -x509 -days 365 -out relay.pem ----------------------------------------- +---- Si WeeChat tourne déjà, vous pouvez recharger le certificat et clé privée avec la commande : ----------------------------------------- +---- /relay sslcertkey ----------------------------------------- +---- [[relay_irc_proxy]] -IRC proxy -^^^^^^^^^ +==== IRC proxy L'extension Relay peut agir comme un proxy IRC : elle simulera un serveur IRC, et vous pourrez vous connecter sur WeeChat avec n'importe quel autre client IRC @@ -2652,45 +2567,43 @@ les serveurs. Lors de l'utilisation d'un port pour tous les serveurs, le client doit envoyer le nom interne du serveur dans la commande IRC "PASS", avec le format : ----------------------------------------- +---- PASS serveur:motdepasse ----------------------------------------- +---- Exemple : proxy IRC avec SSL pour tout serveur (le client choisira) : ----------------------------------------- +---- /relay add ssl.irc 8000 ----------------------------------------- +---- Exemple : proxy IRC sans SSL seulement pour le serveur "freenode" : ----------------------------------------- +---- /relay add irc.freenode 8000 ----------------------------------------- +---- Maintenant vous pouvez vous connecter sur le port 8000 avec n'importe quel client IRC en utilisant le mot de passe "motdepasse" (ou "freenode:motdepasse" si aucun serveur n'a été spécifié dans le relai). [[relay_weechat_protocol]] -Protocole WeeChat -^^^^^^^^^^^^^^^^^ +==== Protocole WeeChat L'extension Relay peut envoyer les données à une interface distante en utilisant le protocole WeeChat. Par exemple : ----------------------------------------- +---- /relay add weechat 9000 ----------------------------------------- +---- Maintenant vous pouvez vous connecter sur le port 9000 avec une interface distante en utilisant le mot de passe "motdepasse". [[relay_websocket]] -WebSocket -^^^^^^^^^ +==== WebSocket Le protocole WebSocket (http://tools.ietf.org/html/rfc6455[RFC 6455]) est supporté dans l'extension Relay pour tous les protocoles. @@ -2704,17 +2617,16 @@ Un WebSocket peut être ouvert dans une page HTML5 avec une seule ligne de JavaScript : [source,js] ----------------------------------------- +---- websocket = new WebSocket("ws://server.com:9000/weechat"); ----------------------------------------- +---- Le port (9000 dans l'exemple) est le port défini dans l'extension Relay. L'URI doit toujours se terminer par "/weechat" (pour les protocoles 'irc' et 'weechat'). [[rmodifier_plugin]] -Extension Rmodifier -~~~~~~~~~~~~~~~~~~~ +=== Extension Rmodifier L'extension Rmodifier vous permet de modifier les chaînes de "modifier" avec des expressions régulières. @@ -2724,32 +2636,29 @@ ou lorsque WeeChat les sauvegarde dans l'historique des commandes. Il est possible par exemple de remplacer chaque lettre de ces mots de passe par `*`. [[rmodifier_options]] -Options (rmodifier.conf) -^^^^^^^^^^^^^^^^^^^^^^^^ +==== Options (rmodifier.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | look | /set rmodifier.look.* | Look and feel | modifier | <<command_rmodifier_rmodifier,/rmodifier add>> + /set rmodifier.modifier.* | Rmodifiers -|======================================== +|=== Options : include::autogen/user/rmodifier_options.txt[] [[rmodifier_commands]] -Commandes -^^^^^^^^^ +==== Commandes include::autogen/user/rmodifier_commands.txt[] [[rmodifier_creation]] -Création d'un rmodifier -^^^^^^^^^^^^^^^^^^^^^^^ +==== Création d'un rmodifier Un rmodifier se compose de trois éléments : @@ -2790,8 +2699,7 @@ Si la ligne de commande contient : `/oper nick password` alors l'affichage sera : `/oper nick ********`. [[scripts_plugins]] -Extensions Scripts -~~~~~~~~~~~~~~~~~~ +=== Extensions Scripts WeeChat fournit 6 extensions pour scripts : Python, Perl, Ruby, Lua, Tcl et Guile (scheme). @@ -2807,68 +2715,59 @@ Pour plus d'informations sur comment écrire des scripts, ou sur l'API WeeChat pour les scripts, merci de lire le 'Le Guide pour Scripts WeeChat'. [[script_options]] -Options Script (script.conf) -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== Options Script (script.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | look | /set script.look.* | Look and feel | color | /set script.color.* | Couleurs | scripts | /set script.scripts.* | Options pour le téléchargement des scripts -|======================================== +|=== Options : include::autogen/user/script_options.txt[] [[script_commands]] -Commandes Script -^^^^^^^^^^^^^^^^ +==== Commandes Script include::autogen/user/script_commands.txt[] [[python_commands]] -Commandes Python -^^^^^^^^^^^^^^^^ +==== Commandes Python include::autogen/user/python_commands.txt[] [[perl_commands]] -Commandes Perl -^^^^^^^^^^^^^^ +==== Commandes Perl include::autogen/user/perl_commands.txt[] [[ruby_commands]] -Commandes Ruby -^^^^^^^^^^^^^^ +==== Commandes Ruby include::autogen/user/ruby_commands.txt[] [[lua_commands]] -Commandes Lua -^^^^^^^^^^^^^ +==== Commandes Lua include::autogen/user/lua_commands.txt[] [[tcl_commands]] -Commandes Tcl -^^^^^^^^^^^^^ +==== Commandes Tcl include::autogen/user/tcl_commands.txt[] [[guile_commands]] -Commandes Guile -^^^^^^^^^^^^^^^ +==== Commandes Guile include::autogen/user/guile_commands.txt[] [[xfer_plugin]] -Extension Xfer -~~~~~~~~~~~~~~ +=== Extension Xfer L'extension Xfer permet : @@ -2877,33 +2776,30 @@ L'extension Xfer permet : * le transfert de fichiers, par exemple le "DCC" via l'extension IRC [[xfer_options]] -Options (xfer.conf) -^^^^^^^^^^^^^^^^^^^ +==== Options (xfer.conf) Sections : [width="100%",cols="3m,6m,16",options="header"] -|======================================== +|=== | Section | Commande de contrôle | Description | look | /set xfer.look.* | Look and feel | color | /set xfer.color.* | Couleurs | network | /set xfer.network.* | Options réseau | file | /set xfer.file.* | Options pour les fichiers envoyés/reçus -|======================================== +|=== Options : include::autogen/user/xfer_options.txt[] [[xfer_commands]] -Commandes -^^^^^^^^^ +==== Commandes include::autogen/user/xfer_commands.txt[] [[support]] -Support -------- +== Support Avant de faire appel au support, merci de lire la documentation et la FAQ de WeeChat (la documentation est le document que vous êtes en train de lire, si |