# Guide du développeur WeeChat

Sébastien Helleu
flashcode@flashtux.org
version 4.10.0

Ce manuel documente le client de messagerie instantanée WeeChat, il fait partie de WeeChat.

La dernière version de ce document peut être téléchargée sur cette page ↗.

## 1. Introduction

WeeChat (Wee Enhanced Environment for Chat) est un client de discussion libre, rapide et léger, conçu pour différents systèmes d’exploitation.

Ce manuel documente l’intérieur de WeeChat :

- dépôts

- règles de développement

- le cœur

- les extensions

- comment contribuer à WeeChat.

## 2. Dépôts

Les dépôts de WeeChat sont dans l’organisation weechat ↗ de GitHub.

Liste des dépôts :

weechat

  dépôt principal avec le code source et la documentation

scripts

  les scripts officiels soumis sur weechat.org

weechat.org

  le code source du site de WeeChat ↗

weercd

  serveur de test IRC

qweechat

  interface Qt distante pour WeeChat.

Ce manuel documente seulement le dépôt weechat.

### 2.1. Vue d’ensemble

Les répertoires principaux de WeeChat sont :

Répertoire | Description
--- | ---
`src/` | Racine des sources.
`core/` | Fonctions du cœur : point d’entrée, structures internes.
`hook/` | Fonctions sur les "hooks".
`gui/` | Fonctions pour les tampons, fenêtres, …​ (utilisées par toutes les interfaces).
`curses/` | Interface Curses.
`headless/` | Mode sans interface (« headless »).
`normal/` | Interface Curses.
`plugins/` | API extension/script.
`alias/` | Extension Alias.
`buflist/` | Extension Buflist.
`charset/` | Extension Charset.
`exec/` | Extension Exec.
`fifo/` | Extension Fifo (tube FIFO utilisé pour envoyer des commandes à WeeChat).
`fset/` | Extension Fset (Fast Set).
`guile/` | API script Guile (scheme).
`irc/` | Extension IRC (Internet Relay Chat).
`javascript/` | API script JavaScript.
`logger/` | Extension Logger (enregistrer les messages affichés dans des fichiers).
`lua/` | API script Lua.
`perl/` | API script Perl.
`php/` | API script PHP.
`python/` | API script Python.
`relay/` | Extension Relay (proxy IRC + relai pour interfaces distantes).
`ruby/` | API script Ruby.
`script/` | Gestionnaire de scripts.
`spell/` | Extension Spell.
`tcl/` | API script Tcl.
`trigger/` | Extension Trigger.
`typing/` | Extension Typing.
`xfer/` | Extension Xfer (IRC DCC fichier/discussion).
`tests/` | Tests.
`fuzz/` | Fuzzing (tests à données aléatoires).
`core/` | Fuzzing pour les fonctions du cœur.
`unit/` | Tests unitaires.
`core/` | Tests unitaires pour les fonctions du cœur.
`hook/` | Tests unitaires pour les fonctions hook.
`gui/` | Tests unitaires pour les fonctions de l’interface.
`curses/` | Tests unitaires pour les fonctions de l’interface Curses.
`scripts/` | Tests de l’API script.
`python/` | Scripts Python pour générer et lancer les tests de l’API script.
`plugins/` | Tests unitaires pour les extensions.
`alias/` | Tests unitaires pour l’extension alias.
`irc/` | Tests unitaires pour l’extension IRC.
`logger/` | Tests unitaires pour l’extension logger.
`relay/` | Tests unitaires pour l’extension relay.
`trigger/` | Tests unitaires pour l’extension trigger.
`typing/` | Tests unitaires pour l’extension typing.
`xfer/` | Tests unitaires pour l’extension xfer.
`doc/` | Documentation.
`po/` | Fichiers de traductions (gettext).
`debian/` | Empaquetage Debian.

### 2.2. Sources

#### Cœur

Le cœur de WeeChat est situé dans les répertoires suivants :

- src/core/ : fonctions du cœur (pour manipuler des données)

- src/gui/ : fonctions pour l’interface (tampons, fenêtres, …​)

Chemin/fichier | Description
--- | ---
`core/` | Fonctions du cœur : point d’entrée, structures internes.
`core-args.c` | Paramètres de ligne de commande.
`core-arraylist.c` | Listes avec tableau (« arraylists »).
`core-backtrace.c` | Afficher une trace après un plantage.
`core-calc.c` | Calcul du résultat d’expressions.
`core-command.c` | Commandes du cœur de WeeChat.
`core-completion.c` | Complétions par défaut.
`core-config-file.c` | Gestion des fichiers de configuration.
`core-config.c` | Options de configuration du cœur de WeeChat (fichier weechat.conf).
`core-crypto.c` | Fonctions de cryptographie.
`core-debug.c` | Quelques fonctions de debug.
`core-dir.c` | Fonctions sur les répertoires/fichiers.
`core-doc.c` | Génération de fichiers pour la documentation.
`core-eval.c` | Évaluation d’expressions avec des références à des variables internes.
`core-hashtable.c` | Tables de hachage.
`core-hdata.c` | Hdata (accès direct aux données en utilisant des tables de hachage).
`core-hook.c` | Crochets ("hooks").
`core-infolist.c` | Infolists (listes avec les données des objets).
`core-input.c` | Entrée de commandes/texte.
`core-list.c` | Listes triées.
`core-log.c` | Écriture dans le fichier de log WeeChat (weechat.log).
`core-network.c` | Fonctions réseau (connexion aux serveurs/proxies).
`core-proxy.c` | Gestion des proxies.
`core-secure.c` | Fonctions pour les données sécurisées.
`core-secure-buffer.c` | Tampon pour les données sécurisées.
`core-secure-config.c` | Options des données sécurisées (fichier sec.conf).
`core-signal.c` | Fonctions sur les signaux.
`core-string.c` | Fonctions sur les chaînes de caractères.
`core-sys.c` | Fonctions système.
`core-upgrade-file.c` | Système de mise à jour interne.
`core-upgrade.c` | Mise à jour du cœur de WeeChat (tampons, lignes, historique, …​).
`core-url.c` | Transfert d’URL (en utilisant libcurl).
`core-utf8.c` | Fonctions UTF-8.
`core-util.c` | Quelques autres fonctions utilitaires.
`core-version.c` | Fonctions pour la version de WeeChat.
`weechat.c` | Fonctions principales : options de ligne de commande, démarrage.
`hook/` | Fonctions "hook".
`hook-command-run.c` | Hook "command_run".
`hook-command.c` | Hook "command".
`hook-completion.c` | Hook "completion".
`hook-config.c` | Hook "config".
`hook-connect.c` | Hook "connect".
`hook-fd.c` | Hook "fd".
`hook-focus.c` | Hook "focus".
`hook-hdata.c` | Hook "hdata".
`hook-hsignal.c` | Hook "hsignal".
`hook-info-hashtable.c` | Hook "info".
`hook-info.c` | Hook "info".
`hook-infolist.c` | Hook "infolist".
`hook-line.c` | Hook "line".
`hook-modifier.c` | Hook "modifier".
`hook-print.c` | Hook "print".
`hook-process.c` | Hook "process".
`hook-signal.c` | Hook "signal".
`hook-timer.c` | Hook "timer".
`hook-url.c` | Hook "url".
`gui/` | Fonctions pour les tampons, fenêtres, …​ (utilisées par toutes les interfaces).
`gui-bar-item.c` | Objets de barre.
`gui-bar-window.c` | Fenêtres de barre.
`gui-bar.c` | Barres.
`gui-buffer.c` | Tampons.
`gui-chat.c` | Fonctions pour la discussion (afficher un message, …​).
`gui-color.c` | Fonctions de couleur.
`gui-completion.c` | Complétion sur la ligne de commande.
`gui-cursor.c` | Mode curseur (mouvement libre du curseur).
`gui-filter.c` | Filtres.
`gui-focus.c` | Fonctions concernant le focus (pour les modes curseur et souris).
`gui-history.c` | Commandes/texte sauvés dans les tampons.
`gui-hotlist.c` | Gestion de la "hotlist" (liste des tampons avec activité).
`gui-input.c` | Fonctions d’entrée (barre "input").
`gui-key.c` | Fonctions pour le clavier.
`gui-layout.c` | Dispositions ("layouts").
`gui-line.c` | Lignes dans les tampons.
`gui-mouse.c` | Souris.
`gui-nick.c` | Fonctions pour les pseudos.
`gui-nicklist.c` | Liste de pseudos dans les tampons.
`gui-window.c` | Fenêtres.
`curses/` | Interface Curses.
`gui-curses-bar-window.c` | Affichage dans les fenêtres de barre.
`gui-curses-chat.c` | Affichage dans la zone de discussion (messages).
`gui-curses-color.c` | Fonctions pour les couleurs.
`gui-curses-key.c` | Fonctions pour le clavier (touches par défaut, lecture du clavier).
`gui-curses-main.c` | Boucle principale de WeeChat (attente des évènements clavier/réseau).
`gui-curses-mouse.c` | Souris.
`gui-curses-term.c` | Fonctions pour le terminal.
`gui-curses-window.c` | Fenêtres.
`headless/` | Mode sans interface (« headless »).
`main.c` | Point d’entrée pour le mode sans interface.
`ncurses-fake.c` | Fausse bibliothèque ncurses.
`normal/` | Interface Curses.
`main.c` | Point d’entrée pour l’interface Curses.

#### Extensions

Chemin/fichier | Description
--- | ---
`plugins/` | Racine des extensions.
`plugin.c` | Gestion des extensions (chargement/déchargement des bibliothèques C dynamiques).
`plugin-api.c` | Fonctions supplémentaires pour l’API extension (enveloppes autour des fonctions du cœur de WeeChat).
`plugin-api-info.c` | Fonctions supplémentaires info/infolist pour l’API extension.
`plugin-config.c` | Options de configuration des extensions (fichier plugins.conf).
`plugin-script.c` | Fonctions communes utilisés par les extensions pour les scripts.
`plugin-script-api.c` | Fonctions pour l’API script : enveloppes autour de quelques fonctions de l’API extension.
`plugin-script-config.c` | Options de configuration des extensions pour les scripts (fichiers python.conf, perl.conf, …​).
`weechat-plugin.h` | En-tête destiné à être distribué avec les extensions WeeChat, pour les compiler.
`alias/` | Extension Alias.
`alias.c` | Fonctions principales pour les alias.
`alias-command.c` | Commandes Alias.
`alias-completion.c` | Complétions pour Alias.
`alias-config.c` | Options de configuration des alias (fichier alias.conf).
`alias-info.c` | Info/infolists/hdata pour les alias.
`spell/` | Extension Spell.
`spell.c` | Fonctions principales pour Spell.
`spell-bar-item.c` | Objets de barre Spell.
`spell-command.c` | Commandes Spell.
`spell-completion.c` | Complétions pour Spell.
`spell-config.c` | Options de configuration pour Spell (fichier spell.conf).
`spell-info.c` | Info/infolists/hdata pour Spell.
`spell-speller.c` | Gestion des correcteurs orthographiques.
`buflist/` | Extension Buflist.
`buflist.c` | Fonctions principales de Buflist.
`buflist-bar-item.c` | Objets de barre Buflist.
`buflist-command.c` | Commandes pour Buflist.
`buflist-completion.c` | Complétions pour Buflist.
`buflist-config.c` | Options de configuration pour Buflist (fichier buflist.conf).
`buflist-info.c` | Info/infolists/hdata pour Buflist.
`buflist-mouse.c` | Actions souris pour Buflist.
`charset/` | Extension Charset.
`charset.c` | Fonctions pour Charset.
`exec/` | Extension Exec.
`exec.c` | Fonctions principales de Exec.
`exec-buffer.c` | Tampon Exec.
`exec-command.c` | Commandes pour Exec.
`exec-completion.c` | Complétions pour Exec.
`exec-config.c` | Options de configuration pour Exec (fichier exec.conf).
`fifo/` | Extension Fifo.
`fifo.c` | Fonctions principales de Fifo.
`fifo-command.c` | Commandes pour Fifo.
`fifo-config.c` | Options de configuration pour Fifo (fichier fifo.conf).
`fifo-info.c` | Info/infolists/hdata pour Fifo.
`fset/` | Extension Fset.
`fset.c` | Fonctions principales de Fset.
`fset-bar-item.c` | Objets de barre Fset.
`fset-buffer.c` | Tampon Fset.
`fset-command.c` | Commandes pour Fset.
`fset-completion.c` | Complétions pour Fset.
`fset-config.c` | Options de configuration pour Fset (fichier fset.conf).
`fset-info.c` | Info/infolists/hdata pour Fset.
`fset-mouse.c` | Actions souris pour Fset.
`fset-option.c` | Gestion des options Fset.
`guile/` | Extension Guile (scheme).
`weechat-guile.c` | Fonctions principales pour Guile (chargement/déchargement des scripts, exécution de code Guile).
`weechat-guile-api.c` | Fonctions de l’API script Guile.
`irc/` | Extension IRC (Internet Relay Chat).
`irc.c` | Fonctions principales IRC.
`irc-bar-item.c` | Objets de barre IRC.
`irc-batch.c` | Évènements batch IRC.
`irc-buffer.c` | Tampons IRC.
`irc-channel.c` | Canaux IRC.
`irc-color.c` | Couleurs IRC.
`irc-command.c` | Commandes IRC.
`irc-completion.c` | Complétions IRC.
`irc-config.c` | Options de configuration IRC (fichier irc.conf).
`irc-ctcp.c` | CTCP IRC.
`irc-debug.c` | Fonctions de debug IRC.
`irc-ignore.c` | Ignore IRC.
`irc-info.c` | Info/infolists/hdata pour IRC.
`irc-input.c` | Entrée de commandes/texte.
`irc-join.c` | Fonctions pour les listes de canaux à rejoindre.
`irc-list.c` | Tampon pour la réponse à la commande /list.
`irc-message.c` | Fonctions pour manipuler les messages IRC.
`irc-mode.c` | Fonctions pour les modes de canal/pseudo.
`irc-modelist.c` | Listes de modes de canaux IRC (+b, +e, +I, …​).
`irc-msgbuffer.c` | Tampon cible pour les messages IRC.
`irc-nick.c` | Pseudos IRC.
`irc-notify.c` | Listes de notification IRC.
`irc-protocol.c` | Protocole IRC (RFCs 1459/2810/2811/2812/2813/7194).
`irc-raw.c` | Tampon des données brutes IRC.
`irc-redirect.c` | Redirection de la sortie des commandes IRC.
`irc-sasl.c` | Authentification SASL avec le serveur IRC.
`irc-server.c` | Communication avec le serveur IRC.
`irc-tag.c` | Fonctions pour manipuler les étiquettes de message IRC.
`irc-typing.c` | Statut d’écriture.
`irc-upgrade.c` | Sauvegarde/restauration des données IRC lors de la mise à jour de WeeChat.
`javascript/` | Extension JavaScript.
`weechat-js.cpp` | Fonctions principales pour JavaScript (chargement/déchargement des scripts, exécution de code JavaScript).
`weechat-js-api.cpp` | Fonctions de l’API script JavaScript.
`weechat-js-v8.cpp` | Fonctions JavaScript v8.
`logger/` | Extension Logger.
`logger.c` | Fonctions principales pour Logger.
`logger-backlog.c` | Fonctions de backlog pour Logger.
`logger-buffer.c` | Gestion des listes de tampons pour Logger.
`logger-command.c` | Commandes de Logger.
`logger-config.c` | Options de configuration pour Logger (fichier logger.conf).
`logger-info.c` | Info/infolists/hdata pour Logger.
`logger-tail.c` | Fonctions pour obtenir les dernières lignes d’un fichier.
`lua/` | Extension Lua.
`weechat-lua.c` | Fonctions principales pour Lua (chargement/déchargement des scripts, exécution de code Lua).
`weechat-lua-api.c` | Fonctions de l’API script Lua.
`perl/` | Extension Perl.
`weechat-perl.c` | Fonctions principales pour Perl (chargement/déchargement des scripts, exécution de code Perl).
`weechat-perl-api.c` | Fonctions de l’API script Perl.
`php/` | Extension PHP.
`weechat-php.c` | Fonctions principales pour PHP (chargement/déchargement des scripts, exécution de code PHP).
`weechat-php-api.c` | Fonctions de l’API script PHP.
`python/` | Extension Python.
`weechat-python.c` | Fonctions principales pour Python (chargement/déchargement des scripts, exécution de code Python).
`weechat-python-api.c` | Fonctions de l’API script Python.
`relay/` | Extension Relay (proxy IRC et relai pour des interfaces distantes).
`relay.c` | Fonctions principales de Relay.
`relay-auth.c` | Authentification des clients.
`relay-bar-item.c` | Objets de barre Relay.
`relay-buffer.c` | Tampon Relay.
`relay-client.c` | Clients du relai.
`relay-command.c` | Commandes de Relay.
`relay-completion.c` | Complétions de Relay.
`relay-config.c` | Options de configuration pour Relay (fichier relay.conf).
`relay-http.c` | Fonctions HTTP.
`relay-info.c` | Info/infolists/hdata pour Relay.
`relay-network.c` | Fonctions de réseau pour Relay.
`relay-raw.c` | Tampon des données brutes de Relay.
`relay-remote.c` | Relai distant.
`relay-server.c` | Serveur Relay.
`relay-upgrade.c` | Sauvegarde/restauration des données Relay lors de la mise à jour de WeeChat.
`relay-websocket.c` | Fonctions pour le serveur WebSocket (RFC 6455).
`api/` | Relai pour les interfaces distantes (en utilisant une API REST HTTP).
`relay-api.c` | Fonctions principales pour l’API REST HTTP.
`relay-api-msg.c` | Envoi de messages JSON aux clients.
`relay-api-protocol.c` | Protocole HTTP REST API.
`remote/` | Relai distant.
`relay-remote-event.c` | Traitement des évènements reçus du relai distant.
`relay-remote-network.c` | Fonctions réseau pour le relai distant.
`irc/` | Proxy IRC.
`relay-irc.c` | Fonctions principales pour le proxy IRC.
`weechat/` | Relai pour les interfaces distantes (en utilisant le protocole binaire "weechat").
`relay-weechat.c` | Relai pour les interfaces distantes (fonctions principales).
`relay-weechat-msg.c` | Envoi de messages binaires aux clients.
`relay-weechat-nicklist.c` | Fonctions pour la liste de pseudos.
`relay-weechat-protocol.c` | Lecture des commandes des clients.
`ruby/` | Extension Ruby.
`weechat-ruby.c` | Fonctions principales pour Ruby (chargement/déchargement des scripts, exécution de code Ruby).
`weechat-ruby-api.c` | Fonctions de l’API script Ruby.
`script/` | Gestionnaire de scripts.
`script.c` | Fonctions principales du gestionnaire de scripts.
`script-action.c` | Actions sur les scripts (chargement/déchargement, installation/suppression, …​).
`script-buffer.c` | Tampon pour le gestionnaire de scripts.
`script-command.c` | Commandes pour le gestionnaire de scripts.
`script-completion.c` | Complétions pour le gestionnaire de scripts.
`script-config.c` | Options de configuration pour le gestionnaire de scripts (fichier script.conf).
`script-info.c` | Info/infolists/hdata pour le gestionnaire de scripts.
`script-mouse.c` | Actions souris pour le gestionnaire de scripts.
`script-repo.c` | Téléchargement et lecture du dépôt de scripts.
`tcl/` | Extension Tcl.
`weechat-tcl.c` | Fonctions principales pour Tcl (chargement/déchargement des scripts, exécution de code Tcl).
`weechat-tcl-api.c` | Fonctions de l’API script Tcl.
`trigger/` | Extension Trigger.
`trigger.c` | Fonctions principales de Trigger.
`trigger-buffer.c` | Tampon Trigger.
`trigger-callback.c` | Fonctions de rappel de Trigger.
`trigger-command.c` | Commandes pour Trigger.
`trigger-completion.c` | Complétions pour Trigger.
`trigger-config.c` | Options de configuration pour Trigger (fichier trigger.conf).
`typing/` | Extension Typing.
`typing.c` | Fonctions principales de Typing.
`typing-bar-item.c` | Objets de barre Typing.
`typing-config.c` | Options de configuration pour Typing (fichier typing.conf).
`typing-status.c` | Statut d’écriture de messages sur les tampons.
`xfer/` | Extension Xfer (IRC DCC fichier/discussion).
`xfer.c` | Fonctions principales de Xfer.
`xfer-buffer.c` | Tampon Xfer.
`xfer-chat.c` | Discussion DCC.
`xfer-command.c` | Commandes pour Xfer.
`xfer-completion.c` | Complétions pour Xfer.
`xfer-config.c` | Options de configuration pour Xfer (fichier xfer.conf).
`xfer-dcc.c` | Transfert de fichier par DCC.
`xfer-file.c` | Fonctions pour les fichiers dans Xfer.
`xfer-info.c` | Info/infolists/hdata pour Xfer.
`xfer-network.c` | Fonctions réseau pour Xfer.
`xfer-upgrade.c` | Sauvegarde/restauration des données Xfer lors de la mise à jour de WeeChat.

#### Tests

Chemin/fichier | Description
--- | ---
`tests/` | Racine des tests.
`fuzz/` | Racine du fuzzing (tests à données aléatoires).
`ossfuzz.sh` | Script de construction pour OSS-Fuzz ↗.
`core/` | Racine du fuzzing pour le cœur.
`calc-fuzzer.c` | Fuzzing : calcul d’expressions.
`crypto-fuzzer.c` | Fuzzing : fonctions cryptographiques.
`secure-fuzzer.c` | Fuzzing : données sécurisées.
`string-fuzzer.c` | Fuzzing : chaînes.
`utf8-fuzzer.c` | Fuzzing : UTF-8.
`util-fuzzer.c` | Fuzzing : fonctions utiles.
`unit/` | Racine des tests unitaires.
`tests.cpp` | Programme utilisé pour lancer tous les tests.
`tests-record.cpp` | Enregistrement et recherche dans les messages affichés.
`core/` | Racine des tests unitaires pour le cœur.
`test-core-arraylist.cpp` | Tests : listes avec tableau (« arraylists »).
`test-core-calc.cpp` | Tests : calcul d’expressions.
`test-core-command.cpp` | Tests : commandes.
`test-core-config-file.cpp` | Tests : fichiers de configuration.
`test-core-crypto.cpp` | Tests : fonctions cryptographiques.
`test-core-dir.cpp` | Tests : répertoires/fichiers.
`test-core-eval.cpp` | Tests : évaluation d’expressions.
`test-core-hashtable.cpp` | Tests : tables de hachage.
`test-core-hdata.cpp` | Tests : hdata.
`test-core-hook.cpp` | Tests : hooks.
`test-core-infolist.cpp` | Tests : infolists.
`test-core-input.cpp` | Tests : fonctions d’entrée.
`test-core-list.cpp` | Tests : listes.
`test-core-network.cpp` | Tests : fonctions réseau.
`test-core-secure.cpp` | Tests : données sécurisées.
`test-core-signal.cpp` | Tests : signaux.
`test-core-string.cpp` | Tests : chaînes.
`test-core-sys.cpp` | Tests : fonctions système.
`test-core-url.cpp` | Tests : URLs.
`test-core-utf8.cpp` | Tests : UTF-8.
`test-core-util.cpp` | Tests : fonctions utiles.
`hook/` | Racine des tests pour les hooks.
`test-hook-command.cpp` | Tests : hooks "command".
`test-hook-command-run.cpp` | Tests : hooks "command_run".
`test-hook-completion.cpp` | Tests : hooks "completion".
`test-hook-config.cpp` | Tests : hooks "config".
`test-hook-connect.cpp` | Tests : hooks "connect".
`test-hook-fd.cpp` | Tests : hooks "fd".
`test-hook-focus.cpp` | Tests : hooks "focus".
`test-hook-hdata.cpp` | Tests : hooks "hdata".
`test-hook-hsignal.cpp` | Tests : hooks "hsignal".
`test-hook-info-hashtable.cpp` | Tests : hooks "info_hashtable".
`test-hook-info.cpp` | Tests : hooks "info".
`test-hook-infolist.cpp` | Tests : hooks "infolist".
`test-hook-line.cpp` | Tests : hooks "line".
`test-hook-modifier.cpp` | Tests : hooks "modifier".
`test-hook-print.cpp` | Tests : hooks "print".
`test-hook-process.cpp` | Tests : hooks "process".
`test-hook-signal.cpp` | Tests : hooks "signal".
`test-hook-timer.cpp` | Tests : hooks "timer".
`test-hook-url.cpp` | Tests : hooks "url".
`gui/` | Racine des tests unitaires pour les interfaces.
`test-gui-bar-item-custom.cpp` | Tests : fonctions d’objets de barre personnalisés.
`test-gui-bar-item.cpp` | Tests : fonctions d’objets de barre.
`test-gui-bar-window.cpp` | Tests : fonctions de fenêtres de barre.
`test-gui-bar.cpp` | Tests : fonctions de barres.
`test-gui-buffer.cpp` | Tests : fonctions de tampons.
`test-gui-chat.cpp` | Tests : fonctions de discussion.
`test-gui-color.cpp` | Tests : couleurs.
`test-gui-filter.cpp` | Tests : filtres.
`test-gui-hotlist.cpp` | Tests : fonctions hotlist.
`test-gui-input.cpp` | Tests : fonctions d’entrée.
`test-gui-key.cpp` | Tests : touches.
`test-gui-line.cpp` | Tests : lignes.
`test-gui-nick.cpp` | Tests : pseudos.
`test-gui-nicklist.cpp` | Tests : fonctions de liste de pseudos.
`curses/` | Racine des tests unitaires pour l’interface Curses.
`test-gui-curses-mouse.cpp` | Tests : souris (interface Curses).
`scripts/` | Racine des tests de l’API script.
`test-scripts.cpp` | Programme utilisé pour lancer les tests de l’API script.
`python/` | Scripts Python pour générer et lancer les tests de l’API script.
`testapigen.py` | Script Python générant des scripts dans tous les languages pour tester l’API script.
`testapi.py` | Script Python avec les tests API, utilisé par le script testapigen.py.
`unparse.py` | Conversion de code Python vers d’autres langages, utilisé par le script testapigen.py.
`plugins/` | Racine des tests unitaires pour les extensions.
`test-plugin-api-info.cpp` | Tests : fonctions info de l’API extension.
`test-plugin-config.cpp` | Tests : fonctions config de l’extension.
`test-plugins.cpp` | Tests : extensions.
`alias/` | Racine des tests unitaires pour l’extension alias.
`test-alias.cpp` | Tests : alias.
`irc/` | Racine des tests unitaires pour l’extension IRC.
`test-irc-batch.cpp` | Tests : évènements batch IRC.
`test-irc-buffer.cpp` | Tests : tampons IRC.
`test-irc-channel.cpp` | Tests : canaux IRC.
`test-irc-color.cpp` | Tests : couleurs IRC.
`test-irc-command.cpp` | Tests : commandes IRC.
`test-irc-config.cpp` | Tests : configuration IRC.
`test-irc-ctcp.cpp` | Tests : CTCP IRC.
`test-irc-ignore.cpp` | Tests : ignores IRC.
`test-irc-info.cpp` | Tests : infos IRC.
`test-irc-join.cpp` | Tests : fonctions de join IRC.
`test-irc-list.cpp` | Tests : tampon IRC pour la réponse à la commande /list.
`test-irc-message.cpp` | Tests : messages IRC.
`test-irc-mode.cpp` | Tests : modes IRC.
`test-irc-nick.cpp` | Tests : pseudos IRC.
`test-irc-protocol.cpp` | Tests : protocole IRC.
`test-irc-sasl.cpp` | Tests : authentification SASL avec le protocole IRC.
`test-irc-server.cpp` | Tests : serveur IRC.
`test-irc-tag.cpp` | Tests : étiquettes des messages IRC.
`logger/` | Racine des tests unitaires pour l’extension logger.
`test-logger.cpp` | Tests : logger.
`test-logger-backlog.cpp` | Tests : backlog logger.
`test-logger-tail.cpp` | Tests : fonctions "tail".
`relay/` | Racine des tests unitaires pour l’extension Relay.
`test-relay-auth.cpp` | Tests : authentification des clients.
`test-relay-bar-item.cpp` | Tests : objets de barre pour l’extension Relay.
`test-relay-http.cpp` | Tests : fonctions HTTP pour l’extension Relay.
`test-relay-raw.cpp` | Tests : fonctions sur les messages bruts pour l’extension Relay.
`test-relay-remote.cpp` | Tests : fonctions remote pour l’extension Relay.
`test-relay-websocket.cpp` | Tests : fonctions websocket pour l’extension Relay.
`api/` | Racine des tests unitaires pour le protocole relay "api".
`test-relay-api.cpp` | Tests : protocole relay "api" : fonctions générales.
`test-relay-api-msg.cpp` | Tests : protocole relay "api" : messages.
`test-relay-api-protocol.cpp` | Tests : protocole relay "api" : protocole.
`remote/` | Tests : protocole relay "api" : fonctions "remote" : évènement.
`test-relay-remote-event.cpp` | Tests : protocole relay "api" : fonctions "remote" : réseau.
`test-relay-remote-network.cpp` | Tests: Relay "api" protocol: remote network.
`irc/` | Racine des tests unitaires pour le protocole relay "irc".
`test-relay-irc.cpp` | Tests : protocole relay "irc".
`trigger/` | Racine des tests unitaires pour l’extension trigger.
`test-trigger.cpp` | Tests : triggers.
`test-trigger-config.cpp` | Tests : configuration trigger.
`typing/` | Racine des tests unitaires pour l’extension typing.
`test-typing.cpp` | Tests : typing.
`test-typing-status.cpp` | Tests : statut d’écriture.
`xfer/` | Racine des tests unitaires pour l’extension Xfer.
`test-xfer-file.cpp` | Tests : fonctions sur les fichiers.
`test-xfer-network.cpp` | Tests : fonctions réseau.

### 2.3. Documentation / traductions

Fichiers de documentation :

Chemin/fichier | Description
--- | ---
`doc/` | Documentation.
`docinfo.html` | Style Asciidoctor.
`XX/` | Documentation pour la langue XX (langues : en, fr, de, it, …​).
`weechat.1.XX.adoc` | Page de manuel (`man weechat`).
`weechat_dev.XX.adoc` | Guide du développeur ↗ (ce document).
`weechat_faq.XX.adoc` | FAQ ↗ (questions fréquemment posées).
`weechat_plugin_api.XX.adoc` | Référence API extension ↗.
`weechat_quickstart.XX.adoc` | Guide de démarrage ↗.
`weechat_relay_api.XX.adoc` | Protocole relay "api" ↗ (pour les interfaces distantes).
`weechat_relay_weechat.XX.adoc` | Protocole relay "weechat" ↗ (pour les interfaces distantes).
`weechat_scripting.XX.adoc` | Guide pour scripts ↗.
`weechat_user.XX.adoc` | Guide utilisateur ↗.
`includes/` | Fichiers inclus dans la documentation.
`cmdline_options.XX.adoc` | Options de ligne de commande (fichier inclus dans les pages de manuel et le guide utilisateur).
`man.XX.adoc` | Parties des pages de manuel : options d’extension, fichiers et copyright.

Les traductions pour WeeChat et les extensions sont effectuées avec gettext, les fichiers sont dans le répertoire po/ :

Chemin/fichier | Description
--- | ---
`po/` | Fichiers de traduction (gettext).
`XX.po` | Traductions pour la langue XX (fr, de, it, …​), la langue par défaut est l’anglais.
`weechat.pot` | Modèle pour les traductions (automatiquement généré).

## 3. Règles de développement

### 3.1. Règles générales

- Dans le code source, vos commentaires, noms de variables, …​ doivent être écrits en anglais uniquement (aucune autre langue n’est autorisée).

- Utilisez un en-tête de copyright dans chaque nouveau fichier source avec :

  - la date

  - le nom

  - l’e-mail

  - la licence

  - une brève description du fichier (une seule ligne).

Le copyright et la licence doivent être définis en utilisant SPDX (System Package Data Exchange), en suivant les recommandations de REUSE Software (voir la spécification REUSE ↗).

Tous les fichiers du dépôt doivent avoir un copyright et une licence valide.
Lorsque l’information ne peut pas être mise dans le fichier lui-même, vous pouvez utiliser le fichier REUSE.toml à la racine du projet.

Exemple en C :

    /*
     * SPDX-FileCopyrightText: 2026 Your Name <your@email.com>
     *
     * SPDX-License-Identifier: GPL-3.0-or-later
     *
     * This file is part of WeeChat, the extensible chat client.
     *
     * WeeChat is free software; you can redistribute it and/or modify
     * it under the terms of the GNU General Public License as published by
     * the Free Software Foundation; either version 3 of the License, or
     * (at your option) any later version.
     *
     * WeeChat is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     * GNU General Public License for more details.
     *
     * You should have received a copy of the GNU General Public License
     * along with WeeChat.  If not, see <https://www.gnu.org/licenses/>.
     */

    /* Core functions for WeeChat */

### 3.2. Style C

Quelques règles basiques que vous devez suivre quand vous écrivez du code C :

- Utilisez 4 espaces pour l’indentation (pas de tabulations).

- Essayez de ne pas dépasser 80 caractères par ligne, sauf si cela est nécessaire pour améliorer la lisibilité.

- Utilisez les commentaires `/* comment */` (pas de style C99 comme `// comment`).

- Ajoutez un commentaire avant chaque fonction, pour expliquer ce qu’elle fait (utilisez toujours un commentaire multi-lignes, même si la description est très courte).

Exemple :

    /*
     * Check if a string with boolean value is valid.
     *
     * Return:
     *   1: boolean value is valid
     *   0: boolean value is NOT valid
     */

    int
    foo ()
    {
        int i;

        /* one line comment */
        i = 1;

        /*
         * multi-line comment: this is a very long description about next block
         * of code
         */
        i = 2;
        printf ("%d\n", i);
    }

- Utilisez des noms de variable explicites, par exemple "nicks_count" au lieu de "n" ou "nc". Exception : dans les boucles `for`, où les variables comme "i" ou "n" sont OK.

- Initialisez les variables locales après la déclaration, dans le corps de la fonction, exemple :

    void
    foo ()
    {
        int nick_count, buffer_count;

        nick_count = 0;
        buffer_count = 1;
        /* ... */
    }

- Utilisez des parenthèses pour montrer explicitement comment l’expression est évaluée, même si cela n’est pas obligatoire, par exemple écrivez `x + (y * z)` au lieu de `x + y * z`.

- Disposez les accolades `{ }` seules sur la ligne, et indentez les avec le nombre d’espaces utilisés sur la ligne au dessus de l’accolade ouvrante (le `if` dans l’exemple) :

    if (nicks_count == 1)
    {
        /* something */
    }

- Utilisez des lignes vides pour séparer différents blocs dans les fonctions, et si possible ajoutez un commentaire pour chacun, comme ceci :

    /*
     * Sends a message from out queue.
     */

    void
    irc_server_outqueue_send (struct t_irc_server *server)
    {
        /* ... */

        /* send signal with command that will be sent to server */
        irc_server_send_signal (server, "irc_out",
                                server->outqueue[priority]->command,
                                server->outqueue[priority]->message_after_mod,
                                NULL);
        tags_to_send = irc_server_get_tags_to_send (server->outqueue[priority]->tags);
        irc_server_send_signal (server, "irc_outtags",
                                server->outqueue[priority]->command,
                                server->outqueue[priority]->message_after_mod,
                                (tags_to_send) ? tags_to_send : "");
        if (tags_to_send)
            free (tags_to_send);

        /* send command */
        irc_server_send (server, server->outqueue[priority]->message_after_mod,
                         strlen (server->outqueue[priority]->message_after_mod));
        server->last_user_message = time_now;

        /* start redirection if redirect is set */
        if (server->outqueue[priority]->redirect)
        {
            irc_redirect_init_command (server->outqueue[priority]->redirect,
                                       server->outqueue[priority]->message_after_mod);
        }

        /* ... */
    }

- Indentez les conditions `if`, et utilisez des parenthèses autour des conditions avec un opérateur (pas nécessaire pour un booléen simple), comme ceci :

    if (something)
    {
        /* something */
    }
    else
    {
        /* something else */
    }

    if (my_boolean1 && my_boolean2 && (i == 10)
        && ((buffer1 != buffer2) || (window1 != window2)))
    {
        /* something */
    }
    else
    {
        /* something else */
    }

- Indentez les `switch` comme ceci :

    switch (string[0])
    {
        case 'A':  /* first case */
            foo ("abc", "def");
            break;
        case 'B':  /* second case */
            bar (1, 2, 3);
            break;
        default:  /* other cases */
            baz ();
            break;
    }

- Utilisez `typedef` pur les prototypes de fonctions mais pas pour les structures :

    typedef int (t_hook_callback_fd)(void *data, int fd);

    struct t_hook_fd
    {
        t_hook_callback_fd *callback;      /* fd callback                       */
        int fd;                            /* socket or file descriptor         */
        int flags;                         /* fd flags (read,write,..)          */
        int error;                         /* contains errno if error occurred  */
                                           /* with fd                           */
    };

    /* ... */

    struct t_hook_fd *new_hook_fd;

    new_hook_fd = malloc (sizeof (*new_hook_fd));

- Ce code Lisp peut être utilisé dans votre ~/.emacs.el pour indenter correctement si vous utilisez l’éditeur de texte Emacs :

    (add-hook 'c-mode-common-hook
              '(lambda ()
                 (c-toggle-hungry-state t)
                 (c-set-style "k&r")
                 (setq c-basic-offset 4)
                 (c-tab-always-indent t)
                 (c-set-offset 'case-label '+)))

### 3.3. Style Python

Voir PEP 8 ↗.

## 4. Intérieur du cœur

### 4.1. Conventions pour les noms

#### Fichiers

Les noms de fichiers sont composés de lettres et tirets, avec le format : xxx-yyyyy.[ch], où xxx est le répertoire/composant (peut être une abréviation) et yyyyy un nom pour le fichier.

Le fichier principal d’un répertoire peut avoir le même nom que le répertoire, par exemple irc.c pour l’extension irc.

Exemples :

Répertoire | Fichiers
--- | ---
`src/core/` | weechat.c, core-backtrace.c, core-command.c, …​
`src/gui/` | gui-bar.c, gui-bar-item.c, gui-bar-window.c, …​
`src/gui/curses/` | gui-curses-bar.c, gui-curses-bar-window.c, gui-curses-chat.c, …​
`src/plugins/` | plugin.c, plugin-api.c, plugin-api-info.c, plugin-config.c, plugin-script.c, …​
`src/plugins/irc/` | irc.c, irc-bar-item.c, irc-buffer.c, …​
`src/plugins/python/` | weechat-python.c, weechat-python-api.c, …​

Les en-têtes des fichiers C doivent avoir le même nom que le fichier, par exemple core-command.h pour le fichier core-command.c.

#### Structures

Les structures ont le nom t_X_Y ou t_X_Y_Z :

- X : répertoire/composant (peut être une abréviation)

- Y : fin du nom de fichier

- Z : nom de la structure (facultatif)

Exemple : un pseudo IRC (de src/plugins/irc/irc-nick.h) :

    struct t_irc_nick
    {
        char *name;                     /* nickname                              */
        char *host;                     /* full hostname                         */
        char *prefixes;                 /* string with prefixes enabled for nick */
        char prefix[2];                 /* current prefix (higher prefix set in  */
                                        /* prefixes)                             */
        int away;                       /* 1 if nick is away                     */
        char *color;                    /* color for nickname in chat window     */
        struct t_irc_nick *prev_nick;   /* link to previous nick on channel      */
        struct t_irc_nick *next_nick;   /* link to next nick on channel          */
    };

#### Variables

Les variables globales (en dehors des fonctions) ont le nom X_Y_Z :

- X : répertoire/composant (peut être une abréviation)

- Y : fin du nom de fichier

- Z : nom de la variable

Exception : pour les variables des derniers éléments d’une liste, le nom est last_X (où X est le nom de la variable, en utilisant le singulier).

Exemple : fenêtres (de src/gui/gui-window.c) :

    struct t_gui_window *gui_windows = NULL;        /* first window             */
    struct t_gui_window *last_gui_window = NULL;    /* last window              */
    struct t_gui_window *gui_current_window = NULL; /* current window           */

Il n’y a pas de convention pour les variables locales (dans les fonctions). La seule recommandation est que le nom soit explicite (et pas trop court).
Cependant, les pointeurs vers les structures sont souvent nommés ptr_xxxx, par exemple un pointeur sur struct t_gui_buffer * sera : *ptr_buffer.

#### Fonctions

La convention pour les noms des fonctions est le même que celui des variables.

Exemple : création d’une nouvelle fenêtre (de src/gui/gui-window.c) :

    /*
     * Create a new window.
     *
     * Return pointer to new window, NULL if error.
     */

    struct t_gui_window *
    gui_window_new (struct t_gui_window *parent_window, struct t_gui_buffer *buffer,
                    int x, int y, int width, int height,
                    int width_pct, int height_pct)
    {
        /* ... */

        return new_window;
    }

### 4.2. Thread unique

WeeChat a un seul thread. Cela signifie que chaque partie du code doit s’exécuter très rapidement, et que les appels aux fonctions comme `sleep` sont strictement interdits (cela est vrai pour le cœur de WeeChat mais aussi les extensions et les scripts).

Si pour une raison quelconque vous devez attendre un peu, utilisez `hook_timer` avec une fonction de rappel.

### 4.3. Listes doublement chaînées

La plupart des listes WeeChat sont doublement chaînées : chaque nœud a un pointeur vers le nœud précédent/suivant.

Exemple : liste des tampons (de src/gui/gui-buffer.h) :

    struct t_gui_buffer
    {
        /* data */

        /* ... */

        struct t_gui_buffer *prev_buffer;  /* link to previous buffer           */
        struct t_gui_buffer *next_buffer;  /* link to next buffer               */
    };

Et les deux pointeurs vers la tête et la fin de liste :

    struct t_gui_buffer *gui_buffers = NULL;           /* first buffer          */
    struct t_gui_buffer *last_gui_buffer = NULL;       /* last buffer           */

### 4.4. Codes couleur dans les chaînes

WeeChat utilise ses propres codes couleur dans les chaînes pour afficher les attributs (gras, souligné, …​) et les couleurs à l’écran.

Tous les attributs/couleurs sont préfixés par un caractère dans la chaîne, qui peuvent être :

- 0x19 : code couleur (suivi par un/des code(s) couleur)

- 0x1A : activer un attribut (suivi par un attribut brut sur un caractère)

- 0x1B : supprimer un attribut (suivi par un attribut brut sur un caractère)

- 0x1C : réinitialiser (rien après)

Les couleurs possibles sont :

- couleur standard : attributs facultatifs + nombre sur 2 digits

- couleur étendue : `@` + attributs facultatifs + nombre sur 5 digits

Dans le tableau qui suit, les conventions suivantes sont utilisées :

- `STD` : couleur standard (2 digits)

- `(ATTR)STD` : couleur standard avec des attributs facultatifs (attributs + 2 digits)

- `EXT` : couleur étendue (`@` + 5 digits)

- `(ATTR)EXT` : couleur étendue avec des attributs facultatifs (`@` + attributs + 5 digits)

- `(ATTR)` : un ou plusieurs caractères d’attribut :

  - `%` : clignotement

  - `.` : "dim" (demi-intensité)

  - `*` : gras

  - `!` : vidéo inverse

  - `/` : italique

  - `_` : souligné

  - `|` : garder les attributs

- `(a)` : un caractère d’attribut brut :

  - 0x01 : gras

  - 0x02 : vidéo inverse

  - 0x03 : italique

  - 0x04 : souligné

  - 0x05 : clignotement

  - 0x06 : "dim" (demi-intensité)

Toutes les combinaisons sont résumées dans ce tableau :

Code | Exemple | Aires | Description
--- | --- | --- | ---
19 + `STD` | 19 `01` | chat + barres | Définir les attributs et la couleur en utilisant une option, voir le tableau ci-dessous.
19 + `EXT` | 19 `@00001` | chat | Définir une couleur avec la paire ncurses (utilisé seulement sur le tampon `/color`).
19 + `F` + `(ATTR)STD` | 19 `F*05` | chat + barres | Définir la couleur de texte (couleur WeeChat).
19 + `F` + `(ATTR)EXT` | 19 `F@00214` | chat + barres | Définir la couleur de texte (couleur étendue).
19 + `B` + `STD` | 19 `B05` | chat + barres | Définir la couleur de fond (couleur WeeChat).
19 + `B` + `EXT` | 19 `B@00124` | chat + barres | Définir le couleur de fond (couleur étendue).
19 + `*` + `(ATTR)STD` | 19 `*05` | chat + barres | Définir la couleur de texte (couleur WeeChat).
19 + `*` + `(ATTR)EXT` | 19 `*@00214` | chat + barres | Définir la couleur de texte (couleur étendue).
19 + `*` + `(ATTR)STD` + `,` + `STD` (1) | 19 `*08,05` | chat + barres | Définir la couleur de texte/fond (couleurs WeeChat).
19 + `*` + `(ATTR)STD` + `,` + `EXT` (1) | 19 `*01,@00214` | chat + barres | Définir la couleur de texte (couleur WeeChat) et de fond (couleur étendue).
19 + `*` + `(ATTR)EXT` + `,` + `STD` (1) | 19 `*@00214,05` | chat + barres | Définir la couleur de texte (couleur étendue) et de fond (couleur WeeChat).
19 + `*` + `(ATTR)EXT` + `,` + `EXT` (1) | 19 `*@00214,@00017` | chat + barres | Définir la couleur de texte/fond (couleurs étendues).
19 + `*` + `(ATTR)STD` + `~` + `STD` | 19 `*08~05` | chat + barres | Définir la couleur de texte/fond (couleurs WeeChat).
19 + `*` + `(ATTR)STD` + `~` + `EXT` | 19 `*01~@00214` | chat + barres | Définir la couleur de texte (couleur WeeChat) et de fond (couleur étendue).
19 + `*` + `(ATTR)EXT` + `~` + `STD` | 19 `*@00214~05` | chat + barres | Définir la couleur de texte (couleur étendue) et de fond (couleur WeeChat).
19 + `*` + `(ATTR)EXT` + `~` + `EXT` | 19 `*@00214~@00017` | chat + barres | Définir la couleur de texte/fond (couleurs étendues).
19 + `b` + `F` | 19 `bF` | barres | Définir la couleur de texte de la barre.
19 + `b` + `D` | 19 `bD` | barres | Définir la couleur du délimiteur de la barre.
19 + `b` + `B` | 19 `bB` | barres | Définir la couleur de fond de la barre.
19 + `b` + `_` | 19 `b_` | barre input | Caractère de démarrage dans l’entrée (utilisé seulement dans l’objet "input_text").
19 + `b` + `-` | 19 `b-` | barre input | Caractère de démarrage caché dans l’entrée (utilisé seulement dans l’objet "input_text").
19 + `b` + `#` | 19 `b#` | barre input | Caractère de déplacement du curseur (utilisé seulement dans l’objet "input_text").
19 + `b` + `i` | 19 `bi` | barres | Début d’objet.
19 + `b` + `l` (lower L) | 19 `bl` | barres | Ligne de démarrage d’objet.
19 + `E` | 19 `E` | chat + barres | Texte mis en valeur (WeeChat ≥ 0.4.2).
19 + 1C | 19 1C | chat + barres | Réinitialiser la couleur (garder les attributs).
1A + `(a)` | 1A 01 | chat + barres | Activer un attribut.
1B + `(a)` | 1B 01 | chat + barres | Supprimer un attribut.
1C | 1C | chat + barres | Réinitialiser les attributs et la couleur.

Note

(1) L’utilisation de virgule comme séparateur était utilisé jusqu’à WeeChat 2.5.
Avec WeeChat WeeChat ≥ 2.6, un tilde est utilisé pour séparer la couleur du texte et du fond. Si vous développez un client WeeChat relay et voulez être compatible avec toutes les versions de WeeChat, vous devriez supporter les deux séparateurs (par exemple si un utilisateur avec WeeChat ≤ 2.5 lance `/upgrade` vers une version ≥ 2.6, les deux séparateurs pourront être utilisés au même moment dans les tampons).

Les codes couleur utilisant des options (voir t_gui_color_enum, dans le fichier src/gui/gui-color.h) :

Code | Option
--- | ---
`00` | weechat.color.separator
`01` | weechat.color.chat
`02` | weechat.color.chat_time
`03` | weechat.color.chat_time_delimiters
`04` | weechat.color.chat_prefix_error
`05` | weechat.color.chat_prefix_network
`06` | weechat.color.chat_prefix_action
`07` | weechat.color.chat_prefix_join
`08` | weechat.color.chat_prefix_quit
`09` | weechat.color.chat_prefix_more
`10` | weechat.color.chat_prefix_suffix
`11` | weechat.color.chat_buffer
`12` | weechat.color.chat_server
`13` | weechat.color.chat_channel
`14` | weechat.color.chat_nick
`15` | weechat.color.chat_nick_self
`16` | weechat.color.chat_nick_other
`17` | (n’est plus utilisé depuis WeeChat 0.3.4)
`18` | (n’est plus utilisé depuis WeeChat 0.3.4)
`19` | (n’est plus utilisé depuis WeeChat 0.3.4)
`20` | (n’est plus utilisé depuis WeeChat 0.3.4)
`21` | (n’est plus utilisé depuis WeeChat 0.3.4)
`22` | (n’est plus utilisé depuis WeeChat 0.3.4)
`23` | (n’est plus utilisé depuis WeeChat 0.3.4)
`24` | (n’est plus utilisé depuis WeeChat 0.3.4)
`25` | (n’est plus utilisé depuis WeeChat 0.3.4)
`26` | (n’est plus utilisé depuis WeeChat 0.3.4)
`27` | weechat.color.chat_host
`28` | weechat.color.chat_delimiters
`29` | weechat.color.chat_highlight
`30` | weechat.color.chat_read_marker
`31` | weechat.color.chat_text_found
`32` | weechat.color.chat_value
`33` | weechat.color.chat_prefix_buffer
`34` | weechat.color.chat_tags (WeeChat ≥ 0.3.6)
`35` | weechat.color.chat_inactive_window (WeeChat ≥ 0.3.6)
`36` | weechat.color.chat_inactive_buffer (WeeChat ≥ 0.3.6)
`37` | weechat.color.chat_prefix_buffer_inactive_buffer (WeeChat ≥ 0.3.6)
`38` | weechat.color.chat_nick_offline (WeeChat ≥ 0.3.9)
`39` | weechat.color.chat_nick_offline_highlight (WeeChat ≥ 0.3.9)
`40` | weechat.color.chat_nick_prefix (WeeChat ≥ 0.4.1)
`41` | weechat.color.chat_nick_suffix (WeeChat ≥ 0.4.1)
`42` | weechat.color.emphasized (WeeChat ≥ 0.4.2)
`43` | weechat.color.chat_day_change (WeeChat ≥ 0.4.2)
`44` | weechat.color.chat_value_null (WeeChat ≥ 1.4)
`45` | weechat.color.chat_status_disabled (WeeChat ≥ 4.0.0)
`46` | weechat.color.chat_status_enabled (WeeChat ≥ 4.0.0)

Les couleurs WeeChat sont :

Code | Couleur
--- | ---
`00` | Défaut (couleur de texte/fond du terminal)
`01` | Noir
`02` | Gris foncé
`03` | Rouge foncé
`04` | Rouge clair
`05` | Vert foncé
`06` | Vert clair
`07` | Marron
`08` | Jaune
`09` | Bleu foncé
`10` | Bleu clair
`11` | Magenta foncé
`12` | Magenta clair
`13` | Cyan foncé
`14` | Cyan clair
`15` | Gris
`16` | Blanc

Exemples de codes couleur :

Code | Description
--- | ---
19 `01` | Couleur de l’option "01" (texte de discussion).
19 `*08,03` | Jaune sur rouge.
19 `*@00214` | Orange (couleur étendue 214).
19 `*@*_00214,@00017` | Orange (214) gras souligné sur bleu foncé (17).
1A `_` | Activer le souligné.
1B `_` | Supprimer le souligné.
1C | Réinitialiser les attributs et la couleur.

## 5. Intérieur des extensions

Le fichier src/plugins/weechat-plugin.h définit et exporte toutes les fonctions disponibles dans l’API.

Une structure appelée t_weechat_plugin est utilisée pour stocker les informations sur l’extension (nom de fichier, nom, auteur, description, …​) et toutes les fonctions de l’API, sous forme de pointeurs vers les fonctions WeeChat.

Et puis des macros sont utilisées pour appeler ces fonctions.

Par exemple, la fonction hook_timer est définie dans la structure t_weechat_plugin comme ceci :

    struct t_hook *(*hook_timer) (struct t_weechat_plugin *plugin,
                                  long interval,
                                  int align_second,
                                  int max_calls,
                                  int (*callback)(void *data,
                                                  int remaining_calls),
                                  void *callback_data);

Et la macro utilisée pour appeler cette fonction est :

    #define weechat_hook_timer(__interval, __align_second, __max_calls,     \
                               __callback, __data)                          \
        weechat_plugin->hook_timer(weechat_plugin, __interval,              \
                                   __align_second, __max_calls,             \
                                   __callback, __data)

Donc dans une extension, l’appel à cette fonction sera par exemple :

    server->hook_timer_sasl = weechat_hook_timer (timeout * 1000,
                                                  0, 1,
                                                  &irc_server_timer_sasl_cb,
                                                  server);

## 6. Contribuer à WeeChat

### 6.1. Dépôt Git

Le dépôt Git est sur GitHub ↗.

Tout patch pour un bug ou une nouvelle fonctionnalité doit être effectué sur la branche `main`, le format préféré étant une "pull request" sur GitHub. Un patch peut aussi être envoyé par e-mail (fait avec `git diff` ou `git format-patch`).

Le format du message de commit est le suivant (avec fermeture automatique du bug GitHub) :

    composant: fix a problem (closes #123)

Où composant est :

Composant | Fichiers | Description
--- | --- | ---
`core` | `AUTHORS.md CHANGELOG.md CONTRIBUTING.md .github/FUNDING.yml .github/ISSUE_TEMPLATE/* icons/* po/* README.md UPGRADING.md src/core/* src/gui/* version.sh weechat.desktop` | cœur de WeeChat
`build` | `CMakeLists.txt cmake/* tools/* weechat.cygport.in` | Construction
`ci` | `.github/workflows/*` | Intégration continue
`debian` | `debian-devel/* debian-stable/*` | Empaquetage Debian
`tests/fuzz` | `tests/fuzz/*` | Fuzzing (tests à données aléatoires)
`tests/unit` | `tests/unit/*` | Tests unitaires
`doc` | `doc/*` | Mises à jour générales sur la documentation, par exemple la construction
`doc/man` | `doc/xx/weechat.1.xx.adoc doc/xx/weechat-headless.1.xx.adoc` | Pages de manuel
`doc/faq` | `doc/xx/weechat_faq.xx.adoc` | Questions fréquemment posées (FAQ)
`doc/quickstart` | `doc/xx/weechat_quickstart.xx.adoc` | Guide de démarrage rapide
`doc/user` | `doc/xx/weechat_user.xx.adoc` | Guide utilisateur
`doc/scripting` | `doc/xx/weechat_scripting.xx.adoc` | Guide pour scripts
`doc/api` | `doc/xx/weechat_plugin_api.xx.adoc` | Référence extension API
`doc/relay` | `doc/xx/weechat_relay_api.xx.adoc doc/xx/weechat_relay_weechat.xx.adoc` | Protocoles relay
`doc/dev` | `doc/xx/weechat_dev.en.adoc` | Guide du développeur
`irc python relay …` | `src/plugins/<name>/*` | Extension

Quelques règles à suivre :

- Utilisez seulement l’anglais.

- Utilisez des verbes à l’infinitif.

- Si le commit est relatif à un bug GitHub, écrivez-le entre parenthèses après le message, avec ce format : `(issue #123)` ou `(closes #123)` pour le fermer.

Exemples de messages de commit :

    core: add callback "nickcmp" for nick comparison in buffers
    core: update Japanese translations
    irc: add command /unquiet (closes #36)
    python: fix crash when unloading a script without pointer to interpreter
    ruby: add detection of ruby version 1.9.3 in CMake

### 6.2. Traductions

#### Gettext

Les fichiers gettext sont dans le répertoire po/.

Si vous souhaitez initialiser une nouvelle langue, utilisez la commande `msginit`. Par exemple pour créer un fichier qui est prêt à traduire en néerlandais :

    cd po
    msginit -i weechat.pot -l nl_NL -o nl.po

La langue de base pour WeeChat est l’anglais, donc vous devez évidemment comprendre parfaitement l’anglais pour traduire vers votre langue.

Après des changements dans les sources, vous pouvez regénérer toutes les traductions : lancez cette commande dans le répertoire "build" de CMake :

    make translations && make update-po

Vous pouvez alors éditer les fichiers .po (si vous pouvez traduire dans une langue).

Une fois terminé, vous devez vérifier votre fichier avec msgcheck ↗ :

    msgcheck.py xx.po

Et vous pouvez alors recompiler WeeChat pour utiliser les nouvelles traductions.

#### Asciidoc

Les fichiers Asciidoc donc dans le répertoire doc/XX/ où XX est la langue (en, fr, de, it, …​).

Faites d’abord une copie du fichier asciidoc en anglais (dans le répertoire doc/en/), puis travaillez dessus.

Les traductions manquantes dans les fichiers sont indiquées par cette chaîne :

    // TRANSLATION MISSING

Vous devez traduire tout le fichier sauf les liens et les mots-clés spéciaux pour les notes, avertissements, …​ Ces mots doivent être gardés tels quels :

    [[link_name]]
    <<link_name>>

    [NOTE]
    [TIP]
    [IMPORTANT]
    [WARNING]
    [CAUTION]

Lorsqu’il y a un nom après `<<link_name>>`, alors vous devez le traduire :

    <<link_name,ce texte doit être traduit>>