]> Schneller, leichter und erweiterbarer IRC Client Sébastien Helleu flashcode AT flashtux.org &date.xml; 2006 Sébastien Helleu Dieses Programm ist freie Software. Sie können es unter den Bedingungen der GNU General Public License, wie von der Free Software Foundation veröffentlicht, weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder (nach Ihrer Option) jeder späteren Version. Die Veröffentlichung dieses Programms erfolgt in der Hoffnung, daß es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE, sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK. Details finden Sie in der GNU General Public License. Sie sollten ein Exemplar der GNU General Public License zusammen mit diesem Programm erhalten haben. Falls nicht, schreiben Sie an die Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA. Dieses Dokument beschreibt den WeeChat IRC client, es ist ein Teil von WeeChat. Deutsche version: Frank Zacharias Die aktuellste Version ist auf dieser Seite zu finden: http://weechat.flashtux.org/doc.php Dieses Kapitel beschreibt WeeChat und die Vorraussetzungen für die Installation.

WeeChat (Wee Enhanced Environment for Chat) ist ein freier IRC Client, schnell und klein, entwickelt für viele Betriebssysteme. Hauptmerkmale: Mehrere Server gleichzeitig nutzbar (mit SSL, IPv6, Proxy) viele unterschiedliche User-Interfaces: Curses, wxWidgets, Gtk und Qt klein, schnell and leichtgewichtig änderbar und erweiterbar mit Plugins und Skripten entsprechend den folgenden RFCs 1459, 2810, 2811, 2812 und 2813 Viele Plattformen (GNU/Linux, *BSD, MacOS X, Windows and other) 100% GPL, freie Software WeeChat Homepage: http://weechat.flashtux.org

Um WeeChat zu installieren, werden gebraucht : ein laufendes GNU/Linux (Compiler für Quellcode-Pakete) root-Rechte für die Installation dem User-Interface entsprechend, eine der folgenden Bibliotheken: Curses: ncurses Bibliothek Gtk: *** noch nicht implementiert *** WxWidgets: *** noch nicht implementiert *** Qt: *** noch nicht implementiert ***

Dieses Kapitel erklärt die Installation von WeeChat.

Binäre Pakete sind für die folgenden Distributionen verfügbar: Debian (oder Debian-kompatible): apt-get install weechat Mandriva/RedHat (oder jede RPM-kompatible Distribution): rpm -i /chemin/weechat-x.y.z-1.i386.rpm Gentoo: emerge weechat FÜr andere Distributionen: sehen sie in die Dokumentation für Installationsanweisungen.

Alles was sie tun müssen, ist in einer Konsole oder einem Terminal aufzurufen: $ ./configure $ make Dann root werden und WeeChat installieren: $ su (root-Passwort eingeben) # make install

Warnung: CVS Quellen sind für fortgeschrittene Anwender, das Übersetzen könnte fehlschlagen oder das Ergebnis nicht stabil sein. Sie wurden gewarnt! Um die CVS Quellen zu bekommen, sind folgende Kommandos nötig: $ cvs -z3 -d:pserver:anonymous@cvs.savannah.nongnu.org:/sources/weechat co weechat Ausführen des folgenden Skripts: ./autogen.sh Dann folgen sie den Anweisungen zu den Quellpaketen (siehe )

Dieses Kapitel erklärt, wie Weechat zu starten ist, die zu verwendenden Tastenkombinationen, interne und IRC-Kommandos, die Konfigurationsdatei und die FIFO für die remote-Bedienung.

Argumente der Kommandozeile: Parameter Beschreibung -a, --no-connect Schaltet das auto-connect ab -c, --config Zeigt eine Hilfe zu den Konfigurationsmöglichkeiten (Liste der Optionen) -d, --dir <path> Setzt den Pfad für das Verzeichnis, dass Weechat benutzen soll (relevant für die Konfigurationsdateien, Logs, Plugins und Skripte). Der Standardwert "~/.weechat". Bitte beachten Sie: dieses Verzeichnis wird automatisch erzeugt, wenn es noch nicht exitiert. -f, --key-functions Zeigt die intern verwendeten Funktionen von WeeChat für bestimmte Tastenkombinationen an -h, --help Zeigt eine zusammenfassende Hilfe an. -i, --irc-commands Zeigt die IRC-Kommandos an -k, --keys Zeigt die Standard-Tastenkombinationen an -l, --license Zeigt die Lizenz an -p, --no-plugin Schaltet das automatische Laden der Plugins ab -v, --version Zeigt die Programmversion an -w, --weechat-commands Zeigt die Weechat-eigenen Kommandos an Es ist auch möglich URLs für einen oder mehrere IRC-Server anzugeben, so wie: irc[6][s]://[nick[:passwort]@]irc.example.org[:port][/channel][,channel[...] Beispiel um die Channels #weechat and #toto zu betreten "irc.freenode.net" server, default port (6667), mit dem Nicknamen "nono": $ weechat-curses irc://nono@irc.freenode.net/#weechat,#toto Um WeeChat zu starten, ist eins der folgenden Kommandos abzusetzen: für Curses GUI: weechat-curses für Gtk GUI: weechat-gtk für wxWidgets GUI: weechat-wxwidgets für Qt GUI: weechat-qt Wenn Sie Weechat zum ersten Mal starten, wird eine Konfigurationsdatei erzeugt, deren Optionen besitzen Standardwerte. Diese Datei ist: "~/.weechat/weechat.rc" Sie können diese Datei entsprechend ihren Bedürfnissen editieren, um Weechat anzupassen (NUR wenn Weechat nicht läuft) oder Parameter zu beeinflussen mit "/set" Kommando in WeeChat (siehe )

Tastenkombination Wirkung Links Gehe zum vorherigen Zeichen in der Kommandozeile Rechts Gehe zum nächsten Zeichen in der Kommandozeile Strg + Links Gehe zum vorherigen Wort in der Kommandozeile Strg + Rechts Gehe zum nächsten Wort in der Kommandozeile Pos1 / Strg + A Gehe zum Anfang der Kommandozeile Ende / Strg + E Gehe zum Ende der Kommandozeile Strg + K Lösche vom Cursor bis zum Ende der Kommandozeile Strg + L Fenster neu aufbauen Strg + U Lösche vom Cursor bis zum Aanfang der Kommandozeile Strg + W Lösche das vorhergehende Wort in der Kommandozeile Rückschritt Lösche das vorhergehende Zeichen in der Kommandozeile Entfernen Lösche das nächste Zeichen in der Kommandozeile Tabulator Vervollständige ein Kommando oder Nick (wiederhole: finde nächste Vervollständigung) Jedes Zeichen Setze das Zeichen beim Cursor in die Kommandozeile ein Eingabe Führe ein Kommando aus oder sende eine Nachricht Hoch / Runter Rufe das letzte Kommando/die letzte Nachricht wieder auf Strg + Hoch / Strg + Runter Rufe das letzte Kommando/die letzte Nachricht des globalen Buffers wieder auf (für alle Buffer) Seite hoch / Seite runter Eine Seite hoch / runter im Verlauf des Buffers Alt + Seite hoch / Alt + Seite runter Ein paar Zeilen hoch / runter im Verlauf des Buffers Alt + Pos1 / Alt + Ende Gehe zum Anfang / Ende des Puffers F5 / Alt + Links Gehe zum vorherigen Puffer F6 / Alt + Rechts Gehe zum nächsten Puffer F7 Schalte in das vorherige Fenster F8 Schalte in das nächste Fenster F10 Entferne den letzten Hinweis in der Infobar F11 / F12 Blättere in der Nicklist Alt + F11 / Alt + F12 Gehe zum Anfang / Ende der Nicklist Alt + A Schalte in den nächsten Puffer mit Aktivität (mit der Priorität: highlight, message, other) Alt + B Gehe zum vorherigen Wort in der Kommandozeile Alt + D Lösche das nächste Wort in der Kommandozeile Alt + F Gehe zum nächsten Wort in der Kommandozeile Alt + H Lösche den Inhalt der Hotlist (Aktivitätsanzeige für andere Puffer) Alt + J dann Alt + D Zeige den DCC-Puffer Alt + J dann Alt + L Schalte zum letzten Puffer Alt + J dann Alt + R Schalte in den reinen IRC-Daten Puffer Alt + J dann Alt + S Schalte in den Server-Puffer Alt + J dann Alt + X Schalte in den ersten Channel des nächsten Puffers (oder in den Server-Puffer wenn keine Channel offen ist) Alt + Zahl (0-9) Schalte in den Puffer mit der Nummer (0 = 10) Alt + J dann eine Zahl (01-99) Schalte in den Puffer mit der Nummer Alt + K Setze den Keycode der nächsten Taste in der Kommandozeile ein Alt + N Blättere zum nächsten Highlight Alt + P Blättere zum vorigen Highlight Alt + R Lösche die komplette Kommandozeile Alt + S Schalte zwischen den Servern im Server-Puffer hin und her (wenn "look_one_server_buffer" angeschaltet ist) Alt + U Blättere zur ersten ungelesenen Zeile im Puffer Alt + W dann Alt + Pfeil Schalte zum Fenster in der entsprechenden Richtung

Die WeeChat Kommandozeile (am Ende des Fensters) lässt sie Nachrichten an einen Channel senden oder WeeChat- bzw. IRC-Kommandos ausführen (siehe ). Kommandos beginnen mit einem "/", gefolgt vom Namen des Kommandos. Um zum Beispiel einen privaten Chat mit "toto" zu beginnen: /query toto Nachrichten an einen Channel sind jeder Text, der nicht mit einem "/" begint. Um zum Beispiel den Text "hello" an den gegenwärtigen Channel zu senden: hello Dennoch ist es möglich, eine Nachricht auch mit einem "/" zu beginnen, einfach ein weiteres "/" voranstellen. Um zum Beispiel den Text "/query toto" an den gegenwärtigen Channel zu senden: //query toto Wenn die Option IRC-Farben ("irc_colors_send") senden angeschaltet ist, können sie Farbcodierung und Attribute wiefolgt verwenden: Code Beschreibung %B Fett (bold) %Cxx Textfarbe "xx" (color) (siehe Farbtabelle) %Cxx,yy Textfarbe "xx" und Hintergrund "yy" (siehe Farbtabelle) %O Schalte Farben und Attribute ab %R umgedrehte Farben (tausche Textfarbe mit Hintergrundfarbe) %U Unterstreiche Text %% Schreibe ein einzelnes "%" Hinweis: Der gleiche Farbcode (ohne die Nummer) kann zum Ausschalten des Attributes verwendet werden. Farbcodes für %C: Code Farbe 00 weiss 01 schwarz 02 dunkles Blau 03 dunkles Grün 04 helles Rot 05 dunkles Rot 06 Magenta 07 Orange 08 Gelb 09 helles Grün 10 Cyan 11 helles Cyan 12 helles Blau 13 helles Magenta 14 Grau 15 helles Grau (Weiss) Beispiel: Anzeige von "hello everybody!" mit "hello" fett in hellem Blau, und "everybody" unterstrichen in hellem Rot: %C12%Bhello%B%C04%U everybody%U%C!

Dieses Kapitel listet alle WeeChat- und IRC-Kommandos auf.

&weechat_commands.xml;

Funktion Beschreibung &key_functions.xml;

&irc_commands.xml;

Liste der Optionen für die Konfigurationsdatei: Option Typ Wert Default Beschreibung &config.xml; Farben für die Curses GUI: Schlüsselwort Farbe default default Farbe (Transparent für den Hintergrund) black Schwarz red dunkles Rot lightred helles Rot green dunkles Grün lightgreen helles Grün brown Braun yellow Gelb blue dunkles Blau lightblue helles Blau magenta dunkles Magenta lightmagenta helles Magenta cyan dunkles Cyan lightcyan helles Cyan white Weiss

Sie können WeeChat auch extern steuern, indem sie Kommandos oder Text an eine sogen. pipe übergeben (sie müssen die Option "irc_fifo_pipe" anschalten, die normalerweise abgeschaltet ist). Diese pipe liegt in "~/.weechat/" und hat den Namen "weechat_fifo_xxxxx" (das xxxxx ist die Prozess-ID (PID) eines laufenden WeeChat). Wenn mehrere Instanzen von WeeChat laufen, sind mehrere pipes vorhanden, eine für jede Instanz. Der Syntax für ein pipe-Kommando ist: server,channel *Text oder Kommando wobei Server und Channel optional sind, aber wenn der Channel angegeben ist, muss der Server auch angegeben werden. Einige Beispiele: Ändern des Nicks auf freenode in "mynick|out" : $ echo 'freenode */nick mynick|out' >~/.weechat/weechat_fifo_12345 Senden einer Nachricht an #weechat: $ echo 'freenode,#weechat *hello everybody!' >~/.weechat/weechat_fifo_12345 Senden einer Nachricht an den gegenwärtigen Channel (Puffer, der in WeeChat angezeigt wird): $ echo '*hello!' >~/.weechat/weechat_fifo_12345 Warnung: Das ist gefährlich und sie sollten das nicht tun, ausgenommen sie wissen was sie tun! Sende zwei Kommandos um (alle) Perl-Skripte abzuschalten/neu zu laden (getrennt durch ein "\n"): $ echo -e "freenode */perl unload\nfreenode */perl autoload" >~/.weechat/weechat_fifo_12345 Sie können ein Skript schreiben, um ein Kommando an alle laufenden WeeChat-Instanzen zu senden, zum Beispiel: #!/bin/sh if [ $# -eq 1 ]; then for fifo in $(/bin/ls ~/.weechat/weechat_fifo_* 2>/dev/null); do echo -e "$1" >$fifo done fi Wenn das Skript "auto_weechat_command" heisst, können sie es folgendermassen aufrufen: $ ./auto_weechat_command "freenode,#weechat *hello"

Dieses Kapitel beschreibt das Plugin-Interface (API) in WeeChat und die Standard-Skriptplugins (Perl, Python, Ruby, Lua), die zu WeeChat gehören.

Ein Plugin ist ein C-Programm, dass WeeChat-Funktionen aufrufen kann, die in einem Interface definiert sind. Dieses C-Programm braucht nicht den Quellcode von WeeChat (aber die API-Beschreibung) und kann dynamisch mit dem folgenden Kommando in WeeChat geladen werden /plugin. Das Plugin muss in Form einer dynamischen Bibliothek vorliegen, damit es das Betriebssystem dynamisch laden kann. Unter GNU/Linux besitzt die Datei die Endung ".so", unter Windows ".dll".

Das Plugin muss die Datei "weechat-plugin.h" einbinden (verfügbar im WeeChat-Quellcode). Diese Datei definiert die Strukturen und Typen um mit WeeChat zu kommunizieren. Das Plugin muss einige Variablen und Funktionen besitzen (nötig, sonst kann das Plugin nicht geladen werden): Variable Beschreibung char plugin_name[] Plugin Name char plugin_version[] Plugin Version char plugin_description[] kurze Beschreibung des Plugins Funktion Beschreibung int weechat_plugin_init (t_weechat_plugin *plugin) Die Funktion wird aufgerufen, wenn das Plugin geladen wird. Sie muss bei Erfolg PLUGIN_RC_OK, bei Fehlschlag PLUGIN_RC_KO zurückgeben. (Bei einem Fehler wird das Plugin nicht geladen) void weechat_plugin_end (t_weechat_plugin *plugin) Funktion wird beim Abschalten aufgerufen

Prototyp: int ascii_strcasecmp (t_weechat_plugin *plugin, char *string1, char *string2) Vergleich von Zeichenketten unabhängig von Sprache und Schreibweise (gross/klein). Argumente: plugin: Zeiger auf Plugin-Struktur string1: erste Zeichenkette des Vergleichs string2: zweite Zeichenkette des Vergleichs Rückgabewert: Unterschied zwischen den zwei Zeichenketten: kleiner Null wenn string1 < string2, Null wenn string1 == string2, grösser Null wenn string1 > string2 Beispiel: if (plugin->ascii_strcasecmp (plugin, "abc", "def") != 0) ...

Prototyp: int ascii_strncasecmp (t_weechat_plugin *plugin, char *string1, char *string2, int max) Vergleich von Zeichenketten unabhängig von Sprache und Schreibweise (gross/klein) für höchstens "max" Zeichen. Argumente: plugin: Zeiger auf Plugin-Struktur string1: erste Zeichenkette des Vergleichs string2: zweite Zeichenkette des Vergleichs max: maximale Zahl an Zeichen für den Vergleich Rückgabewert: Unterschied zwischen den zwei Zeichenketten: kleiner Null wenn string1 < string2, Null wenn string1 == string2, grösser Null wenn string1 > string2 Beispiel: if (plugin->ascii_strncasecmp (plugin, "abc", "def", 2) != 0) ...

Prototyp: char **explode_string (t_weechat_plugin *plugin, char *string, char *separators, int num_items_max, int *num_items) Zerlege eine Zeichenkette entsprechend eines oder mehrerer Trennzeichen(s). Argumente: plugin: Zeiger auf eine Plugin-Struktur string: zu zerlegende Zeichenkette separators: zu verwendende(s) Trennzeichen num_items_max: maximale Anzahl an zu erzeugenden Teilen (0 = keine Grenze) num_items: Zeiger auf eine int-Variable, die die Anzahl der erzeugten Teile enthält Rückgabewert: ein Array von Zeichenketten, NULL bei Fehlern. Hinweis: Das zurückgegebene Array muss nach der Benutzung mittels "free_exloded_string" explizit freigegeben werden. Beispiel: char **argv; int argc; argv = plugin->explode_string (plugin, string, " ", 0, &argc); ... if (argv != NULL) plugin->free_exploded_string (plugin, argv);

Prototyp: char **free_exploded_string (t_weechat_plugin *plugin, char **string) Gib ein Array frei, dass infolge der Zerlegung eines Strings reserviert wurde. Argumente: plugin: Zeiger auf eine Plugin-Struktur string: ein Array von Strings Rückgabewert: keiner (?). Beispiel: char *argv; int argc; argv = plugin->explode_string (plugin, string, " ", 0, &argc); ... if (argv != NULL) plugin->free_exploded_string (plugin, argv);

Prototype: int mkdir_home (t_weechat_plugin *plugin, char *directory) Create a directory in WeeChat home. Arguments: plugin: pointer to plugin structure directory: directory to create Return value: 1 if directory was successfully created, 0 if an error occurred. Example: if (!plugin->mkdir_home (plugin, "temp")) plugin->print_server(plugin, "Failed to create 'temp' directory in WeeChat home.");

Prototyp: void exec_on_files (t_weechat_plugin *plugin, char *repertoire, int (*callback)(t_weechat_plugin *, char *)) Führe eine Funktion auf allen Dateien eines Verzeichnisses aus. Argumente: plugin: Zeiger auf eine Plugin-Struktur directory: Verzeichnis der zu verwendenden Dateien callback: die anzuwendende Funktion Rückgabewert: keiner. Beispiel: int callback (t_weechat_plugin *plugin, char *file) { plugin->print_server (plugin, "file: %s", file); return 1; } ... plugin->exec_on_files (plugin, "/tmp", &callback);

Prototyp: void print (t_weechat_plugin *plugin, char *server, char *channel, char *message, ...) Sende eine Nachricht an einen WeeChat-Puffer, bezeichnet durch server und channel (beide können NULL sein, dann wird der aktuelle Puffer verwendet). Argumente: plugin: Zeiger auf Plugin-Struktur server: interner Name des Servers, zu welchem der Puffer gehört, in dem die Nachricht angezeigt werden soll (kann NULL sein) channel: Name des Channels, in dem die Nachricht angezeigt werden soll (kann NULL sein) message: Nachricht Rückgabewert: keiner. Beispiele: plugin->print (plugin, NULL, NULL, "hello"); plugin->print (plugin, NULL, "#weechat", "hello"); plugin->print (plugin, "freenode", "#weechat", "hello");

Prototyp: void print_server (t_weechat_plugin *plugin, char *message, ...) Zeige eine Nachricht im aktuellen Server-Puffer. Argumente: plugin: Zeiger auf eine Plugin-Struktur message: Nachricht Rückgabewert: keiner. Beispiel: plugin->print_server (plugin, "hello");

Prototyp: void print_infobar (t_weechat_plugin *plugin, int time, char *message, ...) Zeige eine Nachricht in der Infobar für eine bestimmte Zeit Argumente: plugin: Zeiger auf eine Plugin-Struktur time: Zeitspanne für die Anzeige (in Sekunden, 0 = ständige Anzeige) Rückgabewert: keiner. Beispiel: plugin->print_infobar (plugin, 5, "hello");

Prototyp: void infobar_remove (t_weechat_plugin *plugin, int count) Entferne eine oder mehr Nachrichten aus der Infobar. Argumente: plugin: Zeiger auf eine Plugin-Struktur count: Anzahl der Nachrichten (wenn das Argument kleiner als Null ist, werden alle Nachrichten entfernt) Rückgabewert: keiner. Beispiel: plugin->infobar_remove (1);

Prototyp: void log (t_weechat_plugin *plugin, char *server, char *channel, char *message, ...) Schreibe eine Nachricht in die Log-Datei (für den entsprechenden Server/Channel). Argumente: plugin: Zeiger auf eine Plugin-Struktur server: interner Name des Servers, zu welchem der Log-Puffer gehört (kann NULL sein) channel: Name des Channels, zu welchem der Log-Puffer gehört (kann NULL sein) message: Nachricht Rückgabewert: keiner. Beispiel: plugin->log (plugin, "freenode", "#weechat", "test");

Prototyp: t_plugin_handler *msg_handler_add (t_weechat_plugin *plugin, char *message, t_plugin_handler_func *function, char *handler_args, void *handler_pointer) Erzeuge einen IRC-Message-Handler, der aufgerufen wird, wenn eine Nachricht empfangen wird. Argumente: plugin: Zeiger auf eine Plugin-Struktur message: Name (Typ) der IRC-Nachricht. Eine Liste der bekannten IRC-Nachrichten ist in den RFCs 1459 und 2812 zu finden. Weiterhin können sie einen speziellen Namen verwenden, der mit "weechat_" beginnt, um spezielle Ereignisse zu bearbeiten, wie in der folgenden Tabelle aufgeführt: Name Beschreibung weechat_pv private Nachricht empfangen weechat_highlight hervorgehobene Nachricht (in einem Channel oder privatem Chat) weechat_ctcp CTCP-Nachricht empfangen (VERSION, PING, ...) weechat_dcc DCC-Nachricht empfangen (Chat oder Datei) function: Funktion, die aufgerufen wird, wenn eine Nachricht empfangen wurde Sie verwendet den folgenden Prototyp: int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) Argument argc ist auf 3 gesetzt, die folgenden Werte sind im argv-Array: argv[0] = Server Name argv[1] = IRC Nachricht argv[2] = Kommando Argumente handler_args: Argumente, die beim Aufruf an die Funktion übergeben werden handler_pointer: pointer given to function when called handler_pointer: Zeiger, der an die Funktion übergeben wird Rückgabewert: Zeiger auf den neuen Handler Hinweis: die Funktion, die aufgerufen wird wenn eine Nachricht empfangen wurde, muss einen der folgenden Werte zurückgeben: PLUGIN_RC_KO: Funktion ist fehlgschlagen PLUGIN_RC_OK: Funktion war erfolgreich PLUGIN_RC_OK_IGNORE_WEECHAT: Die Nachricht wird nicht an WeeChat übergeben PLUGIN_RC_OK_IGNORE_PLUGINS: Die Nachricht wird nicht an andere Plugins weitergegeben PLUGIN_RC_OK_IGNORE_ALL: Die Nachricht wird weder an WeeChat noch an andere Plugins weitergegeben Beispiel: int msg_kick (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) { plugin->print (plugin, argv[0], NULL, "KICK received"); return PLUGIN_RC_OK; } ... plugin->msg_handler_add (plugin, "KICK", &msg_kick, NULL, NULL);

Prototyp: t_plugin_handler *cmd_handler_add (t_weechat_plugin *plugin, char *command, char *description, char *arguments, char *arguments_description, char *completion_template, t_plugin_handler_func *fonction, char *handler_args, void *handler_pointer) Erzeugt einen Handler für ein WeeChat-Kommando, der aufgerufen wird, wenn der Anwender das Kommando ausführt (Beispiel: /command). Argumente: plugin: Zeiger auf eine Plugin-Struktur command: Name des neuen Kommandos, der auch Name eines bereits existierenden Kommandos sein kann (mit Bedacht zu verwenden, das ersetzte Kommando ist nicht verfügbar, bis das Plugin entfernt wurde) description: kurze Beschreibung des Kommandos (angezeigt beim Ausführen von /help command) arguments: kurze Beschreibung der Argumente des Kommandos (angezeigt beim Ausführen von /help command) arguments_description: lange Beschreibung der Argumente des Kommandos (angezeigt beim Ausführen von /help command) completion_template: Vorlage für die Vervollständigung; zum Beispiel bedeutet "abc|%w def|%i", dass das erste Argument "abc" oder ein WeeChat-Kommando sein kann und das zweite Argument "def" oder ein IRC-Kommando. Eine leere Zeichenkette bedeutet, dass WeeChat für jedes Argument einen Nicknamen des gegenwärtigen Channels einsetzt, ein NULL oder "-" schaltet die Vervollständigung für alle Argumente ab. Die folgenden Ersetzungen können verwendet werden: Code Beschreibung %- keine Vervollständigung für das Argument %a Alias %A Aliase und Kommandos (WeeChat, IRC und Plugins) %c gegenwärtiger Channel %C Channels des gegenwärtigen Servers %h Plugin Kommandos %i IRC Kommandos (senden) %I IRC Kommandos (empfangen) %k Grundfunktionen %m Nicknamen des gegenwärtigen Servers %n Nicknamen des gegenwärtigen Channels %N Nicknamen und Hostnamen des gegenwärtigen Channels %o Konfigurationseinstellungen %O Plugin Optionen %p Standard "part" Nachricht %q Standard "quit" Nachricht %s Name des gegenwärtigen Servers %S Namen aller definierten Server %t Topic des gegenwärtigen Channels %v Wert einer Konfigurationseinstellung %V Wert einer Plugin-Option %w WeeChat Kommandos function: Funktion, die aufgerufen wird, wenn das Kommando ausgeführt wird Sie verwendet den folgenden Prototypen: int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) Das Argument argc ist auf 3 gesetzt, das Array argv enthält die folgenden Werte: argv[0] = Server Name argv[1] = Kommando argv[2] = Kommando-Argumente handler_args: Argumente, die an die Funktion übergeben werden handler_pointer: Zeiger, der an die Funktion übergeben wird Rückgabewert: Zeiger auf den neuen Kommando-Handler. Hinweis: die Funktion, die aufgerufen wird, wenn das Kommando ausgeführt wird, muss einen der folgende Werte zurückgeben: PLUGIN_RC_KO: Funktion ist fehlgeschlagen PLUGIN_RC_OK: Funktion war erfolgreich Beispiel: int cmd_test (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) { plugin->print (plugin, argv[0], NULL, "test command, nick: %s", (argv[2]) ? argv[2] : "none"); return PLUGIN_RC_OK; } ... plugin->cmd_handler_add (plugin, "test", "Test command", "[nick]", "nick: nick of channel", "%n", &cmd_test, NULL, NULL);

Prototyp: t_plugin_handler *timer_handler_add (t_weechat_plugin *plugin, int interval, t_plugin_handler_func *function, char *handler_args, void *handler_pointer) Erzeuge einen zeitgesteuerten Handler, der periodisch eine Funktion aufruft. Argumente: plugin: Zeiger auf eine Plugin-Struktur interval: Intervall (in Secunden) zwischen zwei Aufrufen der Funktion function: Funktion, die aufgerufen wird Sie verwendet den folgenden Prototypen: int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) Das Argument argc ist auf 0 gesetzt und argv ist auf NULL gesetzt. handler_args: Argumente der aufgerufenen Funktion handler_pointer: Zeiger, der an die Funktion übergeben wird Rückgabewert: Zeiger auf den neuen timer-Handler. Hinweis: die Funktion, die aufgerufen wird, muss einen der folgende Werte zurückgeben: PLUGIN_RC_KO: Funktion ist fehlgeschlagen PLUGIN_RC_OK: Funktion war erfolgreich Beispiel: int my_timer (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) { plugin->print (plugin, NULL, NULL, "my timer"); return PLUGIN_RC_OK; } ... plugin->timer_handler_add (plugin, 60, &my_timer);

Prototyp: t_plugin_handler *keyboard_handler_add (t_weechat_plugin *plugin, t_plugin_handler_func *function, char *handler_args, void *handler_pointer) Erzeugt einen Keyboard-Handler, der nach dem Drücken einer Taste aufgerufen wird. Argumente: plugin: Zeiger auf eine Plugin-Struktur function: Die Funktion, die aufgerufen wird Sie verwendet den folgenden Prototypen: int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) Das Argument argc ist auf 3 gesetzt, argv enthält die folgenden Werte: argv[0] = Taste, die gedrückt wurde (Name der internen Funktion oder '*' gefolgt von einem Tastaturcode) argv[1] = Kommandozeile vor dem Tastendruck argv[2] = Kommandozeile nach dem Tastendruck handler_args: Argumente, die bei Aufruf der Funktion übergeben werden handler_pointer: Zeiger auf die Funktion, der bei Aufruf übergeben wird Rückgabewert: Zeiger auf den Handler. Hinweis: Die aufgerufene Funktion muss einen der folgenden Werte zurückgeben: PLUGIN_RC_KO: Funktion ist fehlgeschlagen PLUGIN_RC_OK: Funktion war erfolgreich Beispiel: int keyb_handler (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) { if (argc == 2) { plugin->print (plugin, NULL, NULL, "key pressed: %s", argv[0]); if (argv[1] && (argv[1][0] == '1')) plugin->print (plugin, NULL, NULL, "input text changed"); else plugin->print (plugin, NULL, NULL, "input text not changed"); } return PLUGIN_RC_OK; } ... plugin->keyboard_handler_add (plugin, &keyb_handler);

Prototyp: void handler_remove (t_weechat_plugin *plugin, t_plugin_handler *handler) Entfernt einen Nachrichten- oder Kommando-Handler. Argumente: plugin: Zeiger auf eine Plugin-Struktur handler: Handler, der entfernt werden soll Rückgabewert: keiner Beispiel: plugin->handler_remove (plugin, my_handler);

Prototyp: void handler_remove_all (t_weechat_plugin *plugin) Entfernt alle Handler eines Plugins. Argumente: plugin: Zeiger auf eine Plugin-Struktur Rückgabewert: keiner Beispiel: plugin->handler_remove_all (plugin);

Prototyp: void exec_command (t_weechat_plugin *plugin, char *server, char *channel, char *command) Führe ein WeeChat-Kommando aus (oder sende eine Nachricht an einen Channel). Argumente: plugin: Zeiger auf eine Plugin-Struktur server: interner Name des Servers, auf den das Kommando angewendet werden soll (kann NULL sein) channel: Name des Channels, auf den das Kommando angewendet werden soll (kann NULL sein) command: Kommando Rückgabewert: keiner Beispiel: plugin->exec_command (plugin, NULL, NULL, "/help nick"); plugin->exec_command (plugin, "freenode", "#weechat", "hello");

Prototyp: char *get_info (t_weechat_plugin *plugin, char *info, char *server) Gib eine Information über WeeChat oder einen Channel zurück. Argumente: plugin: Zeiger auf eine Plugin-Struktur info : Name (Typ) der Information: Info Beschreibung version WeeChats Version nick Nickname channel Name des Channels (NULL bei einem Server oder Privatchat) server Name des Servers away Status des "away"-Flags inactivity Anzahl der Sekunden seit der letzten Tastenbetätigung input Inhalt der Kommandozeile im gegenwärtigen Fenster input_mask Inhalt der Farbmaske für die Kommandozeile input_pos Position des Cursors in der Kommandozeile weechat_dir WeeChat-Verzeichnis (Standard: ~/.weechat/) weechat_libdir WeeChat-Systemverzeichnis (Bibliotheken) weechat_sharedir WeeChat-Systemverzeichnis (gemeinsame Dateien) server: interner Name des Servers um Informationen zu lesen (wenn benötigt) Rückgabewert: angeforderte Information oder NULL Hinweis: das Ergebnis muss nach Nutzung mit "free" wieder freigegeben werden. Beispiele: char *version = plugin->get_info (plugin, "version", NULL); char *nick = plugin->get_info (plugin, "nick", "freenode"); char *inactivity = plugin->get_info (plugin, "inactivity", NULL); plugin->print (plugin, NULL, NULL, "WeeChat version %s, you are %s on freenode " "(inactive for %s seconds)", version, nick, inactivity); if (version) free (version); if (nick) free (nick); if (inactivity) free (inactivity);

Prototyp: t_plugin_info_dcc *get_dcc_info (t_weechat_plugin *plugin) Gib eine Liste der aktiven oder beendeten DCCs zurück. Argumente: plugin: Zeiger auf eine Plugin-Struktur Rückgabewert: verkettete Liste von DCCs. Typ Feld Beschreibung char * server IRC Server char * channel IRC Channel int type DCC Typ: 0 = Chatanfrage empfangen, 1 = Chatanfrage gesendet, 2 = Datei empfangen, 3 = Datei gesendet int* status DCC Status: 0 = wartend, 1 = verbindend, 2 = aktiv, 3 = beendet, 4 = fehlgeschlagen, 5 = unterbrochen durch Anwender time_t start_time Datum/Zeit der Erzeugung der DCC time_t start_transfer Datum/Zeit des Beginns der Übertragung der DCC unsigned long addr IP-Adresse des Partners int port Port der DCC char * nick Nickname des Partners char * filename Dateiname char * local_filename lokaler Dateiname int filename_suffix Suffix wenn die Datei umbenannt wird unsigned long size Dateigrösse unsigned long pos Position in Datei unsigned long start_resume Startposition nach einer Unterbrechung unsigned long bytes_per_sec Übertragungsrate (Bytes/s) seit Beginn der Übertragung t_plugin_dcc_info * prev_dcc Zeiger auf voheriges DCC-Info t_plugin_dcc_info * next_dcc Zeiger auf nächstes DCC-Info Hinweis: Das Ergebnis muss nach der Benutzung mittels "free_dcc_info" wieder freigegeben werden. Beispiele: t_plugin_dcc_info *dcc_info = plugin->get_dcc_info (plugin); for (ptr_dcc = dcc_info; ptr_dcc; ptr_dcc = ptr_dcc->next_dcc) { plugin->print_server (plugin, "DCC type=%d, with: %s", ptr_dcc->type, ptr_dcc->nick); } if (dcc_info) plugin->free_dcc_info (plugin, dcc_info);

Prototyp: void free_dcc_info (t_weechat_plugin *plugin, t_plugin_dcc_info *dcc_info) Gibt den Speicher einer Liste von DCC-Infos wieder frei. Argumente: plugin: Zeiger auf eine Plugin-Struktur dcc_info: Zeiger auf eine Liste mit DCC-Infos, die mit "get_dcc_info" angelegt wurde Rückgabewert: keiner. Beispiel: plugin->free_dcc_info (plugin, dcc_info);

Prototyp: t_plugin_server_info *get_server_info (t_weechat_plugin *plugin) Gibt die Liste von IRC-Servern zurück (verbunden oder nicht) Argumente: plugin: Zeiger auf eine Plugin-Struktur Rückgabewert: Liste von IRC-Servern. Typ Feld Beschreibung char * name interner Servername int autoconnect 1 wenn Autoconnect gesetzt ist, 0 sonst int autoreconnect 1 wenn autoreconnect gesetzt ist, 0 sonst int autoreconnect_delay Wartezeit vor erneutem Verbindungsversuch int command_line 1 wenn der Servername auf der Kommandozeile angegeben wurde (ist somit temporär) 0 sonst char * address Serveradresse (Name oder IP) int port Port int ipv6 IPv6-Verbindung int ssl SSL-Verbindung char * password Passwort char * nick1 primärer Nickname char * nick2 alternativer Nickname char * nick3 zweiter, alternativer Nickname char * username Username char * real name tatsächlicher Name char * command Kommando, dass bei erfolgreicher Verbindung ausgeführt wurde int command_delay Verzögerung nach Ausführung des Kommandos char * autojoin Channels, die automatisch betreten werden sollen int autorejoin 1 wenn Channels wieder betreten werden sollen, nachdem man gekickt wurde 0 sonst char * notify_levels Benachrichtigungs-Level von Channels char * charset_decode_iso Zeichensatz zum Dekodieren von ISO char * charset_decode_utf Zeichensatz zum Dekodieren von UTF char * charset_encode Zeichensatz der Channels zum Kodieren von Nachrichten int is_connected 1 wenn verbunden mit einem Server, 0 otherwise int ssl_connected 1 wenn verbunden über SSL, 0 sonst char * nick gegenwärtiger Nickname int is_away 1 wenn away-flag gesetzt ist, 0 sonst time_t away_time Zeitspanne seit away-flag gesetzt ist int lag Lag (in Millisekunden) t_plugin_server_info * prev_server Zeiger auf vorherigen Knoten der Liste t_plugin_server_info * next_server Zeiger auf nächsten Knoten der Liste Hinweis: das Ergebnis muss nach der Benutzung mit "free_server_info" wieder freigegeben werden. Beispiel: t_plugin_server_info *server_info, *ptr_server_info; server_info = plugin->get_server_info (plugin); if (server_info) { for (ptr_server_info = server_info; ptr_server_info; ptr_server_info = ptr_server_info->next_server) { plugin->print (plugin, NULL, NULL, "server: %s, address: %s, port: %d %s", ptr_server_info->name, ptr_server_info->address, ptr_server_info->port, (ptr_server_info->is_connected) ? "(connected)" : ""); } plugin->free_server_info (plugin, server_info); }

Prototyp: void free_server_info (t_weechat_plugin *plugin, t_plugin_server_info *server_info) Gib den Speicher einer Liste "server info" frei Argumente: plugin: Zeiger auf eine Plugin-Struktur server_info: Zeiger auf eine Server-Liste, der von der Funktion "get_server_info" zurückgegeben wurde. Rückgabewert: keiner. Beispiel: plugin->free_server_info (plugin, server_info);

Prototyp: t_plugin_channel_info *get_channel_info (t_weechat_plugin *plugin, char *server) Gib eine Liste der Channels für einen Server zurück. Argumente: plugin: Zeiger auf eine Plugin-Struktur server: interner Name des Server Rückgabewert: verkettete Liste von Channels für einen Server. Typ Feld Beschreibung int type 0 für einen normalen Channel, 1 für einen Privaten char * name Name des Channels char * topic Topic des Channels char * modes Channelmodus (Flags) int limit Anzahl der erlaubten User char * key Schlüssel des Channels int nicks_count Anzahl der Nicknamen des Channels t_plugin_channel_info * prev_channel Zeiger auf vorherigem Knoten der Liste t_plugin_channel_info * next_channel Zeiger auf nächsten Knoten der Liste Hinweis: Das Ergebnis muss nach der Benutzung mit "free_channel_info" wieder freigegeben werden. Beispiel: t_plugin_channel_info *channel_info, *ptr_chan_info; channel_info = plugin->get_channel_info (plugin, "freenode"); if (channel_info) { for (ptr_chan_info = channel_info; ptr_chan_info; ptr_chan_info = ptr_chan_info->next_channel) { plugin->print (plugin, NULL, NULL, " %s (type %d)", ptr_chan_info->name, ptr_chan_info->type); } plugin->free_channel_info (plugin, channel_info); }

Prototyp: void free_channel_info (t_weechat_plugin *plugin, t_plugin_channel_info *channel_info) Gibt den Speicher einer Liste "channel info" wieder frei. Argumente: plugin: Zeiger auf eine Plugin-Struktur channel_info: Zeiger auf eine Liste "channel info", der von "get_channel_info" zurückgegeben wurde Rückgabewert: keiner. Beispiel: plugin->free_channel_info (plugin, channel_info);

Prototyp: t_plugin_nick_info *get_nick_info (t_weechat_plugin *plugin, char *server, char *channel) Gib eine Liste der Nicknamen für einen Channel zurück. Argumente: plugin: Zeiger auf eine Plugin-Struktur server: interner Name des Servers channel: Name des Channels Rückgabewert: verkettete Liste von Nicknamen eines Channels. Typ Feld Beschreibung char * nick Nickname char * host Hostname int Flags Flags, die für einen Nicknamen gesetzt sind: Zweierpotenzen "oder" Zwischenwerte (1 = channel owner, 2 = channel admin, 4 = op, 8 = halfop, 16 = voice, 32 = away) t_plugin_nick_info * prev_nick Zeiger auf vorherigen Knoten der Liste t_plugin_nick_info * next_nick Zeiger auf nächsten Knoten der Liste Hinweis: Das Ergebnis muss nach der Benutzung mit "free_nick_info" wieder freigegeben werden. Beispiel: t_plugin_nick_info *nick_info, *ptr_nick_info; nick_info = plugin->get_nick_info (plugin, "freenode", "#weechat"); if (nick_info) { for (ptr_nick_info = nick_info; ptr_nick_info; ptr_nick_info = ptr_nick_info->next_nick) { plugin->print (plugin, NULL, NULL, " %s (flags: %d)", ptr_nick_info->nick, ptr_nick_info->flags); } plugin->free_nick_info (plugin, nick_info); }

Prototyp: void free_nick_info (t_weechat_plugin *plugin, t_plugin_nick_info *nick_info) Gibt den Speicher einer Liste "nick info" frei. Argumente: plugin: Zeiger auf eine Plugin-Struktur nick_info: Zeiger auf eine Liste "nick info", der von "get_nick_info" zurückgegeben wurde Rückgabewert: keiner. Beispiel: plugin->free_nick_info (plugin, nick_info);

Prototyp: char *get_config (t_weechat_plugin *plugin, char *option) Gibt den Wert einer Option der WeeChat-Konfiguration zurück. Argumente: plugin: Zeiger auf eine Plugin-Struktur option: Name der Option Rückgabewert: Wert der Option, oder NULL, wenn nichts gefunden wurde. Hinweis: Das Ergebnis muss nach der Benutzung mit "free" wieder freigegeben werden. Beispiel: char *value1 = plugin->get_config (plugin, "look_set_title"); char *value2 = plugin->get_config (plugin, "freenode.server_autojoin");

Prototyp: int set_config (t_weechat_plugin *plugin, char *option, char *value) Setze den Wert einer Option der WeeChat-Konfiguration. Argumente: plugin: Zeiger auf eine Plugin-Struktur option: Name der Option value: der neue Wert der Option Rückgabewert: 1 wenn der Wert der Option gesetzt werden konnte, 0 bei Auftreten eines Fehlers. Beispiel: plugin->set_config (plugin, "look_nicklist", "off");

Prototyp: char *get_plugin_config (t_weechat_plugin *plugin, char *option) Gibt den Wert einer Option eines Plugins zurück. Die Option wird aus "~/.weechat/plugins.rc" gelesen und sieht so aus: "plugin.option=value" (Hinweis: der Name des Plugins wird automatisch gesetzt). Argumente: plugin: Zeiger auf eine Plugin-Struktur option: Name der Option Rückgabewert: Wert der Option, NULL wenn nichts gefunden wurde. Hinweis: Das Ergebnis muss nach der Benutzung mit "free" wieder freigegeben werden. Beispiel: char *value = plugin->get_plugin_config (plugin, "my_var");

Prototyp: int set_plugin_config (t_weechat_plugin *plugin, char *option, char *value) Setzt den Wert einer Option eines Plugins. Die Option wird in die Datei "~/.weechat/plugins.rc" geschrieben und sieht so aus: "plugin.option=value" (Hinweis: der Name des Plugins wird automatisch gesetzt) Argumente: plugin: Zeiger auf eine Plugin-Struktur option: Name der Option, die gesetzt werden soll value: Wert der zu setzenden Option Rückgabewert: 1 wenn die Option gesetzt werden konnte, 0 wenn ein Fehler aufgetreten ist. Beispiel: plugin->set_plugin_config (plugin, "my_var", "value");

Prototype: int get_irc_color (t_weechat_plugin *plugin, char *color_name) Get IRC color index with name. Arguments: plugin: pointer to plugin structure color_name: color name Allowed colors are: Color name Value white 0 black 1 blue 2 green 3 lightred 4 red 5 magenta 6 brown 7 yellow 8 lightgreen 9 cyan 10 lightcyan 11 lightblue 12 lightmagenta 13 gray 14 lightgray 15 Return value: IRC color index, -1 if color is not found. Example: int color_blue = plugin->get_irc_color (plugin, "blue"); /* return 2 */

Prototype: void input_color (t_weechat_plugin *plugin, int color, int start, int length) Add color in input buffer. Arguments: plugin: pointer to plugin structure color: color for text (if < 0, then input buffer is refresh, and there's no change in input buffer content) start: start position for color (if < 0, then mask is reinitialized) length: length for color (if <= 0, then mask is reinitialized) Return value: none. Example: plugin->input_color (plugin, plugin->get_irc_color (plugin, "blue"), 10, 5);

Prototype: t_plugin_window_info *get_window_info (t_weechat_plugin *plugin) Return list of WeeChat windows. Arguments: plugin: pointer to plugin structure Return value: linked list of WeeChat windows. Type Field Description int win_x horizontal position of window int win_y vertical position of window int win_width width of window int win_height height of window int win_width_pct width % (compared to parent window) int win_height_pct height % (compared to parent window) int num_buffer number of displayed buffer t_plugin_window_info * prev_window pointer to previous window info t_plugin_window_info * next_window pointer to next window info Note: result has to be free by a call to "free_window_info" function after use. Example: t_plugin_window_info *window_info, *ptr_window; window_info = plugin->get_window_info (plugin); if (window_info) { for (ptr_window = window_info; ptr_window; ptr_window = ptr_window->next_window) { plugin->print (plugin, NULL, NULL, "--- window info ---"); plugin->print (plugin, NULL, NULL, "(%d,%d), size: %dx%d, %%size: %d%%x%d%%", ptr_window->win_x, ptr_window->win_y, ptr_window->win_width, ptr_window->win_height, ptr_window->win_width_pct, ptr_window->win_height_pct); plugin->print (plugin, NULL, NULL, "num_buffer: %d", ptr_window->num_buffer); } plugin->free_window_info (plugin, window_info); } else plugin->print (plugin, NULL, NULL, "no window info!");

Prototype: void free_window_info (t_weechat_plugin *plugin, t_plugin_window_info *window_info) Free memory used by window info list. Arguments: plugin: pointer to plugin structure window_info: pointer to window info list returned by "get_window_info" function Return value: none. Example: plugin->free_window_info (plugin, window_info);

Prototype: t_plugin_buffer_info *get_buffer_info (t_weechat_plugin *plugin) Return list of WeeChat buffers. Arguments: plugin: pointer to plugin structure Return value: linked list of WeeChat buffers. Type Field Description int type buffer type: 0=standard, 1=dcc, 2=raw IRC data int number buffer number int num_displayed number of windows displaying buffer char * server_name server name for buffer (may be NULL) char * channel_name channel name for buffer (may be NULL) int notify_level notify level for buffer char * log_filename log filename (NULL means not logging) t_plugin_buffer_info * prev_buffer pointer to previous buffer info t_plugin_buffer_info * next_buffer pointer to next buffer info Note: result has to be free by a call to "free_buffer_info" function after use. Example: t_plugin_buffer_info *buffer_info, *ptr_buffer; buffer_info = plugin->get_buffer_info (plugin); if (buffer_info) { for (ptr_buffer = buffer_info; ptr_buffer; ptr_buffer = ptr_buffer->next_buffer) { plugin->print (plugin, NULL, NULL, "--- buffer info ---"); plugin->print (plugin, NULL, NULL, "type: %d", ptr_buffer->type); plugin->print (plugin, NULL, NULL, "number: %d", ptr_buffer->number); plugin->print (plugin, NULL, NULL, "num_displayed: %d", ptr_buffer->num_displayed); plugin->print (plugin, NULL, NULL, "server: %s", ptr_buffer->server_name); plugin->print (plugin, NULL, NULL, "channel: %s", ptr_buffer->channel_name); plugin->print (plugin, NULL, NULL, "notify level: %d", ptr_buffer->notify_level); plugin->print (plugin, NULL, NULL, "log filename: %s", ptr_buffer->log_filename); } plugin->free_buffer_info (plugin, buffer_info); } else plugin->print (plugin, NULL, NULL, "no buffer info!");

Prototype: void free_buffer_info (t_weechat_plugin *plugin, t_plugin_buffer_info *buffer_info) Free memory used by buffer info list. Arguments: plugin: pointer to plugin structure buffer_info: pointer to buffer info list returned by "get_buffer_info" function Return value: none. Example: plugin->free_buffer_info (plugin, buffer_info);

Prototype: t_plugin_buffer_data *get_buffer_info (t_weechat_plugin *plugin, char *server, char *channel) Return content of buffer. Arguments: plugin: pointer to plugin structure server: internal name of server channel: channel name Return value: buffer content (linked list of lines). Type Field Description char * nick nick char * data line content (color codes are removed) t_plugin_buffer_line * prev_line pointer to previous line t_plugin_buffer_line * next_line pointer to next line Note: result has to be free by a call to "free_buffer_data" function after use. Example: t_plugin_buffer_line *buffer_line, *ptr_line; buffer_line = plugin->get_buffer_data (plugin); if (buffer_line) { for (ptr_line = buffer_line; ptr_line; ptr_line = ptr_line->next_line) { plugin->print (plugin, NULL, NULL, "nick: %s, data: %s", ptr_line->nick, ptr_line->data); } plugin->free_buffer_data (plugin, buffer_line); }

Prototype: void free_buffer_data (t_weechat_plugin *plugin, t_plugin_buffer_line *buffer_line) Free memory used by buffer line list. Arguments: plugin: pointer to plugin structure buffer_line: pointer to buffer line list returned by "get_buffer_data" function Return value: none. Example: plugin->free_buffer_data (plugin, buffer_line);

Das Übersetzen braucht keine WeeChat-Quellen, aber die Datei "weechat-plugin.h". Um ein Plugin zu übersetzen, das aus einer Datei "toto.c" besteht (unter GNU/Linux): $ gcc -fPIC -Wall -c toto.c $ gcc -shared -fPIC -o libtoto.so toto.o

Kopiere die Datei "libtoto.so" in das Plugin-Verzeichnis der systemweiten Dateien WeeChats (zum Beispiel: "/usr/local/lib/weechat/plugins") oder in das Plugin-Verzeichnis des Users (zum Beispiel: "/home/xxxxx/.weechat/plugins"). In WeeChat: /plugin load toto

Vollständiges Beispiel eines Plugins, welches das Kommando /double implementiert, dass seine Argumente im gegenwärtigen Channel doppelt ausgibt (ok, das ist weniger nützlich, aber auch nur ein Beispiel!): #include <stdlib.h> #include "weechat-plugin.h" char plugin_name[] = "Double"; char plugin_version[] = "0.1"; char plugin_description[] = "Test plugin for WeeChat"; /* "/double" command manager */ int double_cmd (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer) { if (argv[2] && (argv[2][0] != '/')) { plugin->exec_command (plugin, NULL, NULL, argv[2]); plugin->exec_command (plugin, NULL, NULL, argv[2]); } return PLUGIN_RC_OK; } int weechat_plugin_init (t_weechat_plugin *plugin) { plugin->cmd_handler_add (plugin, "double", "Display two times a message", "msg", "msg: message to display two times", NULL, &double_cmd, NULL, NULL); return PLUGIN_RC_OK; } void weechat_plugin_end (t_weechat_plugin *plugin) { /* nothing done here */ }

Vier Plugins werden von WeeChat angeboten um Skriptsprachen zu nutzen: Perl, Python, Ruby und Lua.

Scripts are loaded and unloaded with /perl, /python, /ruby and /lua commands (type /help in WeeChat for help about commands). Skripte werden mit den Kommandos /perl, /python, /ruby und /lua geladen oder entfernt. (Benutze /help in WeeChat für Hilfe zu den Kommandos). Beispiele: Laden eines Perl-Skripts: /perl load /tmp/test.pl Liste alle geladenen Perl-Skripte auf: /perl Laden eines Python-Skripts: /python load /tmp/test.py Liste alle geladenen Python-Skripte auf: /python Laden eines Ruby-Skripts: /ruby load /tmp/test.rb Liste alle geladenen Ruby-Skripte auf: /ruby Laden eines Lua-Skripts: /lua load /tmp/test.lua Liste alle geladenen Lua-Skripte auf: /lua

In einem WeeChat-PerlSkript ist allen API-Funktionen und Variablen ein "weechat::" vorangestellt. Beispiel: weechat::register("test", "1.0", "end_test", "WeeChat perl script");

Ein WeeChat-Pythonskript muss mit einer Importdirektive für WeeChat beginnen: import weechat Allen API-Funktionen und Variablen ist ein "weechat." vorangestellt. Beispiel: weechat.register("test", "1.0", "end_test", "WeeChat python script")

In einem WeeChat-Rubyskript muss der gesamte Code innerhalb von Funktionen stehen. Für den Hauptteil ist die Funktion "weechat_init" zu definieren, die automatisch aufgerufen wird, wenn das Skript in WeeChat geladen wird. Beispiel: def weechat_init Weechat.register("test", "1.0", "end_test", "WeeChat ruby script") Weechat.add_command_handler("command", "my_command") return Weechat::PLUGIN_RC_OK end def my_command(server, args) Weechat.print("my command") return Weechat::PLUGIN_RC_OK end Allen API-Funktionen ist "Weechat." und Variablen "Weechat::" vorangestellt.

In einem WeeChat-Luaskript ist allen Funktionen ein "weechat." vorangestellt. Variablen beginnen mit "weechat." und enden mit "()". Beispiel: function message_handler(server, args) weechat.print("I am a message handler") return weechat.PLUGIN_RC_OK() end

Perl-Prototyp: weechat::register(name, version, end_function, description); Python-Prototyp: weechat.register(name, version, end_function, description) Ruby-Prototyp: Weechat.register(name, version, end_function, description) Lua-Prototyp: weechat.register(name, version, end_function, description) Das ist die erste Funktion, die in einem Skript aufgerufen wird. Alle WeeChat-Skripte müssen diese Funktion aufrufen. Argumente: name: eindeutiger Name des Skripts (jedes Skript muss einen eindeutigen Namen besitzen) version: Version des Skripts end_function: Funktion, die aufgerufen wird, wenn das Skript entfernt werden soll (optional; ein leerer String bedeutet, dass nichts aufgerufen wird) description: eine kurze Beschreibung des Skripts Rückgabewert: 1 wenn das Skript registriert werden konnte, 0 wenn ein Fehler aufgetaucht ist. Beispiele: # perl weechat::register("test", "1.0", "end_test", "Test script!"); # python weechat.register("test", "1.0", "end_test", "Test script!") # ruby Weechat.register("test", "1.0", "end_test", "Test script!") -- lua weechat.register("test", "1.0", "end_test", "Test script!")

Perl-Prototyp: weechat::print(message, [channel, [server]]) Python-Prototyp: weechat.prnt(message, [channel, [server]]) Ruby-Prototyp: Weechat.print(message, [channel, [server]]) Lua-Prototyp: weechat.print(message, [channel, [server]]) Sende eine Nachricht an einen WeeChat-Puffer, identifiziert durch Server und Channel. Argumente: message: Nachricht channel: Name des Channels, zu welchem der Puffer gehört, in dem die Nachricht angezeigt werden soll server: interner Name des Servers, zu welchem der Puffer gehört, in dem die Nachricht angezeigt werden soll Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist Beispiele: # perl weechat::print("message"); weechat::print("message", "#weechat"); weechat::print("message", "#weechat", "freenode"); # python weechat.prnt("message") weechat.prnt("message", "#weechat") weechat.prnt("message", "#weechat", "freenode") # ruby Weechat.print("message") Weechat.print("message", "#weechat") Weechat.print("message", "#weechat", "freenode") -- lua weechat.print("message") weechat.print("message", "#weechat") weechat.print("message", "#weechat", "freenode")

Perl-Prototyp: weechat::print_infobar(time, message); Python-Prototyp: weechat.print_infobar(time, message) Ruby-Prototyp: Weechat.print_infobar(time, message) Lua-Prototyp: weechat.print_infobar(time, message) Zeige eine Nachricht für einen festen Zeitraum in der Infobar. Argumente: time: Zeit (in sekunden) der Anzeige (0 = permanent) message: Nachricht Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist Beispiele: # perl weechat::print_infobar(5, "message"); # python weechat.print_infobar(5, "message") # ruby Weechat.print_infobar(5, "message") -- lua weechat.print_infobar(5, "message")

Perl-Prototyp: weechat::remove_infobar([count]); Python-Prototyp: weechat.remove_infobar([count]) Ruby-Prototyp: Weechat.remove_infobar([count]) Lua-Prototyp: weechat.remove_infobar([count]) Entfernt eine oder mehrere Nachrichten aus dem Infobar-Speicher. Argumente: count: Anzahl der Nachrichten, die entfernt werden sollen (Ist kein Argument angegeben oder <= 0 werden alle Nachrichten entfernt) Rückgabewert: 1 bei Erfolg, 0 bei Auftreten eines Fehlers Beispiele: # perl weechat::remove_infobar(1); # python weechat.remove_infobar(1) # ruby Weechat.remove_infobar(1) -- lua weechat.remove_infobar(1)

Perl-Prototyp: weechat::log(message, [channel, [server]]); Python-Prototyp: weechat.log(message, [channel, [server]]) Ruby-Prototyp: Weechat.log(message, [channel, [server]]) Lua-Prototyp: weechat.log(message, [channel, [server]]) Schreibe eine Nachricht in die Logdatei eines Servers oder Channels. Argumente: message: Nachricht channel: Name des Channels, zu welchem der Puffer der Logdatei gehört server: interner Name des Servers, zu welchem der Puffer der Logdatei gehört Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist. Beispiel: # perl weechat::log("message", "#weechat", "freenode"); # python weechat.log("message", "#weechat", "freenode") # ruby Weechat.log("message", "#weechat", "freenode") -- lua weechat.log("message", "#weechat", "freenode")

Perl-Prototyp: weechat::add_message_handler(message, function); Python-Prototyp: weechat.add_message_handler(message, function) Ruby-Prototyp: Weechat.add_message_handler(message, function) Lua-Prototyp: weechat.add_message_handler(message, function) Erzeuge einen Nachrichten-Handler, der bei Empfang einer IRC-Nachricht aufgerufen wird. Argumente: message: Name (Typ) der IRC-Nachricht. Für eine Liste der bekannten Typen von IRC-Nachrichten konsultieren sie bitte die RFCs 1459 und 2812. Mehr noch, sie können spezielle Ereignisse abfangen, indem sie einen speziellen Namen verwenden, der mit "weechat_" beginnt (siehe ). function: Funktion, die bei Empfang einer Nachricht aufgerufen werden soll Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist. Beispiele: # perl weechat::add_message_handler ("privmsg", "my_function"); sub my_function { weechat::print("server=$_[0]"); ($null, $channel, $message) = split ":",$_[1],3; ($mask, $null, $channel) = split " ", $channel; weechat::print("mask=$mask, channel=$channel, msg=$message"); return weechat::PLUGIN_RC_OK; } # python weechat.add_message_handler ("privmsg", "my_function") def my_function(server, args): weechat.prnt("server="+server) null, channel, message = string.split(args, ":", 2) mask, null, channel = string.split(string.strip(channel), " ", 2) weechat.prnt("mask="+mask+", canal="+channel+", message="+message) return weechat.PLUGIN_RC_OK # ruby Weechat.add_message_handler("privmsg", "my_function") def my_function(server, args) Weechat.print("server=#{server}, args=#{args}") return Weechat::PLUGIN_RC_OK end -- lua weechat.add_message_handler ("privmsg", "my_function") function my_function(server, args) weechat.print("server=" .. server .. ", args=" .. args) return weechat.PLUGIN_RC_OK() end Hinweis: die Funktion, die aufgerufen wird wenn eine Nachricht empfangen wurde, muss einen der folgenden Werte zurückgeben: PLUGIN_RC_KO: Funktion fehlgeschlagen PLUGIN_RC_OK: Funktion war erfolgreich PLUGIN_RC_OK_IGNORE_WEECHAT: Die Nachricht wird nicht an WeeChat übergeben PLUGIN_RC_OK_IGNORE_PLUGINS: Die Nachricht wird nicht an andere Plugins weitergegeben PLUGIN_RC_OK_IGNORE_ALL: Die Nachricht wird weder an WeeChat noch an andere Plugins übergeben

Perl-Prototyp: weechat::add_command_handler(command, function, [description, arguments, arguments_description, completion_template]); Python-Prototyp: weechat.add_command_handler(command, function, [description, arguments, arguments_description, completion_template]) Ruby-Prototyp: Weechat.add_command_handler(command, function, [description, arguments, arguments_description, completion_template]) Lua-Prototyp: weechat.add_command_handler(command, function, [description, arguments, arguments_description, completion_template]) Erzeugt einen Kommando-Handler, der aufgerufen wird, wenn der Anwender das Kommando benutzt (Beispiel: /command). Argumente: command: Name des neuen Kommandos, der auch Name eines bereits existierenden Kommandos sein kann (mit Bedacht zu verwenden, das ersetzte Kommando ist nicht verfügbar, bis das Plugin entfernt wurde) function: Funktion, die aufgerufen wird, wenn das Kommando ausgeführt wird arguments: eine kurze Beschreibung der Argumente des Kommandos (werden angezeigt bei /help command) arguments_description: eine ausführliche Beschreibung der Argumente des Kommandos (werden angezeigt bei /help command) completion_template: Vorlage für die Vervollständigung; zum Beispiel bedeutet "abc|%w def|%i", dass das erste Argument "abc" oder ein WeeChat-Kommando sein kann und das zweite Argument "def" oder ein IRC-Kommando. (siehe ) Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist Beispiele: # perl weechat::add_command_handler("command", "my_command"); sub my_command { weechat::print("server= $_[0], args: $_[1]"); return weechat::PLUGIN_RC_OK; } # python weechat.add_command_handler("command", "my_command") def my_command(server, args): weechat.prnt("server="+server+", args="+args) return weechat.PLUGIN_RC_OK # ruby Weechat.add_command_handler("command", "my_command") def my_command(server, args) Weechat.print("server=#{server}, args=#{args}") return Weechat::PLUGIN_RC_OK end -- lua weechat.add_command_handler("command", "my_command") def my_command(server, args) weechat.print("server="..server..", args="..args) return weechat.PLUGIN_RC_OK() end Hinweis: die Funktion, die aufgerufen wird wenn eine Nachricht empfangen wurde, muss einen der folgenden Werte zurückgeben: PLUGIN_RC_KO : Funktion ist fehlgeschlagen PLUGIN_RC_OK : Funktion war erfolgreich

Perl-Prototyp: weechat::add_timer_handler(message, function); Python-Prototyp: weechat.add_timer_handler(message, function) Ruby-Prototyp: Weechat.add_timer_handler(message, function) Lua-Prototyp: weechat.add_timer_handler(message, function) Erzeugt einen zeitgesteuerten Handler, der periodisch eine Funktion aufruft. Argumente: interval: Interval (in Sekunden) zwischen zwei Aufrufen der Funktion. function: Funktion, die aufgerufen wird Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist Beispiele: # perl weechat::add_timer_handler(60, "my_timer"); sub my_timer { weechat::print("this is timer handler"); return weechat::PLUGIN_RC_OK; } # python weechat.add_timer_handler(60, "my_timer") def my_timer(): weechat.prnt("this is timer handler") return weechat.PLUGIN_RC_OK # ruby Weechat.add_timer_handler(60, "my_timer") def my_timer() Weechat.print("this is timer handler") return Weechat::PLUGIN_RC_OK end -- lua weechat.add_timer_handler(60, "my_timer") function my_timer() weechat.print("this is timer handler) return weechat.PLUGIN_RC_OK() end Note: function called has to return one of following values: Hinweis: die Funktion, die aufgerufen wird, muss einen der folgenden Werte zurückgeben: PLUGIN_RC_KO: Funktion ist fehlgeschlagen PLUGIN_RC_OK: Funktion war erfolgreich completed

Perl-Prototyp: weechat::add_keyboard_handler(message, function); Python-Prototyp: weechat.add_keyboard_handler(message, function) Ruby-Prototyp: Weechat.add_keyboard_handler(message, function) Lua-Prototyp: weechat.add_keyboard_handler(message, function) Erzeugt einen Keyboard-Handler, der für jeden Tastendruck aufgerufen wird. Argumente: function: Funktion, die aufgerufen wird Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist Beispiele: # perl weechat::add_keyboard_handler("my_keyboard"); sub my_keyboard { my $key = shift; my $input_before = shift; my $input_after = shift; weechat::print("keyboard handler: key = '$key', " ."input before = '$input_before' " ."after = '$input_after'"); return weechat::PLUGIN_RC_OK; } # python weechat.add_keyboard_handler("my_keyboard") def my_keyboard(key, input_before, input_after): weechat.prnt("keyboard handler: key = '%s', " \ "input before = '%s' after = '%s'" %(key, input_before, input_after)) return weechat.PLUGIN_RC_OK # ruby Weechat.add_keyboard_handler("my_keyboard") def my_keyboard(server, input_before, input_after) Weechat.print("keyboard handler: key = '#{key}', " \ "input before = '#{input_before}' " \ "after = '#{input_after}'") return Weechat::PLUGIN_RC_OK end -- lua weechat.add_keyboard_handler("my_keyboard") function my_keyboard(server, input_before, input_after) weechat.print("keyboard handler: key = '"..key.. "', input before = '"..input_before.. "' after = '"..input_after.."'") return weechat.PLUGIN_RC_OK() end Hinweis: Die aufgerufene Funktion muss einen der folgenden Werte zurückgeben: PLUGIN_RC_KO: Funktion ist fehlgeschlagen PLUGIN_RC_OK: Funktion war erfolgreich

Perl-Prototyp: weechat::remove_handler(name, function); Python-Prototyp: weechat.remove_handler(name, function) Ruby-Prototyp: Weechat.remove_handler(name, function) Lua-Prototyp: weechat.remove_handler(name, function) Entfernt einen Nachrichten- oder Kommando-Handler. Argumente: name: Name der IRC-Message oder Kommando function: Funktion Rückgabewert: 1 bei Erfolg, 0 bei Auftreten eines Fehlers Beispiele: # perl weechat::remove_handler("command", "my_command"); # python weechat.remove_handler("command", "my_command") # ruby Weechat.remove_handler("command", "my_command") -- lua weechat.remove_handler("command", "my_command")

Perl-Prototyp: weechat::remove_timer_handler(function); Python-Prototyp: weechat.remove_timer_handler(function) Ruby-Prototyp: Weechat.remove_timer_handler(function) Lua-Prototyp: weechat.remove_timer_handler(function) Entfernt einen zeitgesteuerten Handler. Argumente: function: Funktion Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist Beispiele: # perl weechat::remove_timer_handler("my_timer"); # python weechat.remove_timer_handler("my_timer") # ruby Weechat.remove_timer_handler("my_timer") -- lua weechat.remove_timer_handler("my_timer")

Perl-Prototyp: weechat::remove_keyboard_handler(function); Python-Prototyp: weechat.remove_keyboard_handler(function) Ruby-Prototyp: Weechat.remove_keyboard_handler(function) Lua-Prototyp: weechat.remove_keyboard_handler(function) Entfernt einen Keyboard-Handler. Argumente: function: Funktion Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist. Beispiele: # perl weechat::remove_keyboard_handler("my_keyboard"); # python weechat.remove_keyboard_handler("my_keyboard") # ruby Weechat.remove_keyboard_handler("my_keyboard") -- lua weechat.remove_keyboard_handler("my_keyboard")

Perl-Prototyp: weechat::command(command, [channel, [server]]); Python-Prototyp: weechat.command(command, [channel, [server]]) Ruby-Prototyp: Weechat.command(command, [channel, [server]]) Lua-Prototyp: weechat.command(command, [channel, [server]]) Führt ein WeeChat-Kommando aus (oder sendet eine Nachricht an einen Channel). Argumente: command: Kommando channel: Name des Channels, für den das Kommando ausgeführt werden soll server: interner Name des Servers, für den das Kommando ausgeführt werden soll Rückgabewert: 1 bei Erfolg, 0 wenn ein Fehler aufgetreten ist Beispiele: # perl weechat::command("hello everybody!"); weechat::command("/kick toto please leave this channel", "#weechat"); weechat::command("/nick newnick", "", "freenode"); # python weechat.command("hello everybody!") weechat.command("/kick toto please leave this channel", "#weechat") weechat.command("/nick newnick", "", "freenode") # ruby Weechat.command("hello everybody!") Weechat.command("/kick toto please leave this channel", "#weechat") Weechat.command("/nick newnick", "", "freenode") -- lua weechat.command("hello everybody!") weechat.command("/kick toto please leave this channel", "#weechat") weechat.command("/nick newnick", "", "freenode")

Perl-Prototyp: weechat::get_info(name, [server]); Python-Prototyp: weechat.get_info(name, [server]) Ruby-Prototyp: Weechat.get_info(name, [server]) Lua-Prototyp: weechat.get_info(name, [server]) Gibt ein Info über WweeChat oder einen Channel zurück. Argumente: name: Name (Typ) des Infos, das gelesen werden soll (siehe ) server: interner Name des Servers Rückgabewert: angefragte Infos, oder leerer String, wenn ein Fehler aufgetreten ist. Beispiele: # perl $version = get_info("version"); $nick = get_info("nick", "freenode"); # python version = weechat.get_info("version") nick = weechat.get_info("nick", "freenode") # ruby version = Weechat.get_info("version") nick = Weechat.get_info("nick", "freenode") -- lua version = weechat.get_info("version") nick = weechat.get_info("nick", "freenode")

Perl-Prototyp: weechat::get_dcc_info(); Python-Prototyp: weechat.get_dcc_info() Ruby-Prototyp: Weechat.get_dcc_info() Lua-Prototyp: weechat.get_dcc_info() Gibt eine Liste der gegenwärtig aktiven oder beendeten DCCs zurück. Rückgabewert: Liste der DCCS (siehe ). Beispiele: # perl my @dccs = weechat::get_dcc_info(); if (@dccs) { foreach my $dcc (@dccs) { while (my ($key, $value) = each %$dcc) { weechat::print("$key = '$value'"); } } } else { weechat::print("no DCC"); } # python dccs = weechat.get_dcc_info() if dccs != None: if dccs == []: weechat.prnt("no DCC") else: for d in dccs: for b in d.keys(): weechat.prnt("%s = '%s'" %(b, d[b])) else: weechat.prnt("error while getting DCC") # ruby dccs = Weechat.get_dcc_info() if dccs != nil if dccs == [] Weechat.print("no DCC") else dccs.each do |m| m.each do |key, value| Weechat.print("#{key} = '#{value}'") end end end else Weechat.print("error while getting DCC") end -- lua dccs = weechat.get_dcc_info() if dccs ~= nil then if dccs then dcc, dccinfos = next (dccs, nil) while (dcc) do key, value = next (dccinfos, nil) while (key) do weechat.print(key.." = '"..value.."'") key, value = next (dccinfos, key) end dcc, dccinfos = next (dccs, dcc) end else weechat.print("no DCC") end else weechat.print("error while getting DCC") end

Perl-Prototyp: weechat::get_server_info(); Python-Prototyp: weechat.get_server_info() Ruby-Prototyp: Weechat.get_server_info() Lua-Prototyp: weechat.get_server_info() Gibt eine Liste der IRC-Server zurück (verbunden oder nicht). Rückgabewert: Liste der Server (siehe ). Beispiele: # perl my $servers = weechat::get_server_info(); if ($servers) { while (my ($srvname, $srvinfos) = each %$servers) { while ( my ($key, $value) = each %$srvinfos) { weechat::print("$srvname -> $key = '$value'"); } } } else { weechat::print("no server"); } # python servers = weechat.get_server_info() if servers != None: if servers == {}: weechat.prnt("no server") else: for s in servers: for i in servers[s]: weechat.prnt("%s -> %s = '%s'" % (s, i, str(servers[s][i]))) else: weechat.prnt("error while getting servers") # ruby servers = Weechat.get_server_info() if servers != nil if servers == [] Weechat.print("no server") else servers.each do |n, s| s.each do |key, value| Weechat.print("#{n} -> #{key} = '#{value}'") end end end else Weechat.print("error while getting servers") end -- lua servers = weechat.get_server_info() if servers ~= nil then if servers then srv, srvinfos = next (servers, nil) while (srv) do key, value = next (srvinfos, nil) while (key) do weechat.print(srv.." -> "..key.." = '"..value.."'") key, value = next (srvinfos, key) end srv, srvinfos = next (servers, srv) end else weechat.print("no server") end else weechat.print("error while getting servers") end

Perl-Prototyp: weechat::get_channel_info(server); Python-Prototyp: weechat.get_channel_info(server) Ruby-Prototyp: Weechat.get_channel_info(server) Lua-Prototyp: weechat.get_channel_info(server) Gibt eine Liste der Channels für einen Server zurück. Rückgabewert: Liste der Channel für einen Server (siehe ). Beispiele: # perl my $channels = weechat::get_channel_info(weechat::get_info("server")); if ($channels) { while (my ($channame, $chaninfos) = each %$channels) { while (my ($key, $value) = each %$chaninfos) { weechat::print("$channame -> $key = '$value'"); } } } else { weechat::print("no channel"); } # python chans = weechat.get_channel_info(weechat.get_info("server")) if chans != None: if chans == {}: weechat.prnt("no channel") else: for s in chans: for i in chans[s]: weechat.prnt("%s -> %s = '%s'" % (s, i, str(chans[s][i]))) else: weechat.prnt("error while getting channels") # ruby channels = Weechat.get_channel_info(Weechat.get_info("server")) if channels != nil if channels == {} Weechat.print("no channel") else channels.each do |n, c| c.each do |key, value| Weechat.print("#{n} -> #{key} = '#{value}'") end end end else Weechat.print("error while getting channels") end -- lua chans = weechat.get_channel_info(weechat.get_info("server")) if chans ~= nil then if chans then chan, chaninfos = next (chans, nil) while (chan) do key, value = next (chaninfos, nil) while (key) do weechat.print(chan.." -> "..key.." = '"..value.."'") key, value = next (chaninfos, key) end chan, chaninfos = next (chans, chan) end else weechat.print("no channel") end else weechat.print("error while getting channels") end

Perl-Prototyp: weechat::get_nick_info(server, channel); Python-Prototyp: weechat.get_nick_info(server, channel) Ruby-Prototyp: Weechat.get_nick_info(server, channel) Lua-Prototyp: weechat.get_nick_info(server, channel) Gibt eine Liste der Nicknamen für einen Channel zurück. Rückgabewert: Liste der Nicknamen eines Channels (siehe ). Beispiele: # perl my $nicks = weechat::get_nick_info("freenode", "#weechat"); if ($nicks) { while (my ($nickname, $nickinfos) = each %$nicks) { while ( my ($key, $value) = each %$nickinfos) { weechat::print("$nickname -> $key = '$value'"); } } } else { weechat::print("no nick"); } # python nicks = weechat.get_nick_info("freenode", "#weechat") if nicks != None: if nicks == {}: weechat.prnt("no nick") else: for n in nicks: for f in nicks[n]: weechat.prnt("%s -> %s = '%s'" % (n, f, str(nicks[n][f]))) else: weechat.prnt("error while getting nicks") # ruby nicks = Weechat.get_nick_info("freenode", "#weechat") if nicks != nil if nicks == {} Weechat.print("no nick") else nicks.each do |nk, nattr| nattr.each do |key, value| Weechat.print("#{nk} -> #{key} = '#{value}'") end end end else Weechat.print("error while getting nicks") end -- lua nicks = weechat.get_nick_info("freenode", "#weechat") if nicks ~= nil then if nicks then nick, nickinfos = next (nicks, nil) while (nick) do key, value = next (nickinfos, nil) while (key) do weechat.print(nick.." -> "..key.." = '"..value.."'") key, value = next (nickinfos, key) end nick, nickinfos = next (nicks, nick) end else weechat.print("no nick") end else weechat.print("error while getting nicks") end

Perl-Prototyp: weechat::get_config(option); Python-Prototyp: weechat.get_config(option) Ruby-Prototyp: Weechat.get_config(option) Lua-Prototyp: weechat.get_config(option) Gibt den Wert einer Option der WeeChat-Konfiguration zurück. Argumente: option: Name der Option Rückgabewert: Wert der Option, leerer String wenn nichts gefunden wurde. Beispiele: # perl $value1 = weechat::get_config("look_nicklist"); $value2 = weechat::get_config("freenode.server_autojoin"); # python value1 = weechat.get_config("look_nicklist") value2 = weechat.get_config("freenode.server_autojoin") # ruby value1 = Weechat.get_config("look_nicklist") value2 = Weechat.get_config("freenode.server_autojoin") -- lua value1 = weechat.get_config("look_nicklist") value2 = weechat.get_config("freenode.server_autojoin")

Perl-Prototyp: weechat::set_config(option, value); Python-Prototyp: weechat.set_config(option, value) Ruby-Prototyp: Weechat.set_config(option, value) Lua-Prototyp: weechat.set_config(option, value) Setze den Wert einer Option der WeeChat-Konfiguration. Argumente: option: Name der Option, die gesetzt werden soll value: neuer Wert der Option Rückgabewert: 1 wenn der Wert gesetzt wurde, 0 wenn ein Fehler aufgetreten ist. Beispiele: # perl weechat::set_config("look_nicklist", "off"); weechat::set_config("freenode.server_autojoin, "#weechat"); # python weechat.set_config("look_nicklist", "off") weechat.set_config("freenode.server_autojoin, "#weechat") # ruby Weechat.set_config("look_nicklist", "off") Weechat.set_config("freenode.server_autojoin, "#weechat") -- lua weechat.set_config("look_nicklist", "off") weechat.set_config("freenode.server_autojoin, "#weechat")

Perl-Prototyp: weechat::get_plugin_config(option); Python-Prototyp: weechat.get_plugin_config(option) Ruby-Prototyp: Weechat.get_plugin_config(option) Lua-Prototyp: weechat.get_plugin_config(option) Gibt den Wert einer Option eines Plugins zurück. Die Option wird aus der Datei "~/.weechat/plugins.rc" gelesen und sieht so aus: "plugin.option=value" (Hinweis: Der Name des Plugins wird automatisch gesetzt). Argumente: option: Name der zu lesenden Option Rückgabewert: Wert der Option, leerer String wenn die Option nicht gefunden wurde. Beispiele: # perl $value = weechat::get_plugin_config("my_var"); # python value = weechat.get_plugin_config("my_var") # ruby value = Weechat.get_plugin_config("my_var") -- lua value = weechat.get_plugin_config("my_var")

Perl-Prototyp: weechat::set_plugin_config(option, value); Python-Prototyp: weechat.set_plugin_config(option, value) Ruby-Prototyp: Weechat.set_plugin_config(option, value) Lua-Prototyp: weechat.set_plugin_config(option, value) Setzt den Wert einer Option eines Plugins. Die Option bzw. ihr Wert wird in "~/.weechat/plugins.rc" geschrieben und sieht so aus: "plugin.option=value" (Hinweis: der Name des Plugins wird automatisch gesetzt). Argumente: option: Name der Option, die gesetzt werden soll value: Der neue Wert der Option Rückgabewert: 1 wenn die Option gesetzt wurde, 0 wenn ein Fehler aufgetreten ist. Beispiele: # perl weechat::set_plugin_config("my_var", "value"); # python weechat.set_plugin_config("my_var", "value") # ruby Weechat.set_plugin_config("my_var", "value") -- lua weechat.set_plugin_config("my_var", "value")

Perl prototype: weechat::get_irc_color(color); Python prototype: weechat.get_irc_color(color) Ruby prototype: Weechat.get_irc_color(color) Lua prototype: weechat.get_irc_color(color) Return IRC color index with name. Return value: IRC color index, -1 if color is not found (see ). Examples: # perl my $color_blue = weechat::get_irc_color("blue"); # python color_blue = weechat.get_irc_color("blue") # ruby color_blue = Weechat.get_irc_color("blue") -- lua color_blue = weechat.get_irc_color("blue")

Perl prototype: weechat::input_color(color); Python prototype: weechat.input_color(color) Ruby prototype: Weechat.input_color(color) Lua prototype: weechat.input_color(color) Add color in input buffer. Return value: none. Examples: # perl weechat::input_color(weechat::get_irc_color("blue"), 10, 5); # python weechat.input_color(weechat.get_irc_color("blue"), 10, 5) # ruby Weechat.input_color(Weechat.get_irc_color("blue"), 10, 5) -- lua weechat.input_color(weechat.get_irc_color("blue"), 10, 5)

Perl prototype: weechat::get_window_info(); Python prototype: weechat.get_window_info() Ruby prototype: Weechat.get_window_info() Lua prototype: weechat.get_window_info() Return list of WeeChat windows. Return value: list of WeeChat windows (see ). Examples: # perl my @wf = weechat::get_window_info(); if (@wf) { weechat::print("**** windows infos ****"); foreach my $w (@wf) { while ( my ($key, $value) = each %$w) { weechat::print(" > $key => $value"); } weechat::print("----------------------"); } } else { weechat::print("**** no window info ****"); } # python wf = weechat.get_window_info() if wf != None and wf != []: weechat.prnt ("**** windows infos ****") for w in wf: for i in w: weechat.prnt (" > %s => %s" % (i, w[i])) weechat.prnt ("----------------------") else: weechat.prnt ("**** no window info ****") # ruby wf = Weechat.get_window_info() if wf != nil and wf != [] Weechat.print("**** windows infos ****") wf.each do |w| w.each do |key, value| Weechat.print(" > #{key} => #{value}") end Weechat.print("----------------------") end else Weechat.print("**** no window info ****") end -- lua wf = weechat.get_window_info() if wf then weechat.print ("**** windows infos ****") w, winfos = next (wf, nil) while (w) do key, value = next (winfos, nil) while (key) do weechat.print(" > " .. key .. " => " .. value) key, value = next (winfos, key) end weechat.print ("----------------------") w, winfos = next (wf, w) end else weechat.print("**** no window info ****") end

Perl prototype: weechat::get_buffer_info(); Python prototype: weechat.get_buffer_info() Ruby prototype: Weechat.get_buffer_info() Lua prototype: weechat.get_buffer_info() Return list of WeeChat buffers. Return value: list of WeeChat buffers (see ). Examples: # perl my $bf = weechat::get_buffer_info(); if ($bf) { while ( my ($nobuf, $binfos) = each %$bf) { while ( my ($key, $value) = each %$binfos) { weechat::print(" > $key => $value"); } } } else { weechat::print("**** no buffer info ****"); } # python bf = weechat.get_buffer_info() if bf != None and bf != {}: for b in bf: weechat.prnt ("**** info for buffer no %d ****" % b) for c in bf[b]: weechat.prnt (" > %s => %s" % (c, bf[b][c])) else: weechat.prnt ("**** no buffer info ****") # ruby bf = Weechat.get_buffer_info() if bf != nil and bf != {} bf.each do |n, c| Weechat.print("**** info for buffer no #{n} ****") c.each do |key, value| Weechat.print(" > #{key} => #{value}") end end else Weechat.print("**** no buffer info ****") end -- lua bf = weechat.get_buffer_info() if bf then b, binfos = next (bf, nil) while (b) do weechat.print("**** info for buffer no " .. b .. " ****") key, value = next (binfos, nil) while (key) do weechat.print(" > " .. key .. " => " .. value) key, value = next (binfos, key) end b, infos = next (bf, b) end else weechat.print("**** no buffer info ****") end

Perl prototype: weechat::get_buffer_data(server, channel); Python prototype: weechat.get_buffer_data(server, channel) Ruby prototype: Weechat.get_buffer_data(server, channel) Lua prototype: weechat.get_buffer_data(server, channel) Return content of buffer. Return value: list of lines for buffer (see ). Examples: # perl my $server = "freenode"; my $channel = "#weechat"; my @bc = weechat::get_buffer_data($server, $channel); if (@bc) { weechat::print("**** buffer data for $channel@$server ****"); foreach my $l (@bc) { while ( my ($key, $value) = each %$l) { weechat::print(" > $key => $value"); } weechat::print("----------------------"); } } else { weechat::print("**** no buffer data ****"); } # python server = "freenode" channel = "#weechat" bc = weechat.get_buffer_data(server, channel) if bc != None and bc != []: weechat.prnt ("**** buffer data for %s@%s ****" % (channel, server)) for l in bc: for i in l: weechat.prnt (" > %s => %s" % (i, l[i])) weechat.prnt ("----------------------") else: weechat.prnt ("**** no buffer data ****") # ruby server = "freenode" channel = "#weechat" bc = Weechat.get_buffer_data(server, channel) if bc != nil and bc != [] Weechat.print("**** buffer data for #{channel}@#{server} ****") bc.each do |l| l.each do |key, value| Weechat.print(" > #{key} => #{value}") end Weechat.print("----------------------") end else Weechat.print("**** no buffer data ****") end -- lua server = "freenode" channel = "#weechat" bc = weechat.get_buffer_data(server, channel) if bc then b, bdatas = next (bc, nil) weechat.print("**** buffer data for " .. channel .. "@" .. server .. " ****") while (b) do key, value = next (chaninfos, nil) while (key) do weechat.print(" > " .. key .. " => " .. value) key, value = next (bdatas, key) end weechat.print ("----------------------") b, bdatas = next (bc, b) end else weechat.print("**** no buffer data ****") end

Dieses Kapitel listet Autoren und Beitragende für WeeChat auf, und zeigt die Möglichkeiten um Support zu bekommen.

WeeChat wird entwickelt von: FlashCode (Sébastien Helleu) flashcode AT flashtux.org - Hauptentwickler Kolter kolter AT free.fr - Entwickler Ptitlouis ptitlouis AT sysif.net - erzeugt Debian-Pakete

Die folgenden Personen trugen zur Entwicklung von WeeChat bei: Jiri Golembiovsky - Tschechische Übersetzung, Patches Rudolf Polzer - Patches Jim Ramsay - Patches Odin - SuSE RPM Pistos - Patches Gwenn - Patches voroskoi - Ungarische Übersetzung Frank Zacharias - Deutsch Übersetzung Pavel Shevchuk - Russisch Übersetzung

Bevor Sie nach Support fragen, sollten Sie die Dokumentation und die FAQ gelesen haben, die bei WeeChat angeboten wird. (Die Dokumentation ist dieses Dokument, wenn Sie sie nicht bis zu dieser Zeile gelesen haben, sollten Sie sie noch Mal lesen!) IRC: Server "irc.freenode.net", Channel "#weechat" WeeChat Forum: http://forums.flashtux.org Mailingliste: Zum abonnieren: http://mail.nongnu.org/mailman/listinfo/weechat-support Um eine Mail an die Liste zu senden: weechat-support@nongnu.org Das Archiv der Mailingliste ist hier: http://mail.nongnu.org/archive/html/weechat-support