summaryrefslogtreecommitdiff
path: root/doc/de/weechat_scripting.de.txt
diff options
context:
space:
mode:
authorSebastien Helleu <flashcode@flashtux.org>2013-11-04 21:41:34 +0100
committerSebastien Helleu <flashcode@flashtux.org>2013-11-04 21:41:34 +0100
commite3c63849720f968b6ef4087a137b693b0f7f1481 (patch)
tree0693ee54c773580c590a1679be98e36a3cbc4d99 /doc/de/weechat_scripting.de.txt
parentf5a65c9b2ba45e20b2f7fe118961fd04c9b2466f (diff)
downloadweechat-e3c63849720f968b6ef4087a137b693b0f7f1481.zip
doc: use one line titles and less chars for delimited blocks/tables in asciidoc files
Diffstat (limited to 'doc/de/weechat_scripting.de.txt')
-rw-r--r--doc/de/weechat_scripting.de.txt302
1 files changed, 130 insertions, 172 deletions
diff --git a/doc/de/weechat_scripting.de.txt b/doc/de/weechat_scripting.de.txt
index c68a13ded..59a1699cd 100644
--- a/doc/de/weechat_scripting.de.txt
+++ b/doc/de/weechat_scripting.de.txt
@@ -1,5 +1,4 @@
-WeeChat Scripting Guide
-=======================
+= WeeChat Scripting Guide
Sébastien Helleu <flashcode@flashtux.org>
@@ -10,8 +9,7 @@ http://weechat.org/doc
[[introduction]]
-Einleitung
-----------
+== Einleitung
WeeChat (Wee Enhanced Environment for Chat) ist ein freier, schneller und
schlanker Chat-Client der für viele Betriebssysteme entwickelt wird.
@@ -31,28 +29,23 @@ Beinahe alle Beispiele in dieser Dokumentation beziehen sich auf Python.
Allerdings ist die API für alle Skriptsprachen nahezu identisch.
[[scripts_in_weechat]]
-Skripten in WeeChat
--------------------
+== Skripten in WeeChat
[[languages_specifities]]
-Besonderheiten der einzelnen Skriptsprachen
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+=== Besonderheiten der einzelnen Skriptsprachen
-Python
-^^^^^^
+==== Python
* WeeChat muss als Modul eingebunden werden: `import weechat`
* Um die WeeChat Funktion `print*` nutzen zu können muss `prnt*` genutzt
werden ('print' ist ein reservierter Befehl von Python!)
* Funktionen werden im Format `weechat.xxx(arg1, arg2, ...)` ausgeführt
-Perl
-^^^^
+==== Perl
* Funktionen werden im Format `weechat::xxx(arg1, arg2, ...);` ausgeführt
-Ruby
-^^^^
+==== Ruby
* Es muss 'weechat_init' definiert und darin die Funktion 'register' ausgeführt werden
* Funktionen werden im Format `Weechat.xxx(arg1, arg2, ...)` ausgeführt
@@ -61,23 +54,20 @@ Ruby
(3 Callbacks + 3 Data Strings), somit sieht ein Aufruf der Funktion folgendermaßen aus:
[source,ruby]
-----------------------------------------
+----
Weechat.config_new_option(config, section, "name", "string", "description of option", "", 0, 0,
"value", "value", 0, ["check_cb", "", "change_cb", "", "delete_cb", ""])
-----------------------------------------
+----
-Lua
-^^^
+==== Lua
* Funktionen werden im Format `weechat.xxx(arg1, arg2, ...)` ausgeführt
-Tcl
-^^^
+==== Tcl
* Funktionen werden im Format `weechat::xxx arg1 arg2 ...` ausgeführt
-Guile (scheme)
-^^^^^^^^^^^^^^
+==== Guile (scheme)
* Funktionen werden im Format `(weechat:xxx arg1 arg2 ...)` ausgeführt
* folgende Funktionen nutzen eine Liste von Argumente (anstelle von vielen
@@ -88,8 +78,7 @@ Guile (scheme)
** bar_new
[[register_function]]
-Die "Register" Funktion
-~~~~~~~~~~~~~~~~~~~~~~~
+=== Die "Register" Funktion
Jedes WeeChat Skript muss sich bei WeeChat "registrieren". Die "register" Funktion
muss deshalb der erste WeeChat Befehl sein der durch das Skript genutzt wird.
@@ -97,9 +86,9 @@ muss deshalb der erste WeeChat Befehl sein der durch das Skript genutzt wird.
Prototyp:
[source,python]
-----------------------------------------
+----
weechat.register(Name, Author, Version, Lizenz, Beschreibung, Shutdown_Funktion, Zeichensatz)
-----------------------------------------
+----
Argumente:
@@ -118,101 +107,99 @@ Beispielskripten, für jede Sprache:
* python:
[source,python]
-----------------------------------------
+----
import weechat
weechat.register("test_python", "FlashCode", "1.0", "GPL3", "Test Skript", "", "")
weechat.prnt("", "Hallo, von einem python Skript!")
-----------------------------------------
+----
* perl:
[source,perl]
-----------------------------------------
+----
weechat::register("test_perl", "FlashCode", "1.0", "GPL3", "Test Skript", "", "");
weechat::print("", "Hallo, von einem perl Skript!");
-----------------------------------------
+----
* ruby:
[source,ruby]
-----------------------------------------
+----
def weechat_init
Weechat.register("test_ruby", "FlashCode", "1.0", "GPL3", "Test Skript", "", "")
Weechat.print("", "Hallo, von einem ruby Skript!")
return Weechat::WEECHAT_RC_OK
end
-----------------------------------------
+----
* lua:
[source,lua]
-----------------------------------------
+----
weechat.register("test_lua", "FlashCode", "1.0", "GPL3", "Test Skript", "", "")
weechat.print("", "Hallo, von einem lua Skript!")
-----------------------------------------
+----
* tcl:
[source,tcl]
-----------------------------------------
+----
weechat::register "test_tcl" "FlashCode" "1.0" "GPL3" "Test Skript" "" ""
weechat::print "" "Hallo, von einem tcl Skript!"
-----------------------------------------
+----
* guile (scheme):
[source,lisp]
-----------------------------------------
+----
(weechat:register "test_scheme" "FlashCode" "1.0" "GPL3" "Test script" "" "")
(weechat:print "" "Hello, from scheme script!")
-----------------------------------------
+----
[[load_script]]
-Laden von Skripten
-~~~~~~~~~~~~~~~~~~
+=== Laden von Skripten
Es wird empfohlen die "script" Erweiterung zum Laden von Skripten zu
nutzen, zum Beispiel:
-----------------------------------------
+----
/script load script.py
/script load script.pl
/script load script.rb
/script load script.lua
/script load script.tcl
/script load script.scm
-----------------------------------------
+----
Es besteht natürlich weiterhin die Möglichkeit, individuell für jede
Skriptsprache, den entsprechenden Befehl zu nutzen:
-----------------------------------------
+----
/python load python/skript.py
/perl load perl/skript.pl
/ruby load ruby/skript.rb
/lua load lua/skript.lua
/tcl load tcl/skript.tcl
/guile load guile/skript.scm
-----------------------------------------
+----
Um Skripten automatisch beim Start von WeeChat zu laden sollte man einen Link
anlegen, der in das Verzeichnis 'Skriptsprache/autoload' zeigt.
Ein Beispiel für ein Python-Skript:
-----------------------------------------
+----
$ cd ~/.weechat/python/autoload
$ ln -s ../script.py
-----------------------------------------
+----
[NOTE]
Installiert man mittels `/script install` ein Skript, dann wird automatisch
ein Link in das entsprechende 'autoload' Verzeichnis erzeugt.
[[differences_with_c_api]]
-Unterschiede zur C API
-----------------------
+== Unterschiede zur C API
Die Skripten API ist nahezu identisch mit der API der C Erweiterung.
Um einen Überblick über alle API Funktionen (Prototyp, Argumente,
@@ -226,28 +213,27 @@ wird.
Falls Ihr Skript 'test.py' eine WeeChat API Funktion aufruft wird der Aufruf
wie folgt abgearbeitet:
-........................................
+....
┌──────────────────────┐ ╔══════════════════╗
│ python Erweiterung │ ║ WeeChat "core" ║
├────────────┬─────────┤ ╟─────────┐ ║
test.py ─────► │ Skript API │ C API │ ─────► ║ C API │ ║
└────────────┴─────────┘ ╚═════════╧════════╝
-........................................
+....
Gibt WeeChat einen Rückgabewert an Ihr Skript 'test.py' zurück wird der
Aufruf in umgekehrter Reihenfolge abgearbeitet:
-........................................
+....
╔══════════════════╗ ┌──────────────────────┐
║ WeeChat "core" ║ │ python Erweiterung │
║ ┌─────────╢ ├─────────┬────────────┤
║ │ C API ║ ─────► │ C API │ Skript API │ ─────► test.py
╚════════╧═════════╝ └─────────┴────────────┘
-........................................
+....
[[pointers]]
-Pointer
-~~~~~~~
+=== Pointer
Wie Sie vermutlich wissen existieren in Skripten keine "Pointer". Sendet nun
die API Funktion einen Pointer als Rückgabewert an das Skript, dann wird der
@@ -264,9 +250,9 @@ Ein leerer String oder "0x0" sind hierbei erlaubt. Beides wird in C als NULL int
Im folgenden ein Beispiel um Daten im Core Buffer (WeeChat Hauptbuffer) auszugeben:
[source,python]
-----------------------------------------
+----
weechat.prnt("", "Hi!")
-----------------------------------------
+----
[WARNING]
Aus Gründen der Geschwindigkeit wird in vielen Funktionen darauf verzichtet
@@ -275,8 +261,7 @@ einen gültigen Pointer zu übergeben. Sollten Sie dies nicht beachten dann werd
Sie mit einem netten Crash-Report belohnt ;)
[[callbacks]]
-Callbacks
-~~~~~~~~~
+=== Callbacks
Beinahe alle WeeChat Callbacks müssen entweder WEECHAT_RC_OK oder WEECHAT_RC_ERROR als
Ergebnis zurück liefern. Eine Ausnahme bildet das modifier Callback, hier wird ein
@@ -291,18 +276,18 @@ callback Beispiele, für jede Skriptsprache:
* python:
[source,python]
-----------------------------------------
+----
def timer_cb(data, remaining_calls):
weechat.prnt("", "timer! data=%s" % data)
return weechat.WEECHAT_RC_OK
weechat.hook_timer(1000, 0, 1, "timer_cb", "test")
-----------------------------------------
+----
* perl:
[source,perl]
-----------------------------------------
+----
sub timer_cb {
my ($data, $remaining_calls) = @_;
weechat::print("", "timer! data=$data");
@@ -310,71 +295,69 @@ sub timer_cb {
}
weechat::hook_timer(1000, 0, 1, "timer_cb", "test");
-----------------------------------------
+----
* ruby:
[source,ruby]
-----------------------------------------
+----
def timer_cb(data, remaining_calls)
Weechat.print("", "timer! data=#{data}");
return Weechat::WEECHAT_RC_OK
end
Weechat.hook_timer(1000, 0, 1, "timer_cb", "test");
-----------------------------------------
+----
* lua:
[source,lua]
-----------------------------------------
+----
function timer_cb(data, remaining_calls)
weechat.print("", "timer! data="..data)
return weechat.WEECHAT_RC_OK
end
weechat.hook_timer(1000, 0, 1, "timer_cb", "test")
-----------------------------------------
+----
* tcl:
[source,tcl]
-----------------------------------------
+----
proc timer_cb { data remaining_calls } {
weechat::print {} "timer! data=$data"
return $::weechat::WEECHAT_RC_OK
}
weechat::hook_timer 1000 0 1 timer_cb test
-----------------------------------------
+----
* guile (scheme):
[source,lisp]
-----------------------------------------
+----
(define (timer_cb data remaining_calls)
(weechat:print "" (string-append "timer! data=" data))
weechat:WEECHAT_RC_OK
)
(weechat:hook_timer 1000 0 1 "timer_cb" "test")
-----------------------------------------
+----
[[script_api]]
-Skript API
-----------
+== Skript API
Um weiterführende Informationen zu den API Funktionen zu erhalten
lesen Sie bitte 'WeeChat Plugin API Reference'.
[[script_api_functions]]
-Funktionen
-~~~~~~~~~~
+=== Funktionen
Liste der Skript API Funktionen:
[width="100%",cols="^1,10",options="header"]
-|========================================
+|===
| Kategorie | Funktionen
| Allgemein |
register
@@ -451,16 +434,15 @@ Liste der Skript API Funktionen:
hdata_pointer, hdata_time, hdata_hashtable, hdata_update, hdata_get_string
| Upgrade |
upgrade_new, upgrade_write_object, upgrade_read, upgrade_close
-|========================================
+|===
[[script_api_constants]]
-Konstanten
-~~~~~~~~~~
+=== Konstanten
Liste der Konstanten in Skript API:
[width="100%",cols="^1,10",options="header"]
-|========================================
+|===
| Kategorie | Konstanten
| return codes |
WEECHAT_RC_OK, WEECHAT_RC_OK_EAT, WEECHAT_RC_ERROR
@@ -488,23 +470,20 @@ Liste der Konstanten in Skript API:
WEECHAT_HOOK_CONNECT_SOCKET_ERROR
| hook Signal |
WEECHAT_HOOK_SIGNAL_STRING, WEECHAT_HOOK_SIGNAL_INT, WEECHAT_HOOK_SIGNAL_POINTER
-|========================================
+|===
[[common_tasks]]
-Gemeinschaftsaufgabe
---------------------
+== Gemeinschaftsaufgabe
Dieses Kapitel beinhaltet einige Aufgaben mit Lösungsbeispielen.
Die Skript API wird dabei nur sehr oberflächlich besprochen.Um eine vollständige
Übersicht aller Befehle zu erhalten nutzen Sie bitte die 'WeeChat Plugin API Reference'.
[[buffers]]
-Buffer
-~~~~~~
+=== Buffer
[[buffers_display_messages]]
-Nachrichten anzeigen
-^^^^^^^^^^^^^^^^^^^^
+==== Nachrichten anzeigen
Eine leere Zeichenkette wird häufig verwendet um den WeeChat Core Buffer zu nutzen.
Möchten Sie einen anderen Buffer nutzen dann muss der Pointer dieses Buffers verwendet
@@ -513,7 +492,7 @@ werden (Übergabe als String, siehe <<pointers,Pointer>>).
Beispiele:
[source,python]
-----------------------------------------
+----
# Gibt den Text "Hallo" im Core Buffer aus
weechat.prnt("", "Hallo")
@@ -540,14 +519,13 @@ weechat.prnt(buffer, "Nachricht im #weechat Channel")
# (bitte beachten Sie dass der Server- und Channelname durch ein Komma zu trennen sind)
buffer = weechat.info_get("irc_buffer", "freenode,#weechat")
weechat.prnt(buffer, "Nachricht im #weechat Channel")
-----------------------------------------
+----
[NOTE]
Die print Funktion heißt in Perl/Ruby/Lua/Tcl `print`. In Python lautet die Funktion `prnt`.
[[buffers_send_text]]
-Text in einen Buffer senden
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
+==== Text in einen Buffer senden
Sie können einen Text oder einen Befehl in einen Buffer senden. Dies entspricht exakt dem
Verhalten als ob Sie einen Text oder einen Befehl in die Befehlszeile eingeben und selbigen
@@ -556,18 +534,17 @@ mit der [Eingabe] Taste bestätigen.
Beispiele:
[source,python]
-----------------------------------------
+----
# führt den Befehl "/help" im aktuellen Buffer aus (die Ausgabe erfolgt im Core-Buffer)
weechat.command("", "/help")
# sendet den Text "Hallo" in den IRC Channel #weechat (die Teilnehmer des Channels sehen diese Nachricht)
buffer = weechat.info_get("irc_buffer", "freenode,#weechat")
weechat.command(buffer, "Hallo")
-----------------------------------------
+----
[[buffers_new]]
-neuen Buffer öffnen
-^^^^^^^^^^^^^^^^^^^
+==== neuen Buffer öffnen
Sie können aus Ihrem Skript einen neuen Buffer öffnen um dort Nachrichten auszugeben.
@@ -579,7 +556,7 @@ wenn `/buffer close` genutzt wurde).
Beispiele:
[source,python]
-----------------------------------------
+----
# Callback falls Daten aus der Eingabezeile empfangen wurden
def buffer_input_cb(data, buffer, input_data):
# ...
@@ -598,11 +575,10 @@ weechat.buffer_set(buffer, "Titel", "Dies ist die Überschrift für meinen Buffe
# deaktiviert die Protokollierung. Dazu wird die lokale Variable "no_log" auf "1" gesetzt
weechat.buffer_set(buffer, "localvar_set_no_log", "1")
-----------------------------------------
+----
[[buffers_properties]]
-Eigenschaften von Buffern
-^^^^^^^^^^^^^^^^^^^^^^^^^
+==== Eigenschaften von Buffern
Die verschiedenen Eigenschaften von Buffern können in Form eines Strings, Integer oder als Pointer
vorliegen und gelesen werden.
@@ -610,19 +586,19 @@ vorliegen und gelesen werden.
Beispiele:
[source,python]
-----------------------------------------
+----
buffer = weechat.current_buffer()
nummer = weechat.buffer_get_integer(buffer, "number")
name = weechat.buffer_get_string(buffer, "name")
kurz_name = weechat.buffer_get_string(buffer, "short_name")
-----------------------------------------
+----
Es ist möglich lokale Variablen eines Buffers hinzuzufügen, zu
lesen oder zu löschen:
[source,python]
-----------------------------------------
+----
# lokale Variable hinzufügen
weechat.buffer_set(buffer, "localvar_set_meinevariable", "mit_meinem_Wert")
@@ -631,22 +607,20 @@ meine_variable = weechat.buffer_get_string(buffer, "localvar_meinevariable")
# lokale Variable löschen
weechat.buffer_set(buffer, "localvar_del_meinevariable", "")
-----------------------------------------
+----
Um zu sehen welche lokalen Variablen für einen Buffer gesetzt sind führen Sie
bitte in WeeChat folgenden Befehl aus:
-----------------------------------------
+----
/buffer localvar
-----------------------------------------
+----
[[hooks]]
-Hooks
-~~~~~
+=== Hooks
[[hook_command]]
-neuen Befehl hinzufügen
-^^^^^^^^^^^^^^^^^^^^^^^
+==== neuen Befehl hinzufügen
Erstellt mittels `hook_command` einen benutzerdefinierten Befehl. Dabei kann
eine benutzerdefinierte Vervollständigung der Argumente genutzt werden.
@@ -654,7 +628,7 @@ eine benutzerdefinierte Vervollständigung der Argumente genutzt werden.
Beispiel:
[source,python]
-----------------------------------------
+----
def mein_befehl_cb(data, buffer, args):
# ...
return weechat.WEECHAT_RC_OK
@@ -669,37 +643,35 @@ hook = weechat.hook_command("meinfilter", "Beschreibung meines Filters",
" || add %(filters_names) %(buffers_plugins_names)|*"
" || del %(filters_names)|-all",
"mein_befehl_cb", "")
-----------------------------------------
+----
Der Befehl wird dann in WeeChat wie folgt genutzt:
-----------------------------------------
+----
/help meinfilter
/meinfilter Argumente...
-----------------------------------------
+----
[[hook_timer]]
-Nutzung des Timers
-^^^^^^^^^^^^^^^^^^
+==== Nutzung des Timers
Mittels `hook_timer` wird eine Zeitfunktion implementiert.
Beispiele:
[source,python]
-----------------------------------------
+----
def timer_cb(data, remaining_calls):
# ...
return weechat.WEECHAT_RC_OK
# Timer wird jede Minute aufgerufen (wenn die Sekunden auf 00 springen)
weechat.hook_timer(60 * 1000, 60, 0, "timer_cb", "")
-----------------------------------------
+----
[[hook_process]]
-Hintergrundprozesse
-^^^^^^^^^^^^^^^^^^^
+==== Hintergrundprozesse
Mit der Funktion `hook_process` kann ein Hintergrundprozess gestartet werden.
Der Callback wird aufgerufen sobald der Hintergrundprozess abgearbeitet wurde.
@@ -711,7 +683,7 @@ gesetzt. Dies ist der Return Code des Befehls.
Beispiele:
[source,python]
-----------------------------------------
+----
process_output = ""
def my_process_cb(data, command, rc, out, err):
@@ -723,11 +695,10 @@ def my_process_cb(data, command, rc, out, err):
return weechat.WEECHAT_RC_OK
weechat.hook_process("/bin/ls -l /etc", 10 * 1000, "my_process_cb", "")
-----------------------------------------
+----
[[url_transfer]]
-URL Übertragung
-^^^^^^^^^^^^^^^
+==== URL Übertragung
_Neu seit Version 0.3.7._
@@ -739,7 +710,7 @@ Beispiel eines URL Transfers, ohne zusätzliche Optionen: Die HTML Seite wird
dabei in der Callback-Variable "out" gesichert (Standardausgabe des Prozesses):
[source,python]
-----------------------------------------
+----
# Zeigt die aktuelle stabile Version von WeeChat an.
weechat_version = ""
@@ -753,7 +724,7 @@ def weechat_process_cb(data, command, rc, out, err):
weechat.hook_process("url:http://weechat.org/dev/info/stable/",
30 * 1000, "weechat_process_cb", "")
-----------------------------------------
+----
[TIP]
Alle Informationen die WeeChat betreffen findet man auf: http://weechat.org/dev/info
@@ -762,7 +733,7 @@ Beispiel eines URL Transfers, mit zusätzliche Optionen: Es wird das neuste
WeeChat Entwicklerpaket in die Datei '/tmp/weechat-devel.tar.gz' gesichert:
[source,python]
-----------------------------------------
+----
def my_process_cb(data, command, rc, out, err):
if int(rc) >= 0:
weechat.prnt("", "End of transfer (rc=%s)" % rc)
@@ -771,18 +742,16 @@ def my_process_cb(data, command, rc, out, err):
weechat.hook_process_hashtable("url:http://weechat.org/files/src/weechat-devel.tar.gz",
{ "file_out": "/tmp/weechat-devel.tar.gz" },
30 * 1000, "my_process_cb", "")
-----------------------------------------
+----
Für weiterführende Informationen zum URL Transfer und für die verfügbaren Optionen,
siehe `hook_process` und `hook_process_hashtable` in der API Erweiterung Anleitung.
[[config_options]]
-Konfiguration / Optionen
-~~~~~~~~~~~~~~~~~~~~~~~~
+=== Konfiguration / Optionen
[[config_options_set_script]]
-Optionen von Skripten setzen
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+==== Optionen von Skripten setzen
Die Funktion `config_is_set_plugin` wird dazu benutzt um zu testen ob eine Option
gesetzt ist oder nicht. Mit der Funktion `config_set_plugin` wird eine Option gesetzt.
@@ -790,7 +759,7 @@ gesetzt ist oder nicht. Mit der Funktion `config_set_plugin` wird eine Option ge
Beispiele:
[source,python]
-----------------------------------------
+----
skript_optionen = {
"Option1" : "Wert1",
"Option2" : "Wert2",
@@ -799,11 +768,10 @@ skript_optionen = {
for option, standardwert in skript_optionen.items():
if not weechat.config_is_set_plugin(option):
weechat.config_set_plugin(option, standardwert)
-----------------------------------------
+----
[[config_options_detect_changes]]
-Veränderungen bemerken
-^^^^^^^^^^^^^^^^^^^^^^
+==== Veränderungen bemerken
Die Funktion `hook_config` wird dazu benutzt um festzustellen falls ein Anwender
eine Option des Skripts verändert hat.
@@ -811,7 +779,7 @@ eine Option des Skripts verändert hat.
Beispiele:
[source,python]
-----------------------------------------
+----
SKRIPT_NAME = "meinskript"
# ...
@@ -826,17 +794,16 @@ def config_cb(data, option, value):
weechat.hook_config("plugins.var.python." + SKRIPT_NAME + ".*", "config_cb", "")
# für die jeweilige Programmiersprache muss "python" durch "perl", "ruby", "lua" oder "tcl" ersetzt werden.
-----------------------------------------
+----
[[config_options_weechat]]
-WeeChat Optionen lesen
-^^^^^^^^^^^^^^^^^^^^^^
+==== WeeChat Optionen lesen
Die Funktion `config_get` gibt einen Pointer zu einer Option zurück. Abhängig vom Typ der Option
muss entweder `config_string`, `config_boolean`, `config_integer` oder `config_color` genutzt werden.
[source,python]
-----------------------------------------
+----
# string
weechat.prnt("", "Wert der Option weechat.look.item_time_format ist: %s"
% (weechat.config_string(weechat.config_get("weechat.look.item_time_format"))))
@@ -852,15 +819,13 @@ weechat.prnt("", "Wert der Option weechat.look.scroll_page_percent ist: %d"
# color
weechat.prnt("", "Wert der Option weechat.color.chat_delimiters ist: %s"
% (weechat.config_color(weechat.config_get("weechat.color.chat_delimiters"))))
-----------------------------------------
+----
[[irc]]
-IRC
-~~~
+=== IRC
[[irc_catch_messages]]
-Nachrichten abfangen
-^^^^^^^^^^^^^^^^^^^^
+==== Nachrichten abfangen
Die IRC Erweiterung sendet zwei Signale wenn eine Nachricht empfangen wurde.
`xxx` ist der interne IRC Servername, `yyy` ist der IRC Befehl der empfangen
@@ -873,7 +838,7 @@ xxx,irc_in2_yyy::
Signal wird gesendet nachdem die Nachricht verarbeitet wurde.
[source,python]
-----------------------------------------
+----
def join_cb(data, signal, signal_data):
# Das Signal lautet: "freenode,irc_in2_join"
# signal_data enthält die IRC Nachricht, zum Beispiel: ":nick!user@host JOIN :#channel"
@@ -888,53 +853,49 @@ def join_cb(data, signal, signal_data):
# es ist sinnvoll als Server "*" anzugeben um alle JOIN Nachrichten von allen
# IRC Servern abzufangen
weechat.hook_signal("*,irc_in2_join", "join_cb", "")
-----------------------------------------
+----
[[irc_modify_messages]]
-Modify messages
-^^^^^^^^^^^^^^^
+==== Modify messages
Die IRC Erweiterung verschickt einen "modifier" mit Namen "irc_in_xxx" ("xxx" steht für den
Namen des IRC Befehls) um eine Nachricht zu empfangen die dann modifiziert werden kann.
[source,python]
-----------------------------------------
+----
def modifier_cb(data, modifier, modifier_data, string):
# füge den Namen des Server zu allen empfangenen Nachrichten hinzu
# (Okay dies ist nicht wirklich sinnvoll, aber es ist auch nur ein Beispiel!)
return "%s %s" % (string, modifier_data)
weechat.hook_modifier("irc_in_privmsg", "modifier_cb", "")
-----------------------------------------
+----
[WARNING]
Eine fehlerhafte Nachricht kann WeeChat zum Absturz bringen oder andere ernsthafte Probleme erzeugen!
[[irc_message_parse]]
-Nachrichten parsen
-^^^^^^^^^^^^^^^^^^
+==== Nachrichten parsen
_Neu seit Version 0.3.4._
Man kann IRC Nachrichten mittels einer info_hashtable mit dem Namen "irc_message_parse" parsen.
[source,python]
-----------------------------------------
+----
dict = weechat.info_get_hashtable("irc_message_parse",
{ "message": ":nick!user@host PRIVMSG #weechat :message here" })
weechat.prnt("", "dict: %s" % dict)
# output:
# dict: {'nick': 'nick', 'host': 'nick!user@host', 'command': 'PRIVMSG', 'arguments': '#weechat :message here', 'channel': '#weechat'}
-----------------------------------------
+----
[[infos]]
-Infos
-~~~~~
+=== Infos
[[infos_weechat_version]]
-WeeChat Version
-^^^^^^^^^^^^^^^
+==== WeeChat Version
Die sinnvollste Methode um die Version abzufragen ist die Nutzung
von "version_number". Das Ergebnis sollte mit einem hexadezimalen
@@ -943,13 +904,13 @@ Integer-Wert verglichen werden.
Beispiele:
[source,python]
-----------------------------------------
+----
version = weechat.info_get("version_number", "") or 0
if int(version) >= 0x00030200:
weechat.prnt("", "Es handelt sich um WeeChat 0.3.2 oder neuer")
else:
weechat.prnt("", "Es handelt sich um WeeChat 0.3.1 oder älter")
-----------------------------------------
+----
[NOTE]
Versionen ≤ 0.3.1.1 geben einen leeren String zurück wenn man 'info_get("version_number")'
@@ -958,31 +919,28 @@ aufruft. Deshalb müssen Sie prüfen ob der Rückgabe wert *nicht* leer ist.
Um die Version als String zu erhalten:
[source,python]
-----------------------------------------
+----
# Dies gibt z.B. "Version 0.3.2" im Core Buffer aus
weechat.prnt("", "Version %s" % weechat.info_get("version", ""))
-----------------------------------------
+----
[[infos_other]]
-andere Informationen
-^^^^^^^^^^^^^^^^^^^^
+==== andere Informationen
[source,python]
-----------------------------------------
+----
# WeeChat Hauptverzeichnis, zum Beispiel: "/home/xxxx/.weechat"
weechat.prnt("", "WeeChat Hauptverzeichnis: %s" % weechat.info_get("weechat_dir", ""))
# Inaktivität der Tastatur
weechat.prnt("", "Tastatur ist seit %s Sekunden nicht mehr betätigt worden" % weechat.info_get("inactivity", ""))
-----------------------------------------
+----
[[infolists]]
-Infolisten
-~~~~~~~~~~
+=== Infolisten
[[infolists_read]]
-Infoliste einlesen
-^^^^^^^^^^^^^^^^^^
+==== Infoliste einlesen
Es können Infolisten eingelesen werden die entweder von WeeChat oder von
Erweiterungen erstellt wurden.
@@ -990,7 +948,7 @@ Erweiterungen erstellt wurden.
Beispiele:
[source,python]
-----------------------------------------
+----
# Infoliste "buffer" einlesen, um eine Liste aller Buffer zu erhalten
infolist = weechat.infolist_get("buffer", "", "")
if infolist:
@@ -998,7 +956,7 @@ if infolist:
name = weechat.infolist_string(infolist, "name")
weechat.prnt("", "Buffer: %s" % name)
weechat.infolist_free(infolist)
-----------------------------------------
+----
[IMPORTANT]
Vergessen Sie bitte nicht `infolist_free` aufzurufen um den Speicher wieder