Add italian translation of Plugin API Reference

3 files changed, 9156 insertions, 0 deletions

diff --git a/doc/it/CMakeLists.txt b/doc/it/CMakeLists.txt
index 8baac63e1..094503716 100644
--- a/doc/it/CMakeLists.txt
+++ b/doc/it/CMakeLists.txt
@@ -26,6 +26,18 @@ ADD_CUSTOM_COMMAND(
 ADD_CUSTOM_TARGET(doc-user-it ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/weechat_user.it.html)
 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/weechat_user.it.html DESTINATION ${SHAREDIR}/doc/${PROJECT_NAME})
 
+# plugin API reference
+ADD_CUSTOM_COMMAND(
+  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/weechat_plugin_api.it.html
+  COMMAND ${ASCIIDOC_EXECUTABLE} ARGS -a toc -a toclevels=3 -a toc-title='Indice' -a date=`date "+%F"` -a revision="${VERSION}" -n -o ${CMAKE_CURRENT_BINARY_DIR}/weechat_plugin_api.it.html ${CMAKE_CURRENT_SOURCE_DIR}/weechat_plugin_api.it.txt
+  DEPENDS
+  ${CMAKE_CURRENT_SOURCE_DIR}/weechat_plugin_api.it.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/autogen/plugin_api/*.txt
+  COMMENT "Building weechat_plugin_api.it.html"
+)
+ADD_CUSTOM_TARGET(doc-plugin-api-it ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/weechat_plugin_api.it.html)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/weechat_plugin_api.it.html DESTINATION ${SHAREDIR}/doc/${PROJECT_NAME})
+
 # FAQ
 ADD_CUSTOM_COMMAND(
   OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/weechat_faq.it.html
diff --git a/doc/it/Makefile.am b/doc/it/Makefile.am
index d2e673577..5a6af7d92 100644
--- a/doc/it/Makefile.am
+++ b/doc/it/Makefile.am
@@ -18,6 +18,7 @@ docdir = $(datadir)/doc/$(PACKAGE)
 
 EXTRA_DIST = CMakeLists.txt \
              weechat_user.it.txt \
+             weechat_plugin_api.it.txt \
              weechat_faq.it.txt \
              weechat_quickstart.it.txt \
              weechat_tester.it.txt \
@@ -25,6 +26,7 @@ EXTRA_DIST = CMakeLists.txt \
              $(wildcard autogen/plugin_api/*.txt)
 
 all-local: weechat_user.it.html \
+		weechat_plugin_api.it.html \
 		weechat_faq.it.html \
 		weechat_quickstart.it.html \
 		weechat_tester.it.html
@@ -33,6 +35,10 @@ all-local: weechat_user.it.html \
 weechat_user.it.html: weechat_user.it.txt $(wildcard autogen/user/*.txt)
 	$(ASCIIDOC) -a toc -a toclevels=3 -a toc-title='Indice' -a date=`date "+%F"` -a revision="$(VERSION)" -n -o weechat_user.it.html weechat_user.it.txt
 
+# plugin API reference
+weechat_plugin_api.it.html: weechat_plugin_api.it.txt $(wildcard autogen/plugin_api/*.txt)
+	$(ASCIIDOC) -a toc -a toclevels=3 -a toc-title='Indice' -a date=`date "+%F"` -a revision="$(VERSION)" -n -o weechat_plugin_api.it.html weechat_plugin_api.it.txt
+
 # FAQ
 weechat_faq.it.html: weechat_faq.it.txt
 	$(ASCIIDOC) -a toc -a toc-title='Indice' -a date=`date "+%F"` -a revision="$(VERSION)" -n -o weechat_faq.it.html weechat_faq.it.txt
diff --git a/doc/it/weechat_plugin_api.it.txt b/doc/it/weechat_plugin_api.it.txt
new file mode 100644
index 000000000..d311ee3d8
--- /dev/null
+++ b/doc/it/weechat_plugin_api.it.txt
@@ -0,0 +1,9138 @@
+WeeChat Plugin API Reference
+============================
+FlashCode <flashcode@flashtux.org>
+
+
+Questo manuale documenta il client di chat WeeChat, ed è parte
+del programma stesso.
+
+È possibile trovare l'ultima versione di questo documento qui:
+http://www.weechat.org/doc
+
+
+[[introduction]]
+Introduzione
+------------
+
+WeeChat (Wee Enhanced Environment for Chat) è un client di chat
+libero, veloce e leggero, realizzato per molti diversi operativi.
+
+Questo manuale documenta le API per i plugin di WeeChat, utilizzati dai plugin
+C per interagire con il core di WeeChat.
+
+[[plugins_in_weechat]]
+Plugin in WeeChat
+-----------------
+
+Un plugin è un programma C che può richiamare le funzioni di WeeChat
+definite in un'interfaccia.
+
+Questo programma C non richiede i sorgenti di WeeChat per essere compilato e
+può essere caricato dinamicamente in WeeChat con il comano `/plugin`.
+
+Il plugin deve essere una libreria dinamica, per essere caricato dinamicamente
+dal del sistema operativo.
+In GNU/Linux, il file ha estensione ".so", ".dll" in Windows.
+
+Il plugin deve includere il file "weechat-plugin.h" (disponibile nel codice
+sorgente di WeeChat).
+Il file definisce strutture e tipi utilizzati per comunicare con WeeChat.
+
+[[macros]]
+Macro
+~~~~~
+
+Il plugin deve utilizzare alcune macro (per definire alcune variabili):
+
+WEECHAT_PLUGIN_NAME("nome")::
+    nome del plugin
+
+WEECHAT_PLUGIN_DESCRIPTION("descrizione")::
+    breve descrizione del plugin
+
+WEECHAT_PLUGIN_VERSION("1.0")::
+    versione del plugin
+
+WEECHAT_PLUGIN_LICENSE("GPL3")::
+    licenza del plugin
+
+[[main_functions]]
+Funzioni principali
+~~~~~~~~~~~~~~~~~~~
+
+Il plugin deve usare due funzioni:
+
+* weechat_plugin_init
+* weechat_plugin_end
+
+weechat_plugin_init
+^^^^^^^^^^^^^^^^^^^
+
+Questa funzione viene chiamata quando il plugin è caricato.
+da WeeChat.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_plugin_init (struct t_weechat_plugin *plugin,
+                         int argc, char *argv[]);
+----------------------------------------
+
+Argomenti:
+
+* 'plugin': puntatore alla struttura del plugin di WeeChat
+* 'argc': numero di argomenti per il plugin (fornito dalla riga di comando
+  dall'utente)
+* 'argv': argomenti per il plugin
+
+Valori restituiti:
+
+* 'WEECHAT_RC_OK' se l'operazione ha successo (il plugin
+  verrà caricato)
+* 'WEECHAT_RC_ERROR' se c'è un errore (il plugin NON
+  verrà caricato)
+
+weechat_plugin_end
+^^^^^^^^^^^^^^^^^^
+
+Questa funzione viene chiamata quando il plugin viene
+disattivato da WeeChat.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_plugin_end (struct t_weechat_plugin *plugin);
+----------------------------------------
+
+Argomenti:
+
+* 'plugin': puntatore alla struttura plugin di WeeChat
+
+Valori restituiti:
+
+* 'WEECHAT_RC_OK' se l'operazione ha successo
+* 'WEECHAT_RC_ERROR' se c'è un errore
+
+[[compile_plugin]]
+Compilazione del plugin
+~~~~~~~~~~~~~~~~~~~~~~~
+
+La compilazione non richiede i sorgenti di WeeChat, è richiesto solo
+il file 'weechat-plugin.h'.
+
+Per compilare un plugin che ha un file "tizio.c" (in GNU/Linux):
+
+----------------------------------------
+$ gcc -fPIC -Wall -c tizio.c
+$ gcc -shared -fPIC -o libtizio.so tizio.o
+----------------------------------------
+
+[[load_plugin]]
+Caricamento del plugin
+~~~~~~~~~~~~~~~~~~~~~~
+
+Copiare il file 'libtizio.so' nella cartella plugin di sistema (ad
+esempio '/usr/local/lib/weechat/plugins') oppure nella cartella
+plugin dell'utente (ad esempio '/home/xxx/.weechat/plugins').
+
+In WeeChat:
+
+----------------------------------------
+/plugin load tizio
+----------------------------------------
+
+[[plugin_example]]
+Plugin di esempio
+~~~~~~~~~~~~~~~~~
+
+Un esempio completo di plugin, che aggiunge un comando '/double':
+visualizza due volte gli argomenti nel buffer corrente, oppure esegue un
+comando due volte (ok, non sarà molto utile, ma è solo un esempio!):
+
+[source,C]
+----------------------------------------
+#include <stdlib.h>
+
+#include "weechat-plugin.h"
+
+WEECHAT_PLUGIN_NAME("double");
+WEECHAT_PLUGIN_DESCRIPTION("Test plugin for WeeChat");
+WEECHAT_PLUGIN_AUTHOR("FlashCode <flashcode@flashtux.org>");
+WEECHAT_PLUGIN_VERSION("0.1");
+WEECHAT_PLUGIN_LICENSE("GPL3");
+
+struct t_weechat_plugin *weechat_plugin = NULL;
+
+
+/* callback for command "/double" */
+
+int
+command_double_cb (void *data, struct t_gui_buffer *buffer, int argc,
+                   char **argv, char **argv_eol)
+{
+    /* fa felice il compilatore C */
+    (void) data;
+    (void) buffer;
+    (void) argv;
+    
+    if (argc > 1)
+    {
+        weechat_command (NULL, argv_eol[1]);
+        weechat_command (NULL, argv_eol[1]);
+    }
+    
+    return WEECHAT_RC_OK;
+}
+
+int
+weechat_plugin_init (struct t_weechat_plugin *plugin,
+                     int argc, char *argv[])
+{
+    weechat_plugin = plugin;
+    
+    weechat_hook_command ("double",
+			  "Visualizza due volte un messaggio "
+			  "oppure esegue un comando due volte",
+			  "messaggio | comando",
+			  "messaggio: messaggio da visualizzare due volte\n"
+			  "comando: comando da eseguire due volte",
+                          NULL,
+                          &command_double_cb, NULL);
+    
+    return WEECHAT_RC_OK;
+}
+
+int
+weechat_plugin_end (struct t_weechat_plugin *plugin)
+{
+    /* fa felice il compilatore C */
+    (void) plugin;
+    
+    return WEECHAT_RC_OK;
+}
+----------------------------------------
+
+[[plugin_api]]
+Plugin API
+----------
+
+I capitoli seguenti descrivono le funzioni  nelle API, organizzate
+in categorie.
+
+Per ogni funzione, viene fornita:
+
+* descrizione della funzione,
+* prototipo C,
+* dettaglio degli argomenti,
+* valore restituito,
+* esempio C,
+* esempio nello script Python (la sintassi è simile per gli altri linguaggi di
+  scripting).
+
+[[plugins]]
+Plugin
+~~~~~~
+
+Funzioni per ottenere informazioni sui plugin.
+
+weechat_plugin_get_name
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Ottiene il nome del plugin.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_plugin_get_name (struct t_weechat_plugin *plugin);
+----------------------------------------
+
+Argomenti:
+
+* 'plugin': puntatore alla struttura plugin di WeeChat (può essere NULL)
+
+Valore restituito:
+
+* nome del plugin, "core" per il core di WeeChat (se il puntatore al plugin
+  è NULL)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+const char *name = weechat_plugin_get_name (plugin);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+name = weechat.plugin_get_name(plugin)
+
+# esempio
+plugin = weechat.buffer_get_pointer(weechat.current_buffer(), "plugin")
+name = weechat.plugin_get_name(plugin)
+----------------------------------------
+
+[[strings]]
+Stringhe
+~~~~~~~~
+
+Molte delle funzioni stringhe che seguono sono già disponibili tramite
+funzioni standard in C, ma si raccomanda di utilizzare le funzioni in
+questa API perché vanno d'accordo con UTF-8 e il locale.
+
+weechat_charset_set
+^^^^^^^^^^^^^^^^^^^
+
+Imposta il nuovo set caratteri del nuovo plugin (il set caratteri predefinito
+è 'UTF-8', così se il plugin usa 'UTF-8' non è necessario chiamare questa
+funzione).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_charset_set (const char *charset);
+----------------------------------------
+
+Argomenti:
+
+* 'charset': nuovo set caratteri da usare
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_charset_set (plugin, "iso-8859-1");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.charset_set(charset)
+
+# esempio
+weechat.charset_set("iso-8859-1")
+----------------------------------------
+
+weechat_iconv_to_internal
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Converte le stringhe per il set caratteri interno di
+WeeChat (UTF-8).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_iconv_to_internal (const char *charset, const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'charset': set caratteri da convertire
+* 'string': stringa da convertire
+
+Valore restituito:
+
+* la stringa convertita (deve essere liberata richiamando "free"
+  dopo l'utilizzo)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = weechat_iconv_to_internal (plugin, "iso-8859-1", "iso string: é à");
+/* ... */
+free (str);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+str = weechat.iconv_to_internal(charset, string)
+
+# esempio
+str = weechat.iconv_to_internal("iso-8859-1", "iso string: é à")
+----------------------------------------
+
+weechat_iconv_from_internal
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Converte la stringa dal set caratteri interno di WeeChat (UTF-8)
+in un'altra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_iconv_from_internal (const char *charset, const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'charset': set caratteri in uscita
+* 'string': stringa da convertire
+
+Valore restituito:
+
+* la stringa convertita (deve essere liberata richiamando "free"
+  dopo l'utilizzo
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = weechat_iconv_from_internal ("iso-8859-1", "utf-8 string: é à");
+/* ... */
+free (str);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+str = weechat.iconv_from_internal(charset, string)
+
+# esempio
+str = weechat.iconv_from_internal("iso-8859-1", "utf-8 string: é à")
+----------------------------------------
+
+weechat_gettext
+^^^^^^^^^^^^^^^
+
+Restituisce la stringa tradotta (dipende dalla lingua).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_gettext (const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa da tradurre
+
+Valore restituito:
+
+* stringa tradotta
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = weechat_gettext ("hello");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+str = weechat.gettext(string)
+
+# esempio
+str = weechat.gettext("hello")
+----------------------------------------
+
+weechat_ngettext
+^^^^^^^^^^^^^^^^
+
+Restituisce la stringa tradotta, utilizzando il singolare o il plurale, in base
+all'argomento 'count' (contatore).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_ngettext (const char *string, const char *plural,
+                              int count);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa da tradurre, singolare
+* 'plural': stringa da tradurre, plurale
+* 'count': utilizzato per scegliere tra singolare e plurale (la scelta viene
+  fatta in base alla lingua locale)
+
+Valore restituito:
+
+* stringa tradotta
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = weechat_ngettext ("file", "files", num_files);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+str = weechat.ngettext(string, plural, count)
+
+# esempio
+num_files = 2
+str = weechat.ngettext("file", "files", num_files)
+----------------------------------------
+
+weechat_strndup
+^^^^^^^^^^^^^^^
+
+Restituisce una stringa duplicata, con un massimo di caratteri
+impostato su 'chars'.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_strndup (const char *string, int length);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa da duplicare
+* 'length': caratteri massimi da duplicare
+
+Valore restituito:
+
+* stringa duplicata (deve essere liberata chiamando "free" dopo
+  l'utilizzo)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = weechat_strndup ("abcdef", 3); /* result: "abc" */
+/* ... */
+free (str);
+----------------------------------------
+
+weechat_string_tolower
+^^^^^^^^^^^^^^^^^^^^^^
+
+Converte una stringa UTF-8 in minuscolo.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_string_tolower (const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa da convertire
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = "AbCdé";
+weechat_string_tolower (str); /* str ora è: "abcdé" */
+----------------------------------------
+
+weechat_string_toupper
+^^^^^^^^^^^^^^^^^^^^^^
+
+Converte una stringa UTF-8 in maiuscolo.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_string_toupper (const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa da convertire
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = "AbCdé";
+weechat_string_tolower (str); /* str ora è: "ABCDé" */
+----------------------------------------
+
+weechat_strcasecmp
+^^^^^^^^^^^^^^^^^^
+
+Locale and case independent string comparison.
+Confronta stringa di li
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_strcasecmp (const char *string1, const char *string2);
+----------------------------------------
+
+Argomenti:
+
+* 'string1': prima stringa da comparare
+* 'string2': seconda stringa da comparare
+
+Valore restituito:
+
+* differenze tra le due stringhe:
+** negativa se stringa1 < stringa2
+** zero se stringa1 == stringa1
+** positiva se stringa1 > stringa2
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int diff = weechat_strcasecmp ("aaa", "CCC"); /* == -2 */
+----------------------------------------
+
+weechat_strcmp_ignore_chars
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Locale (and optionally case independent) string comparison, ignoring some
+chars.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_strcmp_ignore_chars (const char *string1, const char *string2,
+                                 const char *chars_ignored,
+                                 int case_sensitive);
+----------------------------------------
+
+Argomenti:
+
+* 'string1': first string for comparison
+* 'string2': second string for comparison
+* 'chars_ignored': string with chars to ignored
+* 'case_sensitive': 1 for case sensitive comparison, otherwise 0
+
+Valore restituito:
+
+* difference between two strings:
+** negative if string1 < string2
+** zero if string1 == string2
+** positive if string1 > string2
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int diff = weechat_strcmp_ignore_chars ("a-b", "--a-e", "-", 1); /* == -3 */
+----------------------------------------
+
+weechat_strcasestr
+^^^^^^^^^^^^^^^^^^
+
+Locale and case independent string search.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_strcasestr (const char *string, const char *search);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'search': stringa da cercare in 'string'
+
+Valore restituito:
+
+* puntatore alla stringa trovata, o NULL se non trovata
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *pos = weechat_strcasestr ("aBcDeF", "de"); /* risultato: puntatore a "DeF" */
+----------------------------------------
+
+weechat_string_match
+^^^^^^^^^^^^^^^^^^^^
+
+Verifica se una stringa coincide ad una mask.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_string_match (const char *string, const char *mask,
+                          int case_sensitive);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'mask': mask, può iniziare o terminare con "`*`" (nessun altro "`*`"
+* consentito all'interno della mask)
+
+Valore restituito:
+
+* 1 se la stringa coincide alla mask, altrimenti 0
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int match1 = weechat_string_match ("abcdef", "abc*", 0); /* == 1 */
+int match2 = weechat_string_match ("abcdef", "*dd*", 0); /* == 0 */
+int match3 = weechat_string_match ("abcdef", "*def", 0); /* == 1 */
+int match4 = weechat_string_match ("abcdef", "*de*", 0); /* == 1 */
+----------------------------------------
+
+weechat_string_replace
+^^^^^^^^^^^^^^^^^^^^^^
+
+Sostituisce tutte le ricorrenze di una stringa con un'altra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_string_replace (const char *string, const char *search,
+                              const char *replace);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'search': stringa da sostituire
+* 'replace': sostituzione per la stringa 'search'
+
+Valore restituito:
+
+* la stringa dopo 'search' sostituita da 'replace' (deve essere liberata
+* chiamando "free" dopo l'uso)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = weechat_string_replace ("test", "s", "x"); /* result: "text" */
+/* ... */
+free (str);
+----------------------------------------
+
+weechat_string_remove_quotes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Rimuove le virgolette all'inizio e alla fine della stringa (ignora gli spazi se ce ne prima
+delle prime virgolette o dopo le ultime virgolette).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_string_remove_quotes (const char *string, const char *quotes);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'quotes': stringa con elenco di virgolette
+
+Valore restituito:
+
+* stringa senza virgolette all'inizio/fine (deve essere liberata chiamando "free"
+  dopo l'uso)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = weechat_string_remove_quotes (string, " 'I can't' ", "'");
+/* result: "I can't" */
+/* ... */
+free (str);
+----------------------------------------
+
+weechat_string_strip
+^^^^^^^^^^^^^^^^^^^^
+
+Rimuove i caratteri all'inizio/fine della stringa.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_string_strip (const char *string, int left, int right,
+                            const char *chars);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'left': rimuove i caratteri a sinistra se diversi da 0
+* 'right': rimuove i caratteri a destra se diversi da 0
+* 'chars': stringa con i caratteri da rimuovere
+
+Valore restituito:
+
+* stringa corretta (deve essere liberata chiamando "free" dopo l'uso)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = weechat_string_strip (".abc -", 0, 1, "- ."); /* risultato: ".abc" */
+/* ... */
+free (str);
+----------------------------------------
+
+weechat_string_has_highlight
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Controlla se una stringa ha uno o più eventi, usando la lista di parole per
+gli eventi.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_string_has_highlight (const char *string,
+                                  const char highlight_words);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'highlight_words': lista di parole per gli eventi, separate da virgole
+
+Valore restituito:
+
+* 1 se la stringa ha uno o più eventi, altrimenti 0
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int hl = weechat_string_has_highlight ("my test string", "test,word2"); /* == 1 */
+----------------------------------------
+
+weechat_string_mask_to_regex
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce una espressione regolare con una mask, dove l'unico carattere
+speciale è "`*`". Tutti gli altri caratteri speciali per le espressioni regolari
+non vengono riconosciuti.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_string_mask_to_regex (const char *mask);
+----------------------------------------
+
+Argomenti:
+
+* 'mask': mask
+
+Valore restituito:
+
+* espressione regolare, come stringa (deve essere liberata chiamando "free"
+  dopo l'uso)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str_regex = weechat_string_mask_to_regex ("test*mask");
+/* result: "test.*mask" */
+/* ... */
+free (str_regex);
+----------------------------------------
+
+weechat_string_split
+^^^^^^^^^^^^^^^^^^^^
+
+Divide una stringa in base a uno o più delimitatori.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char **weechat_string_split (const char *string, const char *separators,
+                             int keep_eol, int num_items_max,
+                             int *num_items);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa da dividere
+* 'separators': delimitatori usati per dividere
+* 'keep_eol': se diversa da 0, allora ogni argomento conterrà tutte le stringhe
+  fino a fine riga (consultare l'esempio in basso)
+* 'num_items_max': maximum number of items created (0 = no limit)
+* 'num_items': pointer to int which will contain number of items created
+
+Valore restituito:
+
+* array di stringhe, NULL se si verifica un problema (deve essere liberata chiamando
+  <<_weechat_string_free_split>> dopo l'uso)
+
+Esempi:
+
+[source,C]
+----------------------------------------
+char **argv;
+int argc;
+argv = weechat_string_split ("abc de  fghi", " ", 0, 0, &argc);
+/* result: argv[0] == "abc"
+           argv[1] == "de"
+           argv[2] == "fghi"
+           argv[3] == NULL
+           argc == 3
+*/
+weechat_string_free_split (argv);
+
+argv = weechat_string_split ("abc de  fghi", " ", 1, 0, &argc);
+/* result: argv[0] == "abc de  fghi"
+           argv[1] == "de  fghi"
+           argv[2] == "fghi"
+           argv[3] == NULL
+           argc == 3
+*/
+weechat_string_free_split (argv);
+----------------------------------------
+
+weechat_string_free_split
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Libera la memoria usata per la divisione di una stringa.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_string_free_split (char **split_string);
+----------------------------------------
+
+Argomenti:
+
+* 'split_string': stringa divisa dalla funzione <<_weechat_string_split>>
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *argv;
+int argc;
+argv = weechat_string_split (string, " ", 0, 0, &argc);
+/* ... */
+weechat_string_free_split (argv);
+----------------------------------------
+
+weechat_string_build_with_split_string
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Compila una stringa con una stringa divisa.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_string_build_with_split_string (char **split_string,
+                                              const char *separator);
+----------------------------------------
+
+Argomenti:
+
+* 'split_string': stringa divisa dalla funzione <<_weechat_string_split>>
+* 'separator': stringa usata per separare le stringhe
+
+Valore restituito:
+
+* stringa compilata con la stringa divisa (deve essere liberata chiamando
+  "free" dopo l'uso)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char **argv;
+int argc;
+argv = weechat_string_split ("abc def ghi", " ", 0, 0, &argc);
+char *str = weechat_string_build_with_split_string (argv, ";");
+/* str == "abc;def;ghi" */
+/* ... */
+free (str);
+----------------------------------------
+
+weechat_string_split_command
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Divide una lista di comandi separata da 'separator' (che può essere omesso "
+"aggiungendo "\" nella stringa).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char **weechat_string_split_command (const char *command, char separator);
+----------------------------------------
+
+Argomenti:
+
+* 'command': comando da dividere
+* 'separator': separatore
+
+Valore restituito:
+
+* array di stringhe, NULL in caso di problemi (deve essere
+  liberata chiamando
+  <<_weechat_free_split_command>> dopo l'uso)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char **argv = weechat_string_split_command ("/command1 arg;/command2", ';');
+/* result: argv[0] == "/command1 arg"
+           argv[1] == "/command2"
+*/
+weechat_free_split_command (argv);
+----------------------------------------
+
+weechat_string_free_split_command
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Libera la memoria utilizzata dalla divisione di un comando.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_string_free_split_command (char **split_command);
+----------------------------------------
+
+Argomenti:
+
+* 'split_command': comando diviso da <<_weechat_string_split_command>>
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char **argv = weechat_string_split_command ("/command1 arg;/command2", ';');
+/* ... */
+weechat_free_split_command (argv);
+----------------------------------------
+
+weechat_string_format_size
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Build a string with formatted file size and a unit translated to local
+language.
+Compila una stringa con un file di dimensione fissa ed una unità
+tradotta nella lingua locale.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_string_format_size (unsigned long size);
+----------------------------------------
+
+Argomenti:
+
+* 'size': dimensione (in byte)
+
+Valore restituito:
+
+* stringa formattata (deve essere liberata chiamando "free" dopo l'uso)
+
+Examples:
+
+[source,C]
+----------------------------------------
+/* esempi in lingua inglese */
+
+char *str = weechat_string_format_size (0); /* str == "0 byte" */
+/* ... */
+free (str);
+
+char *str = weechat_string_format_size (200); /* str == "200 bytes" */
+/* ... */
+free (str);
+
+char *str = weechat_string_format_size (1536); /* str == "1.5 KB" */
+/* ... */
+free (str);
+
+char *str = weechat_string_format_size (2097152); /* str == "2 MB" */
+/* ... */
+free (str);
+----------------------------------------
+
+weechat_string_remove_color
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Rimuove i colori di WeeChat da una stringa.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_string_remove_color (const char *string,
+                                   const char *replacement);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'replacement': se non NULL e non vuota, i codici colore di WeeChat sono
+  sostituiti dal primo carattere di questa stringa, altrimenti i codici colori di
+  WeeChat ed i caratteri seguenti (se correlate al colore) sono rimossi dalla
+  stringa
+
+Valore restituito:
+
+* stringa senza un colore (deve essere liberata chiamando "free" dopo l'uso)
+
+Esempi:
+
+[source,C]
+----------------------------------------
+/* rimuove i codici colore */
+char *str = weechat_string_remove_color (my_string1, NULL);
+/* ... */
+free (str);
+
+/* sostituisce i codici colore con "?" */
+char *str = weechat_string_remove_color (my_string2, "?");
+/* ... */
+free (str);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+str = weechat.string_remove_color(string, replacement)
+
+# esempio
+str = weechat.string_remove_color(my_string, "?")
+----------------------------------------
+
+[[utf-8]]
+UTF-8
+~~~~~
+
+Alcune funzioni stringa UTF-8.
+
+weechat_utf8_has_8bits
+^^^^^^^^^^^^^^^^^^^^^^
+
+Verifica che una stringa abbia caratteri a 8-bit.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_has_8bits (const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+
+Valore restituito:
+
+* 1 se la stringa ha caratteri a 8-bit, 0 se solo a 7-bit
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_utf8_has_8bits (string))
+{
+    /* ... */
+}
+----------------------------------------
+
+weechat_utf8_is_valid
+^^^^^^^^^^^^^^^^^^^^^
+
+Verifica che una stringa sia valida in UTF-8.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_is_valid (const char *string, char **error);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'error': se non NULL, '*error*' è impostato con il puntatore al primo
+  carattere UTF-8 non valido nella stringa, se esiste
+
+Valore restituito:
+
+* 1 se la stringa UTF-8 è valida, altrimenti 0
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *error;
+if (weechat_utf8_is_valid (string, &error))
+{
+    /* ... */
+}
+else
+{
+    /* "error" points to first invalid char */
+}
+----------------------------------------
+
+weechat_utf8_normalize
+^^^^^^^^^^^^^^^^^^^^^^
+
+Normalizza le stringhe UTF-8: rimuove i caratteri non UTF-8 e li sostituisce con
+un carattere.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_utf8_normalize (const char *string, char replacement);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'replacement': carattere sotitutivo per i caratteri non validi
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_utf8_normalize (string, '?');
+----------------------------------------
+
+weechat_utf8_prev_char
+^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il puntatore al carattere UTF-8 precedente in una stringa.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_utf8_prev_char (const char *string_start, const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string_start': inizio della stringa (la funzione non restituirà un carattere prima
+  di questo puntatore)
+* 'string': puntatore alla stringa (deve essere > = 'string_start')
+
+Valore restituito:
+
+* puntatore al precedente carattere UTF-8, NULL se non trovata (raggiunta
+  l'inizio della stringa)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *prev_char = weechat_utf8_prev_char (string, ptr_in_string);
+----------------------------------------
+
+weechat_utf8_next_char
+^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il puntatore al successivo carattere UTF-8 in una stringa.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_utf8_next_char (const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+
+Valore restituito:
+
+* puntaotre al carattere UTF-8 successivo, NULL se non trovato
+  (raggiunta la fine della stringa)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *next_char = weechat_utf8_next_char (string);
+----------------------------------------
+
+weechat_utf8_char_size
+^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce la dimensione di un carattere UTF-8 (in byte).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_char_size (const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+
+Valore restituito:
+
+* dimensione carattere UTF-8 (in byte)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int char_size = weechat_utf8_char_size ("être"); /* == 2 */
+----------------------------------------
+
+weechat_utf8_strlen
+^^^^^^^^^^^^^^^^^^^
+
+Restituisce la lunghezza della stringa UTF-8 (nei caratteri UTF-8).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_strlen (const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+
+Valore restituito:
+
+* lunghezza della stringa UTF-8 (numero di caratteri UTF-8)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int length = weechat_utf8_strlen ("chêne"); /* == 5 */
+----------------------------------------
+
+weechat_utf8_strnlen
+^^^^^^^^^^^^^^^^^^^^
+
+Restituisce la lunghezza della stringa UTF-8 (in caratteri UTF-8), per
+un massimo di 'bytes' nella stringa.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_strnlen (const char *string, int bytes);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'bytes': massimo di byte
+
+Valore restituito:
+
+* lunghezza della stringa UTF-8 (numero di caratteri UTF-8)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int length = weechat_utf8_strnlen ("chêne", 4); /* == 3 */
+----------------------------------------
+
+weechat_utf8_strlen_screen
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il numero di caratteri necessari per visualizzare la stringa
+UTF-8 su schermo.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_strlen_screen (const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+
+Valore restituito:
+
+* numero di caratteri necessari per visualizzare la stringa UTF-8
+su schermo
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int length_on_screen = weechat_utf8_strlen_screen ("é"); /* == 1 */
+----------------------------------------
+
+weechat_utf8_charcasecmp
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Confronta due caratteri UTF-8, ignorando maiuscole/minuscole.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_charcasecmp (const char *string1, const char *string2);
+----------------------------------------
+
+Argomenti:
+
+* 'string1': prima stringa da comparare
+* 'string2': seconda stringa da comparare
+
+Valore restituito:
+
+* differenza tra i primi caratteri di ogni stringa:
+** negativa se char1 < char2
+** zero se char1 == char2
+** positivao se char1 > char2
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int diff = weechat_utf8_charcasecmp ("aaa", "CCC"); /* == -2 */
+----------------------------------------
+
+weechat_utf8_char_size_screen
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il numero di caratteri necessari per visualizzare il
+carattere UTF-8 sullo schermo.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_char_size_screen (const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+
+Valore restituito:
+
+* numero di caratteri necessario per visualizzare il carattere
+  UTF-8 su schermo
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int length_on_screen = weechat_utf8_char_size_screen ("é"); /* == 1 */
+----------------------------------------
+
+weechat_utf8_add_offset
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Si sposta in avanti di N caratteri in una stringa UTF-8.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_utf8_add_offset (const char *string, int offset);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'offset': numero di caratteri
+
+Valore restituito:
+
+* puntatore alla stringa, N caratteri dopo (NULL se non raggiungibile)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *str = "chêne";
+char *str2 = weechat_utf8_add_offset (str, 3); /* points to "ne" */
+----------------------------------------
+
+weechat_utf8_real_pos
+^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce la posizione reale nella stringa UTF-8.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_real_pos (const char *string, int pos);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'pos': posizione (numero di caratteri)
+
+Valore restituito:
+
+* pozisione reale (in byte)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int pos = weechat_utf8_real_pos ("chêne", 3); /* == 4 */
+----------------------------------------
+
+weechat_utf8_pos
+^^^^^^^^^^^^^^^^
+
+Restituisce la posizione nella stringa UTF-8.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_utf8_pos (const char *string, int real_pos);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'real_pos': posizione (byte)
+
+Valore restituito:
+
+* posizione (numero di caratteri)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int pos = weechat_utf8_pos ("chêne", 4); /* == 3 */
+----------------------------------------
+
+weechat_utf8_strndup
+^^^^^^^^^^^^^^^^^^^^
+
+Restituisce la stringa duplicata, di lunghezza massima 'lenght'.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_utf8_strndup (const char *string, int length);
+----------------------------------------
+
+Argomenti:
+
+* 'string': stringa
+* 'length': caratteri massimi da duplicare
+
+Valore restituito:
+
+* stringa duplicata (deve essere liberata chiamando "free" dopo l'uso)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *string = weechat_utf8_strndup ("chêne", 3); /* returns "chê" */
+/* ... */
+free (string);
+----------------------------------------
+
+[[directories]]
+Cartelle
+~~~~~~~~
+
+Alcune funzioni legate alle cartelle.
+
+weechat_mkdir_home
+^^^^^^^^^^^^^^^^^^
+
+Crea una cartella nella home di WeeChat.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_mkdir_home (char *directory, int mode);
+----------------------------------------
+
+Argomenti:
+
+* 'directory': nome della cartella da creare
+* 'mode': modalità per la cartella
+
+Valore restituito:
+
+* 1 se la cartella è stata creata con successo, 0 se si è verificato
+  un errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (!weechat_mkdir_home ("temp", 0755))
+{
+    /* errore */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.mkdir_home(directory, mode)
+
+# esempio
+weechat.mkdir_home("temp", 0755)
+----------------------------------------
+
+weechat_mkdir
+^^^^^^^^^^^^^
+
+Crea una cartella.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_mkdir (char *directory, int mode);
+----------------------------------------
+
+Argomenti:
+
+* 'directory': nome della cartella da creare
+* 'mode': modalità per la cartella
+
+Valore restituito:
+
+* 1 se la cartella è stata creata con successo, 0 se si è verificato
+  un errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (!weechat_mkdir ("/tmp/mydir", 0755))
+{
+    /* errore */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.mkdir(directory, mode)
+
+# esempio
+weechat.mkdir("/tmp/mydir", 0755)
+----------------------------------------
+
+weechat_mkdir_parents
+^^^^^^^^^^^^^^^^^^^^^
+
+Crea una cartella e le cartelle genitore se necessario.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_mkdir_parents (char *directory, int mode);
+----------------------------------------
+
+Argomenti:
+
+* 'directory': nome della cartella da creare
+* 'mode': modalità per la cartella
+
+Valore restituito:
+
+* 1 se la cartella è stata creata con successo, 0 se si è verificato
+  un errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (!weechat_mkdir_parents ("/tmp/mia/cartella", 0755))
+{
+    /* errore */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.mkdir_parents(directory, mode)
+
+# esempio
+weechat.mkdir_parents("/tmp/my/dir", 0755)
+----------------------------------------
+
+weechat_exec_on_files
+^^^^^^^^^^^^^^^^^^^^^
+
+Cerca i file in una cartella ed esegue un callback su ogni file.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_exec_on_files (const char *directory,
+                            int hidden_files,
+                            void *data,
+                            void (*callback)(void *data,
+                                             const char *filename));
+----------------------------------------
+
+Argomenti:
+
+* 'directory': cartella in cui cercare i file
+* 'hidden_files': 1 per includere i file nascosti, altrimenti 0
+* 'data': puntatore fornito al callback quando chiamato da WeeChat
+* 'callback': funzione chiamata per ogni file trovato, argomenti:
+** 'void *data': puntatore
+** 'const char *filename': nome file trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+void callback (void *data, const char *filename)
+{
+    /* ... */
+}
+...
+weechat_exec_on_files ("/tmp", 0, NULL, &callback);
+----------------------------------------
+
+[[util]]
+Util
+~~~~
+
+Alcune funzioni utili.
+
+weechat_timeval_cmp
+^^^^^^^^^^^^^^^^^^^
+
+Confronta due strutture "timeval".
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_timeval_cmp (struct timeval *tv1, struct timeval *tv2);
+----------------------------------------
+
+Argomenti:
+
+* 'tv1': prima struttura "timeval"
+* 'tv2': seconda struttura "timeval"
+
+Valore restituito:
+
+* -1 se tv1 < tv2
+* zero se tv1 == tv2
+* +1 se tv1 > tv2
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_timeval_cmp (&tv1, &tv2) > 0)
+{
+    /* tv1 > tv2 */
+}
+----------------------------------------
+
+weechat_timeval_diff
+^^^^^^^^^^^^^^^^^^^^
+
+Restituisce la differenza (in millisecondi) tra due strutture "timeval".
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+long weechat_timeval_diff (struct timeval *tv1, struct timeval *tv2);
+----------------------------------------
+
+Argomenti:
+
+* 'tv1': prima struttura "timeval"
+* 'tv2': seconda struttura "timeval"
+
+Valore restituito:
+
+* differenza in millisecondi
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+long diff = weechat_timeval_diff (&tv1, &tv2);
+----------------------------------------
+
+weechat_timeval_add
+^^^^^^^^^^^^^^^^^^^
+
+Aggiungi intervallo (in millisecondi) ad una struttura timeval.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_timeval_add (struct timeval *tv, long interval);
+----------------------------------------
+
+Argomenti:
+
+* 'tv': struttura timeval
+* 'interval': intervallo (in millisecondi)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_timeval_add (&tv, 2000); /* add 2 seconds */
+----------------------------------------
+
+[[sorted_lists]]
+Elenchi ordinati
+~~~~~~~~~~~~~~~~
+
+Funzioni lista ordinata.
+
+weechat_list_new
+^^^^^^^^^^^^^^^^
+
+Crea una nuova lista.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_weelist *weechat_list_new ();
+----------------------------------------
+
+Valore restituito:
+
+* puntatore alla nuova lista
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_weelist *list = weechat_list_new ();
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+list = weechat.list_new()
+
+# esempio
+list = weechat.list_new()
+----------------------------------------
+
+weechat_list_add
+^^^^^^^^^^^^^^^^
+
+Aggiunge un elemento in una lista.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *weechat_list_add (struct t_weelist *weelist,
+                                         const char *data,
+                                         const char *where,
+                                         void *user_data);
+----------------------------------------
+
+Argomenti:
+
+* 'weelist': puntatore alla lista
+* 'data': dati da inserire nella lista
+* 'where': posizione nella lista:
+** 'WEECHAT_LIST_POS_SORT': aggiunge alla lista, mantenendola ordinata
+** 'WEECHAT_LIST_POS_BEGINNING': aggiunge all'inizio della lista
+** 'WEECHAT_LIST_POS_END': aggiunge alla fine della lista
+* 'user_data': qualsiasi puntatore
+
+Valore restituito:
+
+* puntatore al nuovo elemento
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *my_item =
+    weechat_list_add (list, "my data", WEECHAT_LIST_POS_SORT, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+item = weechat.list_add(list, data, where, user_data)
+
+# esempio
+item = weechat.list_add(list, "miei dati", weechat.WEECHAT_LIST_POS_SORT, "")
+----------------------------------------
+
+weechat_list_search
+^^^^^^^^^^^^^^^^^^^
+
+Cerca un elemento nella lista.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *weechat_list_search (struct t_weelist *weelist,
+                                            const char *data);
+----------------------------------------
+
+Argomenti:
+
+* 'weelist': puntatore alla lista
+* 'data': dati da cercare nella lista
+
+Valore restituito:
+
+* puntatore all'elemento trovato, NULL se non trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *item = weechat_list_search (list, "my data");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+item = weechat.list_search(list, data)
+
+# esempio
+item = weechat.list_search(list, "miei dati")
+----------------------------------------
+
+weechat_list_casesearch
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Cerca un elemento nella lista, ignorando maiuscole/minuscole.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *weechat_list_casesearch (struct t_weelist *weelist,
+                                                const char *data);
+----------------------------------------
+
+Argomenti:
+
+* 'weelist': puntatore alla lista
+* 'data': dati da cercare nella lista
+
+Valore restituito:
+
+* puntatore all'elemento trovato, NULL se non trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *item = weechat_list_casesearch (list, "my data");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+item = weechat.list_casesearch(list, data)
+
+# esempio
+item = weechat.list_casesearch(list, "my data")
+----------------------------------------
+
+weechat_list_get
+^^^^^^^^^^^^^^^^
+
+Return an item in a list by position.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *weechat_list_get (struct t_weelist *weelist,
+                                         int position);
+----------------------------------------
+
+Argomenti:
+
+* 'weelist': puntatore alla lista
+* 'position': posizione nella lista (il primo elemento è 0)
+
+Valore restituito:
+
+* puntatore all'elemento trovato, NULL se non trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *item = weechat_list_get (list, 0); /* first item */
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+item = weechat.list_get(list, position)
+
+# esempio
+item = weechat.list_get(list, 0)
+----------------------------------------
+
+weechat_list_set
+^^^^^^^^^^^^^^^^
+
+Imposta un nuovo valore per un elemento.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_list_set (struct t_weelist_item *item, const char *value);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento
+* 'value': nuovo valore per l'elemento
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_list_set (item, "nuovi dati");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.list_set(item, value)
+
+# esempio
+weechat.list_set(item, "new data")
+----------------------------------------
+
+weechat_list_next
+^^^^^^^^^^^^^^^^^
+
+Restituisce l'elemento successivo nella lista.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *weechat_list_next (struct t_weelist_item *item);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento
+
+Valore restituito:
+
+* puntatore all'elemento successivo, NULL se il puntatore è
+  l'ultimo oggetto nella lista
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *next_item = weechat_list_next (item);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+item = weechat.list_next(item)
+
+# esempio
+item = weechat.list_next(item)
+----------------------------------------
+
+weechat_list_prev
+^^^^^^^^^^^^^^^^^
+
+Restituisce l'elemento precedente nella lista.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *weechat_list_prev (struct t_weelist_item *item);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento
+
+Valore restituito:
+
+* puntatore all'elemento precedente, NULL se il puntatore è
+  l'ultimo elemento nella lista
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_weelist_item *prev_item = weechat_list_prev (item);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+item = weechat.list_prev(item)
+
+# esempio
+item = weechat.list_prev(item)
+----------------------------------------
+
+weechat_list_string
+^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore stringa di un elemento.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_list_string (struct t_weelist_item *item);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento
+
+Valore restituito:
+
+* valore stringa di un elemento
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "value of item: %s", weechat_list_string (item));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.list_string(item)
+
+# esempio
+weechat.prnt("", "value of item: %s" % weechat.list_string(item))
+----------------------------------------
+
+weechat_list_size
+^^^^^^^^^^^^^^^^^
+
+Restituisce la dimensione della lista (numero di elementi).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_list_size (struct t_weelist *weelist);
+----------------------------------------
+
+Argomenti:
+
+* 'weelist': puntatore alla lista
+
+Valore restituito:
+
+* dimensione della lista (numero di elementi), 0 se la lista
+  è vuota
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "size of list: %d", weechat_list_size (list));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+size = weechat.list_size(list)
+
+# esempio
+weechat.prnt("", "size of list: %d" % weechat.list_size(list))
+----------------------------------------
+
+weechat_list_remove
+^^^^^^^^^^^^^^^^^^^
+
+Rimuove un elemento in una lista.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_list_remove (struct t_weelist *weelist,
+                          struct t_weelist_item *item);
+----------------------------------------
+
+Argomenti:
+
+* 'weelist': puntatore alla lista
+* 'item': puntatore all'elemento
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_list_remove (list, item);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.list_remove(list, item)
+
+# esempio
+weechat.list_remove(list, item)
+----------------------------------------
+
+weechat_list_remove_all
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Rimuove tutti gli elementi in una lista.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_list_remove_all (struct t_weelist *weelist);
+----------------------------------------
+
+Argomenti:
+
+* 'weelist': puntatore alla lista
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_list_remove_all (list);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.list_remove_all(list)
+
+# esempio
+weechat.list_remove_all(list)
+----------------------------------------
+
+weechat_list_free
+^^^^^^^^^^^^^^^^^
+
+Libera una lista.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_list_free (struct t_weelist *weelist);
+----------------------------------------
+
+Argomenti:
+
+* 'weelist': puntatore alla lista
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_list_free (list);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.list_free(list)
+
+# esempio
+weechat.list_free(list)
+----------------------------------------
+
+[[configuration_files]]
+File di configurazione
+~~~~~~~~~~~~~~~~~~~~~~
+
+Funzioni per i file di configurazione.
+
+weechat_config_new
+^^^^^^^^^^^^^^^^^^
+
+Crea un nuovo file di configurazione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_config_file *weechat_config_new (const char *name,
+                                          int (*callback_reload)(void *data,
+                                                                 struct t_config_file *config_file),
+                                          void *callback_reload_data);
+----------------------------------------
+
+Argomenti:
+
+* 'name': nome del file di configurazione (senza percorso o estensione)
+* 'callback_reload': funzione chiamata quando il file di configurazione viene
+  ricaricato con `/reload` (opzionale, può essere NULL), argomenti:
+** 'void *data': puntatore
+** 'struct t_config_file *config_file': puntatore al file di configurazione
+* 'callback_reload_data': puntatore fornito per ricaricare il callback
+  quando richiesto da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo file di configurazione, NULL se si è verificato
+  un errore
+
+[NOTE]
+Il file NON viene creato su disco da questa funzione. Verrà creato chiamando
+la funzione <<_weechat_write_config>>. Si dovrebbe chiamare questa funzione
+solo dopo aver aggiunto alcune sezioni (con <<_weechat_config_new_section>>)
+e le opzioni (con <<_weechat_config_new_option>>).
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_config_reload_cb (void *data, struct t_config_file *config_file)
+{
+    /* ... */
+    
+    return WEECHAT_RC_OK;
+}
+
+struct t_config_file *config_file = weechat_config_new ("test",
+                                                        &my_config_reload_cb,
+                                                        NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+config_file = weechat.config_new(name, calback_reload, callback_reload_data)
+
+# esempio
+def my_config_reload_cb(data, config_file):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+config_file = weechat.config_new("test", "my_config_reload_cb", "")
+----------------------------------------
+
+weechat_config_new_section
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Crea una nuova sezione nel file di configurazione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_config_section *weechat_config_new_section (
+    struct t_config_file *config_file,
+    const char *name,
+    int user_can_add_options,
+    int user_can_delete_options,
+    int (*callback_read)(void *data,
+                         struct t_config_file *config_file,
+                         struct t_config_section *section,
+                         const char *option_name,
+                         const char *value),
+    void *callback_read_data,
+    int (*callback_write)(void *data,
+                          struct t_config_file *config_file,
+                          const char *section_name),
+    void *callback_write_data,
+    int (*callback_write_default)(void *data,
+                                  struct t_config_file *config_file,
+                                  const char *section_name);
+    void *callback_write_default_data,
+    int (*callback_create_option)(void *data,
+                                  struct t_config_file *config_file,
+                                  struct t_config_section *section,
+                                  const char *option_name,
+                                  const char *value),
+    void *callback_create_option_data,
+    int (*callback_delete_option)(void *data,
+                                  struct t_config_file *config_file,
+                                  struct t_config_section *section,
+                                  struct t_config_option *option),
+    void *callback_delete_option_data);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': puntatore al file di configurazione
+* 'name': nome della sezione
+* 'user_can_add_options': 1 se l'utente può creare nuove opzioni nella sezione,
+  oppure 0 se non gli è consentito
+* 'user_can_delete_options': 1 se l'utente può eliminare le opzioni nella sezione,
+  oppure 0 se non gli è consentito
+* 'callback_read': funzione chiamata quando un'opzione nella sezione viene letta
+  da disco (dovrebbe essere NULL in molti casi, tranne se l'opzione nella sezione
+  necessita di una funzione personalizza), argomenti:
+** 'void *data': puntatore
+** 'struct t_config_file *config_file': puntatore al file di configurazione
+** 'struct t_config_section *section': puntatore alla sezione
+** 'const char *option_name': nome dell'opzione
+** 'const char *value': valore
+* 'callback_read_data': puntatore fornito al callback quando chiamato da WeeChat
+* 'callback_write': funzione chiamata quando la sezione è scritta nel file (dovrebbe
+  essere NULL in molti casi, tranne se la sezione necessita di una funzione
+  personalizzata), argomenti:
+** 'void *data': puntatore
+** 'struct t_config_file *config_file': puntatore al file di configurazione
+** 'struct t_config_section *section': puntatore alla sezione
+** 'const char *option_name': nome dell'opzione
+* callback_write_data: puntatore fornito al callback quando chiamato da WeeChat
+* callback_write_default: funzione chiamata quando i valori predefiniti per la sezione
+  devono essere scritti in un file, argomenti:
+** 'void *data': puntatore
+** 'struct t_config_file *config_file': puntatore al file di configurazione
+** 'const char *section_name': nome della sezione
+* 'callback_write_default_data': puntatore fornito al callback quando chiamato da
+  WeeChat
+* 'callback_create_option': funzione chiamata quando viene creata una nuova
+  opzione nella sezione (NULL se la sezione non consente di creare nuove
+  opzioni), argomenti:
+** 'void *data': puntatore
+** 'struct t_config_file *config_file': puntatore al file di configurazione
+** 'struct t_config_section *section': puntatore alla sezione
+** 'const char *option_name': nome dell'opzione
+** 'const char *value': valore
+* 'callback_create_option_data': puntatore fornito al callback quando chiamato
+  da WeeChat
+* 'callback_delete_option': funzione chiamata quando un'opzione viene eliminata
+  nella sezione (NULL se la sezione non consente di eliminare delle opzioni),
+  argomenti:
+** 'void *data': puntatore
+** 'struct t_config_file *config_file': puntatore al file di configurazione
+** 'struct t_config_section *section': puntatore alla sezione
+** 'struct t_config_option *option': puntatore all'opzione
+* 'callback_delete_option_data': puntatore fornito al callback quando chiamato
+  da WeeChat
+
+Valore restituito:
+
+* puntatore alla nuova sezione nel file di configurazione, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_section_read_cb (void *data, struct t_config_file *config_file,
+                    struct t_config_section *section, const char *option_name,
+                    const char *value)
+{
+    /* ... */
+    
+    return WEECHAT_RC_OK;
+}
+
+int
+my_section_write_cb (void *data, struct t_config_file *config_file,
+                     const char *section_name)
+{
+    /* ... */
+    
+    return WEECHAT_RC_OK;
+}
+
+int
+my_section_write_default_cb (void *data, struct t_config_file *config_file,
+                             const char *section_name)
+{
+    /* ... */
+    
+    return WEECHAT_RC_OK;
+}
+
+int
+my_section_create_option_cb (void *data, struct t_config_file *config_file,
+                             struct t_config_section *section,
+                             const char *option_name, const char *value)
+{
+    /* ... */
+    
+    return WEECHAT_RC_OK;
+}
+
+int
+my_section_delete_option_cb (void *data, struct t_config_file *config_file,
+                             struct t_config_section *section,
+                             struct t_config_option *option)
+{
+    /* ... */
+    
+    return WEECHAT_RC_OK;
+}
+
+/* sezione standart, l'utente non può aggiungere/eliminare opzioni */
+struct t_config_section *new_section1 =
+    weechat_config_new_section (config_file, "section1", 0, 0,
+                                NULL, NULL, /* read callback */
+                                NULL, NULL, /* write callback */
+                                NULL, NULL, /* write default callback */
+                                NULL, NULL, /* create option callback */
+                                NULL, NULL); /* delete option callback */
+
+/* sezione speciale, l'utente può aggiungere/eliminare opzioni, e le
+   opzioni necessitano di un callback per essere lette/scritte */
+struct t_config_section *new_section2 =
+    weechat_config_new_section (config_file, "section2", 1, 1,
+                                &my_section_read_cb, NULL,
+                                &my_section_write_cb, NULL,
+                                &my_section_write_default_cb, NULL,
+                                &my_section_create_option_cb, NULL,
+                                &my_section_delete_option_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+section = weechat.config_new_section(config_file, name,
+    user_can_add_options, user_can_delete_options,
+    callback_read, callback_read_data,
+    callback_write, callback_write_data,
+    callback_create_option, callback_create_option_data,
+    callback_delete_option, callback_delete_option_data)
+
+# esempio
+def my_section_read_cb(data, config_file, section, option_name, value):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+def my_section_write_cb(data, config_file, section_name):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+def my_section_write_default_cb(data, config_file, section_name):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+def my_section_create_option_cb(data, config_file, section, option_name, value):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+def my_section_delete_option_cb(data, config_file, section, option):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+section = weechat.config_new_section(config_file, "section1", 1, 1,
+    "my_section_read_cb", "",
+    "my_section_write_cb", "",
+    "my_section_write_default_cb", "",
+    "my_section_create_option_cb", "",
+    "my_section_delete_option_cb", "")
+----------------------------------------
+
+weechat_config_search_section
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Cerca una sezione in un file di configurazione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_config_section *weechat_config_search_section (
+    struct t_config_file *config_file,
+    const char *section_name);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': puntatore al file di configurazione
+* 'section_name': nome della sezione da cercare
+
+Valore restituito:
+
+* puntatore alla sezione trovata, NULL se non trovata
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_config_section *section = weechat_config_search_section (config_file,
+                                                                  "section");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+section = weechat.config_search_section(config_file, section_name)
+
+# esempio
+section = weechat.config_search_section(config_file, "section")
+----------------------------------------
+
+weechat_config_new_option
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Crea una nuova opzione nella sezione di un file di configurazione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_config_option *weechat_config_new_option (
+    struct t_config_file *config_file,
+    struct t_config_section *section,
+    const char *name,
+    const char *type,
+    const char *description,
+    const char *string_values,
+    int min,
+    int max,
+    const char *default_value,
+    const char *value,
+    int null_value_allowed,
+    int (*callback_check_value)(void *data,
+                                struct t_config_option *option,
+                                const char *value),
+    void *callback_check_value_data,
+    int (*callback_change)(void *data,
+                           struct t_config_option *option),
+    void *callback_change_data,
+    int (*callback_delete)(void *data,
+                           struct t_config_option *option),
+    void *callback_delete_data);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': puntatore al file di configurazione
+* 'section': puntatore alla sezione
+* 'name': nome dell'opzione
+* 'type': tipo dell'opzione:
+** 'boolean': valore booleano (on/off)
+** 'integer': valore intero (con stringhe opzionali per i valori)
+** 'string': valore stringa
+** 'color': colore
+* 'description': descrizione dell'opzione
+* 'string_values': valori come stringa (separati da "|"), usato dal tipo 'integer'
+  (opzionale)
+* 'min': valore minimo (per il tipo 'integer')
+* 'max': valore massimo (per il tipo 'integer')
+* 'default_value': valore predefinito per l'opzione (usato per il reset dell'opzione)
+* 'value': valore per l'opzione
+* 'null_value_allowed': 1 se 'null' (valore non definito) è consentito per l'opzione,
+  altrimenti 0
+* 'callback_check_value': funzione chiamata per verificare il nuovo valore per
+  l'opzione (ozionale), argomenti:
+** 'void *data': puntatore
+** 'struct t_config_option *option': puntatore all'opzione
+** 'const char *value': nuovo valore per l'opzione
+* 'callback_check_value_data': puntatore fornito alla callback check_value
+  quando chiamato da WeeChat
+* 'callback_change': funzione chiamata quando il valore dell'opzione è stata
+  cambiata (opzionale), argomenti:
+** 'void *data': puntatore
+** 'struct t_config_option *option': puntatore all'opzione
+* 'callback_change_data': puntatore fornito per cambiare alla callback quando
+  chiamato da WeeChat
+* 'callback_delete': funzione chiamata quando l'opzione verrà eliminata
+  (opzionale), argomenti:
+** 'void *data': puntatore
+** 'struct t_config_option *option': puntatore all'opzione
+* 'callback_delete_data': puntatore fornito per eiliminare alla callback quando
+  chiamato da WeeChat
+
+Valore restituito:
+
+ alla nuova opzione nella sezione, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+/* booleano */
+struct t_config_option *option1 =
+    weechat_config_new_option (config_file, section, "option1", "boolean",
+                               "My option, type boolean"
+                               NULL, /* valori stringa */
+                               0, 0, /* min, max */
+                               "on", /* predefinito */
+                               "on", /* valore */
+                               0, /* null value allowed */
+                               NULL, NULL, /* verifica callback */
+                               NULL, NULL, /* modifica callback */
+                               NULL, NULL); /* elimina callback */
+
+/* intero */
+struct t_config_option *option2 =
+    weechat_config_new_option (config_file, section, "option2", "integer",
+                               "My option, type integer"
+                               NULL, /* string values */
+                               0, 100, /* min, max */
+                               "15", /* default */
+                               "15", /* value */
+                               0, /* null value allowed */
+                               NULL, NULL, /* verifica callback */
+                               NULL, NULL, /* modifica callback */
+                               NULL, NULL); /* elimina callback */
+
+/* intero (con valori stringa) */
+struct t_config_option *option3 =
+    weechat_config_new_option (config_file, section, "option3", "integer",
+                               "My option, type integer (with string values)"
+                               "top|bottom|left|right", /* string values */
+                               0, 0, /* min, max */
+                               "bottom", /* predefinito */
+                               "bottom", /* valoree */
+                               0, /* null value allowed */
+                               NULL, NULL, /* verifica callback */
+                               NULL, NULL, /* modifica callback */
+                               NULL, NULL); /* elimina callback */
+
+/* stringa */
+struct t_config_option *option4 =
+    weechat_config_new_option (config_file, section, "option4", "string",
+                               "My option, type string"
+                               NULL, /* valori stringa */
+                               0, 0, /* min, max */
+                               "test", /* predefinito */
+                               "test", /* valore */
+                               1, /* valore null consentito */
+                               NULL, NULL, /* verifica callback */
+                               NULL, NULL, /* modifica callback */
+                               NULL, NULL); /* elimina callback */
+
+/* colore */
+struct t_config_option *option5 =
+    weechat_config_new_option (config_file, section, "option5", "color",
+                               "My option, type color"
+                               NULL, /* valori stringa */
+                               0, 0, /* min, max */
+                               "lightblue", /* predefinito */
+                               "lightblue", /* valore */
+                               0, /* valore null consentito */
+                               NULL, NULL, /* verifica callback */
+                               NULL, NULL, /* modifica callback */
+                               NULL, NULL); /* elimina callback */
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+option = weechat.config_new_option(config_file, section, name, type, description,
+    string_values, min, max, default_value, value, null_value_allowed,
+    callback_check_value, callback_check_value_data,
+    callback_change, callback_change_data,
+    callback_delete, callback_delete_data)
+
+# esempio
+def option4_check_value_cb(data, option, value):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+def option4_change_cb(data, option):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+def option4_delete_cb(data, option):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+option1 = weechat.config_new_option(config_file, section, "option1", "boolean",
+    "My option, type boolean",
+    "", 0, 0, "on", "on", 0,
+    "", "",
+    "", "",
+    "", "")
+
+option2 = weechat.config_new_option(config_file, section, "option2", "integer",
+    "My option, type integer",
+    "", 0, 100, "15", "15", 0,
+    "", "",
+    "", "",
+    "", "")
+
+option3 = weechat.config_new_option(config_file, section, "option3", "integer",
+    "My option, type integer (with string values)",
+    "top|bottom|left|right",
+    0, 0, "bottom", "bottom", 0,
+    "", "",
+    "", "",
+    "", "")
+
+option4 = weechat.config_new_option(config_file, section, "option4", "string",
+    "My option, type string",
+    "", 0, 0, "test", "test", 1,
+    "option4_check_value_cb", ""
+    "option4_change_cb", "",
+    "option4_delete_cb", "")
+
+option5 = weechat.config_new_option(config_file, section, "option5", "color",
+    "My option, type color",
+    "", 0, 100, "lightblue", "lightblue", 0,
+    "", "",
+    "", "",
+    "", "")
+----------------------------------------
+
+weechat_config_search_option
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Cerca un'opzione nella sezione di un file di configurazione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_config_option *weechat_config_search_option (
+    struct t_config_file *config_file,
+    struct t_config_section *section,
+    const char *option_name);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': puntatore al file di configurazione
+* 'section': puntatore alla sezione
+* 'name': nome dell'opzione da cercare
+
+Valore restituito:
+
+* puntatore all'opzione trovata, NULL se non trovata
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_config_option *option =
+    weechat_config_search_option (config_file, section, "option");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+option = weechat.config_search_option(config_file, section, option_name)
+
+# esempio
+option = weechat.config_search_option(config_file, section, "option")
+----------------------------------------
+
+weechat_config_search_with_string
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Cerca un'opzione con il nome completo.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_config_search_with_string (const char *option_name,
+                                        struct t_config_file **config_file,
+                                        struct t_config_section **section,
+                                        struct t_config_option **option);
+----------------------------------------
+
+Argomenti:
+
+* 'option_name': nome completo dell'opzione (formato: "file.section.option")
+* 'config_file': puntatore al puntatore del file di configurazione, sarà impostato
+  al puntatore al file di configurazione se l'opzione viene trovata
+* 'section': puntatore al puntatore della sezione, sarà impostato alla sezione
+  dell'opzione, se viene trovata
+* 'option': puntatore al puntatore dell'opzione, sarà impostato al puntatore di
+  un'opzione, se viene trovata
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_config_file *ptr_config_file;
+struct t_config_section *ptr_section;
+struct t_config_option *ptr_option;
+
+weechat_config_search_with_string ("file.section.option",
+                                   &ptr_config_file,
+                                   &ptr_section,
+                                   &ptr_option);
+if (ptr_option)
+{
+    /* opzione trovata */
+}
+else
+{
+    /* opzione non trovata */
+}
+----------------------------------------
+
+weechat_config_string_to_boolean
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Verifica se un testo è "vero" o "falso", come valore booleano.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_string_to_boolean (const char *text);
+----------------------------------------
+
+Argomenti:
+
+* 'text': testo da analizzare
+
+Valore restituito:
+
+* 1 se il testo è "true" ("on", "yes", "y", "true", "t", "1")
+* 0 se il testo è "false" ("off", "no", "n", "false", "f", "0")
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_config_string_to_boolean (option_value))
+{
+    /* il valore è "true" */
+}
+else
+{
+    /* il valore è "false" */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_string_to_boolean(text)
+
+# esempio
+if weechat.config_string_to_boolean(text):
+    # ...
+----------------------------------------
+
+weechat_config_option_reset
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Resetta un'opzione al proprio valore predefinito.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_option_reset (struct t_config_option *option,
+                                 int run_callback);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+* 'run_callback': 1 per la chiamata alla callbackse il valore dell'opzione
+  è cambiato, altrimenti 0
+
+Valore restituito:
+
+* 'WEECHAT_CONFIG_OPTION_SET_OK_CHANGED' se il valore dell'opzione è stato
+  resettato
+* 'WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE' se il valore non è stato
+  modificato
+* 'WEECHAT_CONFIG_OPTION_SET_ERROR' se si è verificato un errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+switch (weechat_config_option_reset (option, 1))
+{
+    case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED:
+        /* .... */
+        break;
+    case WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE:
+        /* .... */
+        break;
+    case WEECHAT_CONFIG_OPTION_SET_ERROR:
+        /* .... */
+        break;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.config_option_reset(option, run_callback)
+
+# esempio
+rc = weechat.config_option_reset(option, 1)
+if rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_CHANGED:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR:
+    # ...
+----------------------------------------
+
+weechat_config_option_set
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Imposta un nuovo valore per l'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_option_set (struct t_config_option *option,
+                               const char *value, int run_callback);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+* 'value': nuovo valore per l'opzione
+* 'run_callback': 1 per la chiamata alla callback chang se il valore dell'opzione
+  è cambiato, altrimenti 0
+
+Valore restituito:
+
+* 'WEECHAT_CONFIG_OPTION_SET_OK_CHANGED' se il valore dell'opzione è
+  cambiato
+* 'WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE' se il valore non è cambiato
+* 'WEECHAT_CONFIG_OPTION_SET_ERROR' se si è verificato un errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+switch (weechat_config_option_set (option, "new_value", 1))
+{
+    case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED:
+        /* .... */
+        break;
+    case WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE:
+        /* .... */
+        break;
+    case WEECHAT_CONFIG_OPTION_SET_ERROR:
+        /* .... */
+        break;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.config_option_set(option, value, run_callback)
+
+# esempio
+rc = weechat.config_option_set(option, "new_value", 1)
+if rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_CHANGED:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR:
+    # ...
+----------------------------------------
+
+weechat_config_option_set_null
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Imposta null (valore non definito) per un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_option_set_null (struct t_config_option *option,
+                                    int run_callback);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+* 'run_callback': 1 per la chiamata alla callback chang se il valore
+  dell'opzione è cambiato (se non è null), altrimenti 0
+
+[NOTE]
+È possibile impostare il valore a null solo se è consentito per l'opzione
+(consultare <<_weechat_config_new_option>>).
+
+Valore restituito:
+
+* 'WEECHAT_CONFIG_OPTION_SET_OK_CHANGED' se il valore dell'opzione è
+  cambiato
+* 'WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE' se il valore non è cambiato
+* 'WEECHAT_CONFIG_OPTION_SET_ERROR' se si è verificato un errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+switch (weechat_config_option_set_null (option, 1))
+{
+    case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED:
+        /* .... */
+        break;
+    case WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE:
+        /* .... */
+        break;
+    case WEECHAT_CONFIG_OPTION_SET_ERROR:
+        /* .... */
+        break;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.config_option_set_null(option, run_callback)
+
+# esempio
+rc = weechat.config_option_set_null(option, 1)
+if rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_CHANGED:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR:
+    # ...
+----------------------------------------
+
+weechat_config_option_unset
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Rimuove/resetta un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_option_unset (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* 'WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET' se il valore dell'opzione non è
+  stato resettato
+* 'WEECHAT_CONFIG_OPTION_UNSET_OK_RESET' se il valore dell'opzione è stato
+  resettato
+* 'WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED' se l'opzione è stata rimossa
+* 'WEECHAT_CONFIG_OPTION_UNSET_ERROR' se si è verificato un errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+switch (weechat_config_option_unset (option))
+{
+    case WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET:
+        /* .... */
+        break;
+    case WEECHAT_CONFIG_OPTION_UNSET_OK_RESET:
+        /* .... */
+        break;
+    case WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED:
+        /* .... */
+        break;
+    case WEECHAT_CONFIG_OPTION_UNSET_ERROR:
+        /* .... */
+        break;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.config_option_unset(option)
+
+# esempio
+rc = weechat.config_option_unset(option)
+if rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_RESET:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_ERROR:
+    # ...
+----------------------------------------
+
+weechat_config_option_rename
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Rinomina un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_config_option_rename (struct t_config_option *option,
+                                   const char *new_name);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+* 'new_name': nuovo nome per l'opzione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_config_option_rename (option, "new_name");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.config_option_rename(option, new_name)
+
+# esempio
+weechat.config_option_rename(option, "new_name")
+----------------------------------------
+
+weechat_config_option_get_pointer
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce un puntatore alla proprietà di un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void *weechat_config_option_get_pointer (struct t_config_option *option,
+                                         const char *property);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+* 'property': nome della proprietà:
+** 'config_file': puntatore al file di configurazione ('struct t_config_file *')
+** 'section': puntatore alla sezione ('struct t_config_section *')
+** 'name': nome dell'opzione ('char *')
+** 'type': tipo dell'opzione ('int *')
+** 'description': descrizione dell'opzione ('char *')
+** 'string_values': valori stringa ('char *')
+** 'min': valore minimo ('int *')
+** 'max': valore massimo ('int *')
+** 'default_value': valore predefinito (dipende dal tipo)
+** 'value': valore corrente (dipende dal tipo)
+** 'prev_option': puntatore all'opzione precedente ('struct t_config_option *')
+** 'next_option': puntatore all'opzione successiva ('struct t_config_option *')
+
+Valore restituito:
+
+* puntatore alla proprietà richiesta
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *description = weechat_config_option_get_pointer (option, "description");
+----------------------------------------
+
+weechat_config_option_is_null
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Verifica se un opzione è "null (valore non definito).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_option_is_null (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* 1 se il valore dell'opzione è "null"
+* 0 se il valore dell'opzione non è "null"
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_config_option_is_null (option))
+{
+    /* il valore è "null" */
+}
+else
+{
+    /* il valore non è "null" */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.config_option_is_null(option)
+
+# esempio
+if weechat.config_option_is_null(option):
+    # ...
+----------------------------------------
+
+weechat_config_option_default_is_null
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Verifica che il valore predefinito di un'opzione sia "null" (valore non definito).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_option_default_is_null (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* 1 se il valore predefinito di un'opzione è "null"
+* 0 se il valore predefinito di un'opzione non è  "null"
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_config_option_default_is_null (option))
+{
+    /* il valore predefinito è "null" */
+}
+else
+{
+    /* il valore predefinito non è "null" */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.config_option_default_is_null(option)
+
+# esempio
+if weechat.config_option_default_is_null(option):
+    # ...
+----------------------------------------
+
+weechat_config_boolean
+^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore bool di un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_boolean (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* valore bool di un'opzione (0 o 1)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_config_boolean (option))
+{
+    /* il valore è "true" */
+}
+else
+{
+    /* il valore è "false" */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_option_boolean(option)
+
+# esempio
+if weechat.config_option_boolean(option):
+    # ...
+----------------------------------------
+
+weechat_config_boolean_default
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore bool predefinito di un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_boolean_default (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* il valore bool predefinito di un'opzione (0 o 1)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_config_boolean_default (option))
+{
+    /* il valore è "true" */
+}
+else
+{
+    /* il valore è "false" */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_option_boolean_default(option)
+
+# esempio
+if weechat.config_option_boolean_default(option):
+    # ...
+----------------------------------------
+
+weechat_config_integer
+^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore intero di un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_integer (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* valore intero di un'opzione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int value = weechat_config_integer (option);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_option_integer(option)
+
+# esempio
+if weechat.config_option_integer(option):
+    # ...
+----------------------------------------
+
+weechat_config_integer_default
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore intero predefinito di un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_integer_default (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* valore intero predefinito di un'opzione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int value = weechat_config_integer_default (option);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_option_integer_default(option)
+
+# esempio
+if weechat.config_option_integer_default(option):
+    # ...
+----------------------------------------
+
+weechat_config_string
+^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore stringa di un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_config_string (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* valore stringa di un'opzione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+const char *value = weechat_config_string (option);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_option_string(option)
+
+# esempio
+value = weechat.config_option_string(option):
+----------------------------------------
+
+weechat_config_string_default
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore stringa predefinito di un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_config_integer_default (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* valore stringa predefinito di un'opzione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+const char *value = weechat_config_string_default (option);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_option_string_default(option)
+
+# esempio
+value = weechat.config_option_string_default(option):
+----------------------------------------
+
+weechat_config_color
+^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore colore di un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_config_color (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* valore colore dell'opzione (stringa con il nome del colore)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+const char *color = weechat_config_color (option);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_option_color(option)
+
+# esempio
+value = weechat.config_option_color(option):
+----------------------------------------
+
+weechat_config_color_default
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore colore predefinito di un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_config_color_default (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Valore restituito:
+
+* valore colore predefinito di un'opzione (stringa con il nome del colore)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+const char *color = weechat_config_color_default (option);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_option_color_default(option)
+
+# esempio
+value = weechat.config_option_color_default(option):
+----------------------------------------
+
+weechat_config_write_option
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Scrive una riga nel file di configurazione con l'opzione ed il suo valore
+(questa funzione dovrebbe essere chiamata solo nelle callback "write"
+o "write_default" per una sezione).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_config_write_option (struct t_config_file *config_file,
+                                  struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': puntatore al file di configurazione
+* 'option': puntatore all'opzione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_section_write_cb (void *data, struct t_config_file *config_file,
+                     const char *section_name)
+{
+    weechat_config_write_line (config_file, "my_section", NULL);
+    
+    weechat_config_write_option (config_file, option);
+    
+    return WEECHAT_RC_OK;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.config_write_option(config_file, option)
+
+# esempio
+def my_section_write_cb(data, config_file, section_name):
+    weechat.config_write_line(config_file, "my_section", "")
+    weechat.config_write_option(config_file, option)
+    return weechat.WEECHAT_RC_OK
+----------------------------------------
+
+weechat_config_write_line
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Scrive una riga nel file di configurazione (questa funzione dovrebbe
+essere chiamata solo nelle callback "write" o "write_default" per una
+sezione).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_config_write_line (struct t_config_file *config_file,
+                                const char *option_name,
+                                const char *value, ...);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': puntatore al file di configurazione
+* 'option_name': nome dell'opzione
+* 'value': valore (se NULL, allora la riga con il nome della sezione viene
+  scritto, ad esempio: "[section]")
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_section_write_cb (void *data, struct t_config_file *config_file,
+                     const char *section_name)
+{
+    weechat_config_write_line (config_file, "my_section", NULL);
+    
+    weechat_config_write_line (config_file, "option", "%s;%d",
+                               "value", 123);
+                               
+    return WEECHAT_RC_OK;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.config_write_line(config_file, option_name, value)
+
+# esempio
+def my_section_write_cb(data, config_file, section_name):
+    weechat.config_write_line(config_file, "my_section", "")
+    weechat.config_write_line(config_file, "option", "value")
+    return weechat.WEECHAT_RC_OK
+----------------------------------------
+
+weechat_config_write
+^^^^^^^^^^^^^^^^^^^^
+
+Scrive il file di configurazione su disco.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_write (struct t_config_file *config_file);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': puntatore al file di configurazione
+
+Valore restituito:
+
+* 'WEECHAT_CONFIG_WRITE_OK' se la configurazione è stata scritta
+* 'WEECHAT_CONFIG_WRITE_MEMORY_ERROR' se non c'è memoria sufficiente
+* 'WEECHAT_CONFIG_WRITE_ERROR' se si è verificato un altro errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+switch (weechat_config_write (config_file))
+{
+    case WEECHAT_CONFIG_WRITE_OK:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_WRITE_MEMORY_ERROR:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_WRITE_ERROR:
+        /* ... */
+        break;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.config_write(config_file)
+
+# esempio
+rc = weechat.config_write(config_file)
+if rc == weechat.WEECHAT_CONFIG_WRITE_OK:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_WRITE_MEMORY_ERROR:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_WRITE_ERROR:
+    # ...
+----------------------------------------
+
+weechat_config_read
+^^^^^^^^^^^^^^^^^^^
+
+Legge il file di configurazione su disco.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_read (struct t_config_file *config_file);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': puntatore al file di configurazione
+
+Valore restituito:
+
+* 'WEECHAT_CONFIG_READ_OK' se la configurazione è stata caricata
+* 'WEECHAT_CONFIG_READ_MEMORY_ERROR' se non c'è memoria sufficiente
+* 'WEECHAT_CONFIG_READ_FILE_NOT_FOUND' se il file non è stato trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+switch (weechat_config_read (config_file))
+{
+    case WEECHAT_CONFIG_READ_OK:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_READ_MEMORY_ERROR:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_READ_FILE_NOT_FOUND:
+        /* ... */
+        break;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.config_read(config_file)
+
+# esempio
+rc = weechat.config_read(config_file)
+if rc == weechat.WEECHAT_CONFIG_READ_OK:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_READ_MEMORY_ERROR:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_READ_FILE_NOT_FOUND:
+    # ...
+----------------------------------------
+
+weechat_config_reload
+^^^^^^^^^^^^^^^^^^^^^
+
+Ricarica il file di configurazione da disco.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_reload (struct t_config_file *config_file);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': configuration file pointer
+
+Valore restituito:
+
+* 'WEECHAT_CONFIG_READ_OK' se il file di configurazione è stato ricaricato
+* 'WEECHAT_CONFIG_READ_MEMORY_ERROR' se non c'è memoria sufficiente
+* 'WEECHAT_CONFIG_READ_FILE_NOT_FOUND' se il file non è stato trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+switch (weechat_config_reload (config_file))
+{
+    case WEECHAT_CONFIG_READ_OK:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_READ_MEMORY_ERROR:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_READ_FILE_NOT_FOUND:
+        /* ... */
+        break;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.config_reload(config_file)
+
+# esempio
+rc = weechat.config_reload(config_file)
+if rc == weechat.WEECHAT_CONFIG_READ_OK:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_READ_MEMORY_ERROR:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_READ_FILE_NOT_FOUND:
+    # ...
+----------------------------------------
+
+weechat_config_option_free
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Libera un'opzione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_config_option_free (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'option': puntatore all'opzione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_config_option_free (option);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.config_option_free(option)
+
+# esempio
+weechat.config_option_free(option)
+----------------------------------------
+
+weechat_config_section_free_options
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Libera tutte le opzioni in una sessione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_config_section_free_options (struct t_config_section *section);
+----------------------------------------
+
+Argomenti:
+
+* 'section': puntatore alla sezione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_config_section_free_options (section);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.config_section_free_options(section)
+
+# esempio
+weechat.config_section_free_options(section)
+----------------------------------------
+
+weechat_config_section_free
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Libera una sezione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_config_section_free (struct t_config_option *option);
+----------------------------------------
+
+Argomenti:
+
+* 'section': puntatore alla sezione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_config_section_free (section);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.config_section_free(section)
+
+# esempio
+weechat.config_section_free(section)
+----------------------------------------
+
+weechat_config_free
+^^^^^^^^^^^^^^^^^^^
+
+Libera un file di configurazione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_config_free (struct t_config_file *config_file);
+----------------------------------------
+
+Argomenti:
+
+* 'config_file': puntatore al file di configurazione
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_config_free (config_file);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.config_free(config_file)
+
+# esempio
+weechat.config_free(config_file)
+----------------------------------------
+
+weechat_config_get
+^^^^^^^^^^^^^^^^^^
+
+Cerca un'opzione con il nome completo.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_config_option *weechat_config_get (const char *option_name);
+----------------------------------------
+
+Argomenti:
+
+* 'option_name': nome completo dell'opzione (formato: "file.section.option")
+
+Valore restituito:
+
+* puntatore all'opzione trovata, NULL se non trovata
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_config_option *option = weechat_config_get ("weechat.look.item_time_format");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+option = weechat.config_get(option_name)
+
+# esempio
+option = weechat.config_get("weechat.look.item_time_format")
+----------------------------------------
+
+weechat_config_get_plugin
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Cerca un'opzione nei file di configurazione dei plugin (plugins.conf).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_config_get_plugin (const char *option_name);
+----------------------------------------
+
+Argomenti:
+
+* 'option_name': nome dell'opzione, WeeChat aggiungerà il prefisso
+  "plugins.var.xxx." (dove "xxx" è il nome del plugin corrente)
+
+Valore restituito:
+
+* valore dell'opzione trovata, NULL se non trovata
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+/* se il plugin corrente è "test", allora cerca il valore
+   dell'opzione "plugins.var.test.option" nel file plugins.conf */
+char *value = weechat_config_get_plugin ("option");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_get_plugin(option_name)
+
+# esempio
+value = weechat.config_get_plugin("option")
+----------------------------------------
+
+weechat_config_is_set_plugin
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Verifica se un'opzione è impostata nel file di configurazione dei
+plugin (plugins.conf).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_is_set_plugin (const char *option_name);
+----------------------------------------
+
+Argomenti:
+
+* 'option_name': nome dell'opzione, WeeChat aggiunge il prefisso "plugins.var.xxx."
+  (dove "xxx" è il nome del plugin corrente)
+
+Valore restituito:
+
+* 1 se l'opzione è impostata, 0 se l'opzione non esiste
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_config_is_set_plugin ("option"))
+{
+    /* l'opzione è impostata */
+}
+else
+{
+    /* l'opzione non esiste */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.config_is_set_plugin(option_name)
+
+# esempio
+if weechat.config_is_set_plugin("option"):
+    # l'opzione è impostata
+    # ...
+else:
+    # l'opzione non esiste
+    # ...
+----------------------------------------
+
+weechat_config_set_plugin
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Imposta il nuovo valore per l'opzione nel file di configurazione dei plugin (plugins.conf).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_set_plugin (const char *option_name, const char *value);
+----------------------------------------
+
+Argomenti:
+
+* 'option_name': nome dell'opzione, WeeChat aggiunge il prefisso "plugins.var.xxx."
+  (dove "xxx" è il nome del plugin corrente)
+* 'value': new value for option
+
+Valore restituito:
+
+* 'WEECHAT_CONFIG_OPTION_SET_OK_CHANGED' se il valore dell'opzione è stato modificato
+* 'WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE' se il valore non è cambiato
+* 'WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND' se l'opzione non è stata trovata
+* 'WEECHAT_CONFIG_OPTION_SET_ERROR' se si è verificato un errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+switch (weechat_config_set_plugin ("option", "test_value"))
+{
+    case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_OPTION_SET_ERROR:
+        /* ... */
+        break;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.config_set_plugin(option_name, value)
+
+# esempio
+rc = weechat.config_is_set_plugin("option", "test_value")
+if rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_CHANGED:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR:
+    # ...
+----------------------------------------
+
+weechat_config_unset_plugin
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Disattiva l'opzione nel file di configurazione dei plugin (plugins.conf).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_config_unset_plugin (const char *option_name);
+----------------------------------------
+
+Argomenti:
+
+* 'option_name': nome dell'opzione, WeeChat aggiunge il prefisso "plugins.var.xxx."
+  (dove xxx è il nome del plugin corrente)
+
+Valore restituito:
+
+* 'WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET' se il valore dell'opzione non è
+  stato resettato
+* 'WEECHAT_CONFIG_OPTION_UNSET_OK_RESET' se il valore dell'opzione è stato
+  resettato
+* 'WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED' se l'opzione è stata rimossa
+* 'WEECHAT_CONFIG_OPTION_UNSET_ERROR' se si è verificato un errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+switch (weechat_config_unset_plugin ("option"))
+{
+    case WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_OPTION_UNSET_OK_RESET:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED:
+        /* ... */
+        break;
+    case WEECHAT_CONFIG_OPTION_UNSET_ERROR:
+        /* ... */
+        break;
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.config_unset_plugin(option_name)
+
+# esempio
+rc = weechat.config_unset_plugin("option")
+if rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_RESET:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED:
+    # ...
+elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_ERROR:
+    # ...
+----------------------------------------
+
+[[display]]
+Display
+~~~~~~~
+
+Funzioni per visualizzare il testo nei buffer.
+
+weechat_prefix
+^^^^^^^^^^^^^^
+
+Restituisce un prefisso.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_prefix (const char *prefix);
+----------------------------------------
+
+Argomenti:
+
+* 'prefix': nome del prefisso:
+
+[width="70%",cols="^2,^1,^3,5",options="header"]
+|========================================
+| Prefisso    | Valore | Colore         | Descrizione
+| 'errore'     | `=!=`  | giallo           | messaggio di errore
+| 'network'  |   `--`    | magenta      | messaggio dalla rete
+| 'action'     |   `*`    | bianco          | azione automatica
+| 'join'         |  `-->`  | verde chiaro | qualcuno entra nella chat corrente
+| 'quit'        |   `<--` | rosso chiaro | qualcuno lascia la chat corrente
+|========================================
+
+[NOTE]
+Valori e colori possono essere personalizzati con il comando `/set`.
+
+Valore restituito:
+
+* valore del prefisso (stringa con prefisso e codici colori), stringa vuota
+  se il prefisso non è stato trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "%sThis is an error...", weechat_prefix ("error"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.prefix(prefix)
+
+# esempio
+weechat.prnt("", "%sThis is an error..." % weechat.prefix("error"))
+----------------------------------------
+
+weechat_color
+^^^^^^^^^^^^^
+
+Restituisce una codice colore stringa da visualizzare.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_color (const char *color_name);
+----------------------------------------
+
+Argomenti:
+
+* 'color_name': nome del colore, uno di:
+** nome opzione di WeeChat (da weechat.color.xxx), ad esempio 'chat_delimiters'
+** colore con sfondo opzionale, ad esempio 'yellow' o 'yellow,red'
+** attributo:
+*** 'bold': imposta grassetto
+*** '-bold': rimuove grassetto
+*** 'reverse': imposta inverso
+*** '-reverse': rimuove inverso
+*** 'italic': imposta corsivo
+*** '-italic': rimuove corsivo
+*** 'underline': imposta sottolineato
+*** '-underline': rimuove sottolineato
+** nome colore della barra:
+*** 'bar_fg': colore di primo piano della barra
+*** 'bar_delim': colore dei delimitatori della barra
+*** 'bar_bg': colore di sfondo della barra
+
+Valore restituito:
+
+* stringa con codice colore, o un codice "reset color" se il colore non è stato trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "Color: %sblue %sdefault color %syellow on red",
+                weechat_color ("blue"),
+                weechat_color ("chat"),
+                weechat_color ("yellow,red"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.color(color_name)
+
+# esempio
+weechat.prnt("", "%sColor: %sblue %sdefault color %syellow on red"
+    % (weechat.color("blue"), weechat.color("chat"), weechat.color("yellow,red")))
+----------------------------------------
+
+weechat_printf
+^^^^^^^^^^^^^^
+
+Visualizza un messaggio su un buffer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_printf (struct t_gui_buffer *buffer, const char *message, ...);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer, se NULL il messaggio viene visualizzato sul buffer di WeeChat
+* 'message': messaggio da visualizzare
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "Benvenuto sul buffer di WeeChat");
+weechat_printf (buffer, "Benvenuto su questo buffer");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.prnt(buffer, message)
+
+# esempio
+weechat.prnt("", "Benvenuto sul buffer di WeeChat")
+weechat.prnt(buffer, "Benvenuto su questo buffer")
+----------------------------------------
+
+[NOTE]
+La funzione è chiamata "print" negli script ("prnt" in Python).
+
+weechat_printf_date
+^^^^^^^^^^^^^^^^^^^
+
+Visualizza un messaggio sul buffer, utilizzando una data personalizzata.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_printf_date (struct t_gui_buffer *buffer, time_t date,
+                          const char *message, ...);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer, se NULL, il messaggio viene visualizzato
+  sul buffer di WeeChat
+* 'date': data per il messaggio
+* 'message': messaggio da visualizzare
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf_date (NULL, time (NULL) - 120, "Ciao, 2 minuti fa");
+----------------------------------------
+
+weechat_printf_tags
+^^^^^^^^^^^^^^^^^^^
+
+Visualizza un messaggio sul buffer, utilizzando tag personalizzati.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_printf_tags (struct t_gui_buffer *buffer, const char *tags,
+                          const char *message, ...);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer, se NULL il messaggio viene visualizzato
+  sul buffer di WeeChat
+* 'tags': lista di tag separati da virgole
+* 'message': messaggio da visualizzare
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf_tags (NULL, "notify_message",
+                     "Messaggio con tag 'notify_message'");
+----------------------------------------
+
+weechat_printf_date_tags
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Visualizza un messaggio sul buffer, usando tag e data personalizzati.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_printf_date_tags (struct t_gui_buffer *buffer, time_t date,
+                               const char *tags, const char *message, ...);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer, se NULL il messaggio viene visualizzato
+  sul buffer di WeeChat
+* 'date': data per il messaggio
+* 'tags': lista di tag separati da virgole
+* 'message': messaggio da visualizzare
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf_date_tags (NULL, time (NULL) - 120, "notify_message",
+                          "Messaggio 2 minuti fa, con tag 'notify_message'");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.prnt_date_tags(buffer, date, tags, message)
+
+# esempio
+time = int(time.time())
+weechat.prnt_date_tags("", time - 120, "notify_message",
+    "Messaggio 2 minuti fa, con tag 'notify_message'")
+----------------------------------------
+
+[NOTE]
+La funzione è chiamata "print_date_tags" negli script ("prnt_date_tags" in Python).
+
+weechat_printf_y
+^^^^^^^^^^^^^^^^
+
+Visualizza un messaggio sulla riga di un buffer con contenuto libero.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_printf_y (struct t_gui_buffer *buffer, int y,
+                       const char *message, ...);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'y': numero di riga (la prima riga è 0)
+* 'message': messaggio da visualizzare
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf_y (buffer, 2, "Mio messaggio sulla terza riga");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.prnt_y(buffer, y, message)
+
+# esempio
+weechat.prnt_y("", 2, "Mio messaggio sulla terza riga")
+----------------------------------------
+
+[NOTE]
+La funzione è chiamata "print_y" negli script ("prnt_y in Python).
+
+weechat_log_printf
+^^^^^^^^^^^^^^^^^^
+
+Scrive un messaggio nel file di log di WeeChat (weechat.log).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_log_printf (const char *message, ...);
+----------------------------------------
+
+Argomenti:
+
+* 'message': messaggio da scrivere
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_log_printf ("Mio messaggio nel file di log");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.log_print(message)
+
+# esempio
+weechat.log_print("Mio messaggio nel file di log")
+----------------------------------------
+
+[NOTE]
+La funzione è chiamata "log_print" negli script.
+
+[[hooks]]
+Hook
+~~~~
+
+weechat_hook_command
+^^^^^^^^^^^^^^^^^^^^
+
+Hook su un comando.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_command (const char *command,
+                                     const char *description,
+                                     const char *args,
+                                     const char *args_description,
+                                     const char *completion,
+                                     int (*callback)(void *data,
+                                                     struct t_gui_buffer *buffer,
+                                                     int argc,
+                                                     char **argv,
+                                                     char **argv_eol),
+                                     void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'command': nome del comando
+* 'description': descrizione per il comando (visualizzata con `/help comando`)
+* 'args': argomenti per il comando (visualizzati con `/help command`)
+* 'args_description': descrizione degli argomenti (visualizzata con `/help command`)
+* 'completion': modello di completamento per il comando:: elenco di completamenti
+  per ogni argomento, separati da spazio. Sono possibili più  completamenti sono
+  possibili per un singolo argomento, separati da "|". Più modelli sono possibili per
+  lo stesso comando, separati da "||".
+* 'callback': funzione chiamata quando viene utilizzato il comando, argomenti:
+** 'void *data': puntatore
+** 'struct t_gui_buffer *buffer': buffer quando il comando viene eseguito
+** 'int argc': numero di argomenti forniti per un comando
+** 'char **argv': argomenti forniti per un comando
+** 'char **argv_eol': argomenti forniti per un comando (fino a fine riga per ogni
+   argomento)
+* 'callback_data': puntatore fornito dalla callback quando chiamata da WeeChat
+
+I codici predefiniti per il completamento sono:
+include::autogen/plugin_api/completions.txt[]
+
+Codici speciali:
+
+* '%%command': riutilizza il modello di completamento dal comando 'command'
+* '%-': ferma completamento
+* '%*': ripete l'ultimo completamento
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_command_cb (void *data, struct t_gui_buffer *buffer, int argc,
+               char **argv, char **argv_eol)
+{
+    /* ... */
+    return WEECHAT_RC_OK;
+}
+
+/* questo esempio si ispira al comando /filter */
+struct t_hook *my_command_hook =
+    weechat_hook_command (/* nome comando */
+                          "myfilter",
+                          /* description */
+                          "description of myfilter",
+                          /* args */
+                          "[list] | [enable|disable|toggle [name]] | "
+                          "[add name plugin.buffer tags regex] | "
+                          "[del name|-all]",
+                          /* args description */
+                          "description of arguments...",
+                          /* completion */
+                          "list"
+                          " || enable %(filters_names)"
+                          " || disable %(filters_names)"
+                          " || toggle %(filters_names)"
+                          " || add %(filters_names) %(buffers_plugins_names)|*"
+                          " || del %(filters_names)|-all",
+                          /* callback */
+                          &my_command_cb,
+                          /* callback_data */
+                          NULL);
+----------------------------------------
+
+Ad esempio, se il comando chiamato è `/comando abc def ghi`, allora
+argv e argv_eol contengono i seguenti valori:
+
+* 'argv':
+** 'argv[0]' == "abc"
+** 'argv[1]' == "def"
+** 'argv[2]' == "ghi"
+* 'argv_eol':
+** 'argv_eol[0]' == "abc def ghi"
+** 'argv_eol[1]' == "def ghi"
+** 'argv_eol[2]' == "ghi"
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_command(command, description, args, args_description,
+    completion, callback, callback_data)
+
+# esempio
+def my_command_cb(data, buffer, args):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+hook = weechat.hook_command("myfilter", "descrizione di myfilter",
+    "[list] | [enable|disable|toggle [name]] | "
+    "[add name plugin.buffer tags regex] | "
+    "[del name|-all]",
+    "description of arguments...",
+    "list"
+    " || enable %(filters_names)"
+    " || disable %(filters_names)"
+    " || toggle %(filters_names)"
+    " || add %(filters_names) %(buffers_plugins_names)|*"
+    " || del %(filters_names)|-all",
+    "my_command_cb", "")
+----------------------------------------
+
+weechat_hook_command_run
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Hook su un comando quando eseguito da WeeChat.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_command_run (const char *command,
+                                         int (*callback)(void *data,
+                                                         struct t_gui_buffer *buffer,
+                                                         const char *command),
+                                         void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'command': comando su cui eseguire l'hook, può iniziare o terminare con "*"
+* 'callback': funzione chiamata quando il comando è in esecuzione, argomenti:
+** 'void *data': puntatore
+** 'struct t_gui_buffer *buffer': buffer dove viene eseguito il comando
+** 'const char *command': il comando eseguito, con i propri argomenti
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+
+[NOTE]
+La callback può restituire 'WEECHAT_RC_OK' o 'WEECHAT_RC_OK_EAT' (il comando
+non verrà eseguito da WeeChat dopo la callback).
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_command_run_cb (void *data, struct t_gui_buffer *buffer,
+                   const char *command)
+{
+    weechat_printf (NULL,
+		    "Vuoi completare? Sto mangiando il completamento, ahah!);
+    return WEECHAT_RC_OK_EAT;
+}
+
+struct t_hook *my_command_run_hook =
+    weechat_hook_command_run ("/input complete*",
+                              &my_command_run_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_command_run(command, callback, callback_data)
+
+# esempio
+def my_command_run_cb(data, buffer, command):
+    weechat.prnt("". "Vuoi completare? Sto mangiando il completamento, ahah!")
+    return weechat.WEECHAT_RC_OK_EAT
+
+hook = weechat.hook_command_run("/input complete*", "my_command_run_cb", "")
+----------------------------------------
+
+weechat_hook_timer
+^^^^^^^^^^^^^^^^^^
+
+Hook sul timer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_timer (long interval,
+                                   const char *align_second,
+                                   const char *max_calls,
+                                   int (*callback)(void *data,
+                                                   int remaining_calls),
+                                   void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'interval': intervallo tra due chiamate (millisecondi, 1000 = 1 secondo)
+* 'align_second': allineamento su un secondo. Per esempio, rrent time is 09:00,
+  if interval = 60000 (60 seconds), and align_second = 60, then timer is
+  called each minute when second is 00
+* 'max_calls': number of calls to timer (if 0, then timer has no end)
+* 'callback': function called when time is reached, arguments:
+** 'void *data': pointer
+** 'int remaining_calls': remaining calls (-1 if timer has no end)
+* 'callback_data': pointer given to callback when it is called by WeeChat
+
+Valore restituito:
+
+* pointer to new hook, NULL if error occured
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_timer_cb (void *data, int remaining_calls)
+{
+    /* ... */
+    return WEECHAT_RC_OK;
+}
+
+/* timer chiamato ogni 20 secondi */
+struct t_hook *my_timer_hook =
+    weechat_hook_timer (20 * 1000, 0, 0, &my_timer_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_timer(interval, align_second, max_calls, callback, callback_data)
+
+# esempio
+def my_timer_cb(data, remaining_calls):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+# timer called each 20 seconds
+hook = weechat.hook_timer(20 * 1000, 0, 0, "my_timer_cb", "")
+----------------------------------------
+
+weechat_hook_fd
+^^^^^^^^^^^^^^^
+
+Hook su un descrittore file (file oppure socket).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_fd (int fd,
+                                int flag_read,
+                                int flag_write,
+                                int flag_exception,
+                                int (*callback)(void *data,
+                                                int fd),
+                                void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'fd': descrittore file
+* 'flag_read': 1 = cattura l'evento lettura (read), 0 = ignora
+* 'flag_write': 1 = cattura l'evento scrittura (write), 0 = ignora
+* 'flag_exception': 1 = cattura l'eccezione evento (event), 0 = ignora
+* 'callback': funzione che chiama un evento selezionato che si verifica
+  per un file (o un socket), argomenti:
+** 'void *data': puntatore
+** 'int fd': descrittore file
+* 'callback_data': puntatore fornito alla calback quando chiamata da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_fd_cb (void *data, int fd)
+{
+    /* ... */
+    return WEECHAT_RC_OK;
+}
+
+int sock = socket (AF_INET, SOCK_STREAM, 0);
+/* set socket options */
+/* ... */
+struct t_hook *my_fd_hook = weechat_hook_fd (sock, 1, 0, 0, &my_fd_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_fd(fd, flag_read, flag_write, flag_exception, callback, callback_data)
+
+# esempio
+def my_fd_cb(data, fd):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+sock = ...
+hook = weechat.hook_fd(sock, 1, 0, 0, "my_fd_cb", "")
+----------------------------------------
+
+weechat_hook_process
+^^^^^^^^^^^^^^^^^^^^
+
+Hook su un processo (lanciato con un fork), e cattura l'output.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_process (const char *command,
+                                     int timeout,
+                                     int (*callback)(void *data,
+                                                     const char *command,
+                                                     int return_code,
+                                                     const char *out,
+                                                     const char *err),
+                                     void *callback_data);
+----------------------------------------
+
+
+Argomenti:
+
+* 'command': comando da avviare nel processo figlio
+* 'timeout': timeout per il comando (in millisecondi): dopo questo timeout,
+  il processo figlio viene terminato (0 vuol dire nessun timeout)
+* 'callback': funzione chiamata quando i dati dal processo figlio sono disponibili,
+  oppure quando è terminato, argomenti:
+** 'void *data': puntatore
+** 'const char *command': comando eseguito dal processo figlio
+** 'int return_code': codice restituito:
+*** '>= 0': codice restituito dal comando figlio
+*** '< 0': 'WEECHAT_HOOK_PROCESS_OK_RUNNING' (dati disponibili, ma figlio
+    ancora in esecuzione) o 'WEECHAT_HOOK_PROCESS_ERROR' (errore nella
+    esecuzione del comando)
+** 'out': output standard del comando (stdout)
+** 'err': output di errore del comando (stderr)
+* 'callback_data': puntatore fornito alla callback quando fornita da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_process_cb (void *data, const char *command, int return_code,
+               const char *out, const char *err)
+{
+    if (return_code == WEECHAT_HOOK_PROCESS_ERROR)
+    {
+        weechat_printf (NULL, "Error with command '%s'", command);
+        return WEECHAT_RC_OK;
+    }
+    
+    if (return_code >= 0)
+    {
+        weechat_printf (NULL, "return_code = %d", return_code);
+    }
+    
+    if (out)
+    {
+        weechat_printf (NULL, "stdout: %s", out);
+    }
+    
+    if (err)
+    {
+        weechat_printf (NULL, "stderr: %s", err);
+    }
+    
+    return WEECHAT_RC_OK;
+}
+
+struct t_hook *my_process_hook = weechat_hook_process ("ls", 5000,
+                                                       &my_process_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_process(command, timeout, callback, callback_data)
+
+# esempio
+def my_process_cb(data, command, return_code, out, err):
+    if return_code == weechat.WEECHAT_HOOK_PROCESS_ERROR:
+        weechat.prnt("", "Error with command '%s'" % command)
+        return weechat.WEECHAT_RC_OK
+    if return_code >= 0:
+        weechat.prnt("", "return_code = %d" % return_code)
+    if out != "":
+        weechat.prnt("", "stdout: %s" % out)
+    if err != "":
+        weechat.prnt("", "stderr: %s" % err)
+    return weechat.WEECHAT_RC_OK
+
+hook = weechat.hook_process("ls", 5000, "my_process_cb", "")
+----------------------------------------
+
+weechat_hook_connect
+^^^^^^^^^^^^^^^^^^^^
+
+Hook su una connessione (connessione in secondo piano ad un host remoto).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_connect (const char *address,
+                                     int port,
+                                     int sock,
+                                     int ipv6,
+                                     void *gnutls_sess,
+                                     const char *local_hostname,
+                                     int (*callback)(void *data,
+                                                     int status,
+                                                     const char *ip_address),
+                                     void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'address': nome o indirizzo IP al quale connettersi
+* 'port': numero della porta
+* 'sock': socket utilizzato per la connessione
+* 'ipv6': 1 per usare IPv6, 0 per usare IPv4
+* 'gnutls_sess': sessione GnuTLS (opzionale)
+* 'callback': funzione chiamata quando la connessione è avvenuta con
+  successo oppure no, argomenti:
+** 'void *data': puntatore
+** 'int status': stato della connessione:
+*** 'WEECHAT_HOOK_CONNECT_OK': connessione avvenuta con successo
+*** 'WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND': indirizzo non trovato
+*** 'WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND': indirizzo IP non trovato
+*** 'WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED': connessione rifiutata
+*** 'WEECHAT_HOOK_CONNECT_PROXY_ERROR': errore con il proxy
+*** 'WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR': errore con il nome host locale
+*** 'WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR': errore inizializzazione GnuTLS 
+*** 'WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR': errore di handshake GnuTLS
+*** 'WEECHAT_HOOK_CONNECT_MEMORY_ERROR': memoria insufficiente
+** 'const char *ip_address': indirizzo IP trovato
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_connect_cb (void *data, int status, const char *ip_address)
+{
+    switch (status)
+    {
+        case WEECHAT_HOOK_CONNECT_OK:
+            /* ... */
+            break;
+        case WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND:
+            /* ... */
+            break;
+        case WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND:
+            /* ... */
+            break;
+        case WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED:
+            /* ... */
+            break;
+        case WEECHAT_HOOK_CONNECT_PROXY_ERROR:
+            /* ... */
+            break;
+        case WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR:
+            /* ... */
+            break;
+        case WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR:
+            /* ... */
+            break;
+        case WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR:
+            /* ... */
+            break;
+        case WEECHAT_HOOK_CONNECT_MEMORY_ERROR:
+            /* ... */
+            break;
+    }
+    return WEECHAT_RC_OK;
+}
+
+struct t_hook *my_connect_hook = weechat_hook_connect ("my.server.org", 1234,
+                                                       sock, 0, NULL, NULL,
+                                                       &my_connect_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_connect(address, port, sock, ipv6, local_hostname,
+    callback, callback_data)
+
+# esempio
+def my_connect_cb(data, status, ip_address):
+    if status == WEECHAT_HOOK_CONNECT_OK:
+        # ...
+    elif status == WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND:
+        # ...
+    elif status == WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND:
+        # ...
+    elif status == WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED:
+        # ...
+    elif status == WEECHAT_HOOK_CONNECT_PROXY_ERROR:
+        # ...
+    elif status == WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR:
+        # ...
+    elif status == WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR:
+        # ...
+    elif status == WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR:
+        # ...
+    elif status == WEECHAT_HOOK_CONNECT_MEMORY_ERROR:
+        # ...
+    return weechat.WEECHAT_RC_OK
+
+hook = weechat.hook_connect("my.server.org", 1234, sock, 0, "", "my_connect_cb", "")
+----------------------------------------
+
+weechat_hook_print
+^^^^^^^^^^^^^^^^^^
+
+Hook su un messaggio stampato.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_print (struct t_gui_buffer *buffer,
+                                   const char *tags,
+                                   const char *message,
+                                   int strip_colors,
+                                   int (*callback)(void *data,
+                                                   struct t_gui_buffer *buffer,
+                                                   time_t date,
+                                                   int tags_count,
+                                                   const char **tags,
+                                                   int displayed,
+                                                   int highlight,
+                                                   const char *prefix,
+                                                   const char *message),
+                                   void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer, se NULL, verranno catturati i messaggi da qualsiasi
+  buffer
+* 'tags': verranno catturati solo messaggi con queste tag (elenco separato da virgole)
+  (opzionale)
+* 'message': verranno catturati solo i messaggi con questa stringa (opzionale)
+* 'strip_colors': se 1, i colori verranno estratti dal messaggio visualizzato, prima
+  di chiamare la callback
+* 'callback': funzione chiamata quando viene stampato un messaggio, argomenti:
+** 'void *data': puntatore
+** 'struct t_gui_buffer *buffer': puntatore al buffer
+** 'time_t date': data
+** 'int tags_count': numero di tag per riga
+** 'const char **tags': array con tag per riga
+** 'int displayed': 1 se la riga è visualizzata, 0 se filtrata (nascosta)
+** 'int highlight': 1 se la riga viene evidenziata, altrimenti 0
+** 'const char *prefix': prefisso
+** 'const char *message': messaggio
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_print_cb (void *data, struct t_gui_buffer *buffer, time_t date,
+             int tags_count, const char **tags,
+             int displayed, int highlight,
+             const char *prefix, const char *message)
+{
+    /* ... */
+    return WEECHAT_RC_OK;
+}
+
+/* cattura tutti i messaggi, su tutti i buffer, senza colore */
+struct t_hook *my_print_hook =
+    weechat_hook_print (NULL, NULL, NULL, 1, &my_print_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_print(buffer, tags, message, strip_colors, callback, callback_data)
+
+# esempio
+def my_print_cb(data, buffer, date, tags, displayed, highlight, prefix, message):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+# catch all messages, on all buffers, without color
+hook = weechat.hook_print("", "", "", 1, "my_print_cb", "")
+----------------------------------------
+
+weechat_hook_signal
+^^^^^^^^^^^^^^^^^^^
+
+Hook su un segnale.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_signal (const char *signal,
+                                    int (*callback)(void *data,
+                                                    const char *signal,
+                                                    const char *type_data,
+                                                    void *signal_data),
+                                    void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'signal': segnale da catturare, può iniziare o terminare con "*":
+
+[width="80%",cols="^1,^3,^3,5",options="header"]
+|========================================
+| Plugin | Segnale | Argomenti | Descrizione
+
+| irc | xxx,irc_in_yyy ^1^ | string: message |
+  irc message from server (before irc plugin uses it)
+
+| irc | xxx,irc_in2_yyy ^1^ | string: message |
+  irc message from server (after irc plugin uses it)
+
+| irc | xxx,irc_out_yyy ^1^ | string: message |
+  irc message sent to server
+
+| irc | irc_ctcp | string: message |
+  CTCP received
+
+| irc | irc_dcc | string: message |
+  new DCC
+
+| irc | irc_pv | string: message |
+  private message received
+
+| irc | irc_channel_opened | pointer: buffer |
+  channel opened
+
+| irc | irc_pv_opened | pointer: buffer |
+  private opened
+
+| irc | irc_server_connecting | string: server name |
+  connecting to server
+
+| irc | irc_server_connected | string: server name |
+  connected to server
+
+| irc | irc_server_disconnected | string: server name |
+  disconnected from server
+
+| irc | irc_ignore_removing | pointer: ignore |
+  removing ignore
+
+| irc | irc_ignore_removed | - |
+  ignore removed
+
+| logger | logger_start | pointer: buffer |
+  start logging for buffer
+
+| logger | logger_stop | pointer: buffer |
+  stop logging for buffer
+
+| logger | logger_backlog | pointer: buffer |
+  display backlog for buffer
+
+| weechat | buffer_closing | pointer: buffer |
+  closing buffer
+
+| weechat | buffer_closed | pointer: buffer |
+  buffer closed
+
+| weechat | buffer_lines_hidden | pointer: buffer |
+  lines hidden in buffer
+
+| weechat | buffer_localvar_added | pointer: buffer |
+  local variable has been added
+
+| weechat | buffer_localvar_changed | pointer: buffer |
+  local variable has changed
+
+| weechat | buffer_localvar_removed | pointer: buffer |
+  local variable has been removed
+
+| weechat | buffer_moved | pointer: buffer |
+  buffer moved
+
+| weechat | buffer_opened | pointer: buffer |
+  buffer opened
+
+| weechat | buffer_renamed | pointer: buffer |
+  buffer renamed
+
+| weechat | buffer_switch | pointer: buffer |
+  switching buffer
+
+| weechat | buffer_title_changed | pointer: buffer |
+  title of buffer changed
+
+| weechat | buffer_type_changed | pointer: buffer |
+  type of buffer changed
+
+| weechat | debug_dump | - |
+  dump request
+
+| weechat | filter_added | pointer: filter |
+  filter added
+
+| weechat | filter_removing | pointer: filter |
+  removing filter
+
+| weechat | filter_removed | - |
+  filter added
+
+| weechat | filter_enabled | - |
+  filters enabled
+
+| weechat | filter_disabled | - |
+  filters disabled
+
+| weechat | hotlist_changed | - |
+  hotlist changed
+
+| weechat | input_paste_pending | - |
+  paste pending
+
+| weechat | input_search | - |
+  text search in buffer
+
+| weechat | input_text_changed | - |
+  input text changed
+
+| weechat | input_text_cursor_moved | - |
+  input text cursor moved
+
+| weechat | key_pressed | string: key pressed |
+  key pressed
+
+| weechat | nicklist_changed | - |
+  nicklist has changed
+
+| weechat | partial_completion | - |
+  partial completion happened
+
+| weechat | quit | string: arguments for /quit |
+  command `/quit` issued by user
+
+| weechat | upgrade | - |
+  command `/upgrade` issued by user
+
+| weechat | weechat_highlight | string: message with prefix |
+  highlight happened
+
+| weechat | weechat_pv | string: message with prefix |
+  private message displayed
+
+| weechat | window_scrolled | pointer: window |
+  scroll in window
+
+| weechat | window_unzooming | pointer: current window |
+  unzooming window
+
+| weechat | window_unzoomed | pointer: current window |
+  window unzoomed
+
+| weechat | window_zooming | pointer: current window |
+  zomming window
+
+| weechat | window_zoomed | pointer: current window |
+  window zoomed
+
+| xfer | xfer_add | pointer: infolist with xfer info |
+  new xfer
+
+| xfer | xfer_send_ready | pointer: infolist with xfer info |
+  xfer ready
+
+| xfer | xfer_accept_resume | pointer: infolist with xfer info |
+  xfer accepts resume (send)
+
+| xfer | xfer_send_accept_resume | pointer: infolist with xfer info |
+  xfer accepts resume (send)
+
+| xfer | xfer_start_resume | pointer: infolist with xfer info |
+  start resume
+
+| xfer | xfer_resume_ready | pointer: infolist with xfer info |
+  xfer resume ready
+|========================================
+
+[NOTE]
+^1^ 'xxx' è il nome del server IRC, 'yyy' è il nome del comando IRC.
+
+* 'callback': funzione chiamata a segnale ricevuto, argomenti:
+** 'void *data': puntatore
+** 'const char *signal': segnale ricevuto
+** 'const char *type_data': tipo di dati inviati con il segnale:
+*** 'WEECHAT_HOOK_SIGNAL_STRING': stringa
+*** 'WEECHAT_HOOK_SIGNAL_INT': numero intero
+*** 'WEECHAT_HOOK_SIGNAL_POINTER': puntatore
+** 'void *signal_data': dati inviati con il segnale
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_signal_cb (void *data, const char *signal, const char *type_data,
+              void *signal_data)
+{
+    /* ... */
+    return WEECHAT_RC_OK;
+}
+
+/* catch signal "quit" */
+struct t_hook *my_signal_hook = weechat_hook_signal ("quit",
+                                                     &my_signal_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_signal(signal, callback, callback_data)
+
+# esempio
+def my_signal_cb(data, signal, type_data, signal_data):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+# catch signal "quit"
+hook = weechat.hook_signal("quit", "my_signal_cb", "")
+----------------------------------------
+
+weechat_hook_signal_send
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Invia un segnale.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_hook_signal_send (const char *signal, const char *type_data,
+                               void *signal_data);
+----------------------------------------
+
+Argomenti:
+
+* 'signal': segnale da inviare
+* 'type_data': tipo di dati inviati con il segnale (consultare
+  <<_weechat_hook_signal>>)
+* 'signal_data': dati inviati con il segnale
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_hook_signal_send ("my_signal", WEECHAT_HOOK_SIGNAL_STRING, my_string);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.hook_signal_send(signal, type_data, signal_data)
+
+# esempio
+weechat.hook_signal_send("my_signal", weechat.WEECHAT_HOOK_SIGNAL_STRING, my_string)
+----------------------------------------
+
+weechat_hook_config
+^^^^^^^^^^^^^^^^^^^
+
+Hook su un'opzione di configurazione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_config (const char *option,
+                                    int (*callback)(void *data,
+                                                    const char *option,
+                                                    const char *value),
+                                    void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'option': opzione, il formato è il nome completo, come usato con il comando
+  `/set` (ad esempio: `weechat.look.item_time_format`)
+* 'callback': function called when configuration option is changed, arguments:
+** 'void *data': pointer
+** 'const char *option': name of option
+** 'const char *value': new value for option
+* 'callback_data': pointer given to callback when it is called by WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_config_cb (void *data, const char *option, const char *value)
+{
+    /* ... */
+    return WEECHAT_RC_OK;
+}
+
+/* cattura le modifiche dell'opzione "weechat.look.item_time_format" */
+struct t_hook *my_config_hook = weechat_hook_config ("weechat.look.item_time_format",
+                                                     &my_config_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_config(option, callback, callback_data)
+
+# esempio
+def my_config_cb(data, option, value):
+    # ...
+    return weechat.WEECHAT_RC_OK
+
+# cattura le modifiche dell'opzione "weechat.look.item_time_format"
+hook = weechat.hook_config("weechat.look.item_time_format", "my_config_cb", "")
+----------------------------------------
+
+weechat_hook_completion
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Hook su un completamento.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_completion (const char *completion_item,
+                                        int (*callback)(void *data,
+                                                        const char *completion_item,
+                                                        struct t_gui_buffer *buffer,
+                                                        struct t_gui_completion *completion),
+                                        void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'completion_item': nome dell'elemento del completamento, è possibile usare
+  in seguito '%(name)' in un comando con un hook (argomento 'completion')
+* 'callback': funzione chiamata quando viene usato l'elemento completamento
+  (l'utente sta completando qualcosa usando questo elemento), argomenti:
+** 'void *data': puntatore
+** 'const char *completion_item': nome dell'elemento del completamento
+** 'struct t_gui_buffer *buffer': buffer dove viene eseguito il completamento
+** 'struct t_gui_completion *completion': struttura usata per aggiungere
+   parole per il completamento (consultare
+   <<_weechat_hook_completion_list_add>>)
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+
+[NOTE]
+I nomi del completamento sono globali (condivisi tra WeeChat e plugin). Si
+raccomanda pertanto di scegliere un nome con un prefisso unico, come
+"plugin_xxx" (dove "xxx" è il nome del proprio elemento).
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_completion_cb (void *data, const char *completion_item,
+                  struct t_gui_buffer *buffer,
+                  struct t_gui_completion *completion)
+{
+    weechat_hook_completion_list_add (completion, "word1",
+                                      0, WEECHAT_LIST_POS_SORT);
+    weechat_hook_completion_list_add (completion, "test_word2",
+                                      0, WEECHAT_LIST_POS_SORT);
+    return WEECHAT_RC_OK;
+}
+
+struct t_hook *my_completion_hook = weechat_hook_completion ("plugin_item",
+                                                             &my_completion_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_completion(completion_item, callback, callback_data)
+
+# esempio
+def my_completion_cb(data, completion_item, buffer, completion):
+    weechat.hook_completion_list_add(completion, "word1", 0, weechat.WEECHAT_LIST_POS_SORT)
+    weechat.hook_completion_list_add(completion, "test_word2", 0, weechat.WEECHAT_LIST_POS_SORT)
+    return weechat.WEECHAT_RC_OK
+
+hook = weechat.hook_completion("plugin_item", "my_completion_cb", "")
+----------------------------------------
+
+weechat_hook_completion_list_add
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiunge una parola per il completamento.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_hook_completion_list_add (struct t_gui_completion *completion,
+                                       const char *word,
+                                       int nick_completion,
+                                       const char *where);
+----------------------------------------
+
+Argomenti:
+
+* 'completion': puntatore al completamento
+* 'word': parola da aggiungere
+* 'nick_completion': 1 se la parola è un nick, altrimenti 0
+* 'where': posizione in cui la parola sarà inserita nella lista:
+** 'WEECHAT_LIST_POS_SORT': qualunque posizione, per mantenere
+   la lista ordinata
+** 'WEECHAT_LIST_POS_BEGINNING': inizio della lista
+** 'WEECHAT_LIST_POS_END': fine della lista
+
+Esempio in C: consultare <<_weechat_hook_completion>>.
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.hook_completion_list_add(completion, word, nick_completion, where)
+
+# esempio: see function hook_completion above
+----------------------------------------
+
+weechat_hook_modifier
+^^^^^^^^^^^^^^^^^^^^^
+
+Hook su un modificatore.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_modifier (const char *modifier,
+                                      char *(*callback)(void *data,
+                                                        const char *modifier,
+                                                        const char *modifier_data,
+                                                        const char *string),
+                                      void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'modifier': nome modificatore, lista di modificatori utilizzati da
+  Weechat o dai plugin:
+
+[width="100%",cols="^1,^2,3,4,4",options="header"]
+|========================================
+| Plugin | Modificatore | Dati modificatore | Stringa | Output
+
+| charset | charset_decode |
+  plugin.buffer_name |
+  qualsiasi stringa |
+  stringa codificata dal set caratteri trovato per plugin/buffer in UTF-8
+
+| charset | charset_encode |
+  plugin.buffer_name |
+  any string |
+  string encoded from UTF-8 to charset found for plugin/buffer
+
+| irc | irc_color_decode |
+  "1" to keep colors, "0" to remove colors |
+  any string |
+  string with WeeChat color codes, or without color
+
+| irc | irc_color_encode |
+  "1" to keep colors, "0" to remove colors |
+  any string |
+  string with IRC color codes, or without color
+
+| irc | irc_in_xxx ^1^ |
+  server name |
+  content of message received from IRC server |
+  new content of message
+
+| irc | irc_out_xxx ^1^ |
+  server name |
+  content of message about to be sent to IRC server |
+  new content of message
+
+| weechat | bar_condition_yyy ^2^ |
+  string with window pointer ("0x123..") |
+  empty string |
+  "1" to display bar, "0" to hide it
+
+| weechat | input_text_content |
+  string with buffer pointer ("0x123..") |
+  input buffer (from user) |
+  new content of input buffer
+
+| weechat | input_text_display |
+  string with buffer pointer ("0x123..") |
+  input buffer (from user), without cursor tag |
+  new content of input buffer, for display only (input buffer is not changed)
+
+| weechat | input_text_display_with_cursor |
+  string with buffer pointer ("0x123..") |
+  input buffer (from user), with cursor tag |
+  new content of input buffer, for display only (input buffer is not changed)
+
+| weechat | weechat_print |
+  plugin;buffer_name;tags |
+  message printed |
+  new message printed
+|========================================
+
+[NOTE]
+^1^ 'xxx' è il nome del comando IRC. +
+^2^ 'yyy' è il nome della barra.
+
+* 'callback': funzione chiamata quando viene usato il modificatore,
+  argomenti:
+** 'void *data': puntatore
+** 'const char *modifier': nome del modificatore
+** 'const char *modifier_data': dati per il modificatore
+** 'const char *string': stringa da modificare (la funzione deve restituire
+   una copia di questa stringa, non è consentito alcun cambiamento in
+    questa stringa)
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *
+my_modifier_cb (void *data, const char *modifier,
+                const char *modifier_data,
+                const char *string)
+{
+    char *result;
+    int length;
+    
+    if (!string)
+        return NULL;
+    
+    length = strlen (string) + 5;
+    result = malloc (length);
+    if (result)
+    {
+        /* aggiunge "xxx" ad ogni messaggio stampato */
+        snprintf (result, length, "%s xxx", string);
+    }
+    
+    return result;
+}
+
+struct t_hook *my_modifier_hook = weechat_hook_modifier ("weechat_print",
+                                                         &my_modifier_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_modifier(modifier, callback, callback_data)
+
+# esempio
+def my_modifier_cb(data, modifier, modifier_data, string):
+    return "%s xxx" % string
+
+hook = weechat.hook_modifier("weechat_print", "my_modifier_cb", "")
+----------------------------------------
+
+weechat_hook_modifier_exec
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Esegue modificatore(i).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_hook_modifier_exec (const char *modifier,
+                                  const char *modifier_data,
+                                  const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'modifier': nome modificatore
+* 'modifier_data': dati modificatore
+* 'string': stringa da modificare
+
+Valore restituito:
+
+* stringa modificata, NULL se nessun cambiamento nella stringa è
+  stato effettuato dal modificatore(i).
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *new_string = weechat_hook_modifier_exec ("my_modifier",
+                                               my_data, my_string);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.hook_modifier_exec(modifier, modifier_data, string)
+
+# esempio
+weechat.hook_modifier_exec("my_modifier", my_data, my_string)
+----------------------------------------
+
+weechat_hook_info
+^^^^^^^^^^^^^^^^^
+
+Hook su una informazione.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_info (const char *info_name,
+                                  const char *description,
+                                  const char *(*callback)(void *data,
+                                                          const char *info_name,
+                                                          const char *arguments),
+                                  void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'info_name': nome della info
+* 'description': descrizione
+* 'callback': funzione chiamata alla richiesta di una info, argomenti:
+** 'void *data': puntatore
+** 'const char *info_name': nome della info
+** 'const char *arguments': argomenti addizionali, dipendono dalle info
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+const char *
+my_info_cb (void *data, const char *info_name, const char *arguments)
+{
+    /* ... */
+    return pointer_to_string;
+}
+
+/* add info "my_info" */
+struct t_hook *my_info_hook = weechat_hook_info ("my_info",
+                                            "Some info",
+                                            &my_info_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_info(info_name, description, callback, callback_data)
+
+# esempio
+def my_info_cb(data, info_name, arguments):
+    return "some_info"
+
+hook = weechat.hook_info("my_info", "Some info", "my_info_cb", "")
+----------------------------------------
+
+weechat_hook_infolist
+^^^^^^^^^^^^^^^^^^^^^
+
+Hook su una lista info: la callback restituisce il puntatore alla lista info
+richiesta.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_hook *weechat_hook_infolist (const char *infolist_name,
+                                      const char *description,
+                                      const char *(*callback)(void *data,
+                                                              const char *infolist_name,
+                                                              void *pointer,
+                                      const char *arguments),
+                                      void *callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist_name': nome della lista info
+* 'description': descrizione
+* 'callback': funzione chiamata alla richiesta della lista info, argomenti:
+** 'void *data': puntatore
+** 'const char *infolist_name': nome della lista info
+** 'void *pointer': puntatore ad un oggetto che la lista info deve restituire
+   (per ricevere un solo elemento della lista info)
+** 'const char *arguments': argomento aggiuntivo, dipende dalla lista info
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo hook, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_infolist *
+my_infolist_cb (void *data, const char *infolist_name, void *pointer,
+                const char *arguments)
+{
+    struct t_infolist *my_infolist;
+    
+    /* build infolist */
+    /* ... */
+    
+    return my_infolist;
+}
+
+/* add infolist "my_infolist" */
+struct t_hook *my_infolist = weechat_hook_infolist ("my_infolist",
+                                                    "Infolist with some data",
+                                                    &my_infolist_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+hook = weechat.hook_infolist(infolist_name, description, callback, callback_data)
+
+# esempio
+def my_infolist_cb(data, infolist_name, pointer, arguments):
+    # build infolist
+    # ...
+    return my_infolist
+
+hook = weechat.hook_infolist("my_infolist", "Infolist with some data", "my_infolist_cb", "")
+----------------------------------------
+
+weechat_unhook
+^^^^^^^^^^^^^^
+
+Rimuove l'hook.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_unhook (struct t_hook *hook);
+----------------------------------------
+
+Argomenti:
+
+* 'hook': qualcosa su cui è presente un hook con "weechat_hook_xxx()"
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_hook *my_hook = weechat_hook_command ( /* ... */ );
+/* ... */
+weechat_unhook (my_hook);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.unhook(hook)
+
+# esempio
+weechat.unhook(my_hook)
+----------------------------------------
+
+weechat_unhook_all
+^^^^^^^^^^^^^^^^^^
+
+Rimuove l'hook in qualsiasi punto in cui è stato attivato dal
+plugin corrente.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_unhook_all ();
+----------------------------------------
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_unhook_all ();
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.unhook_all()
+
+# esempio
+weechat.unhook_all()
+----------------------------------------
+
+[[buffers]]
+Buffers
+~~~~~~~
+
+Funzioni per creare/richiedere/chiudere buffer.
+
+weechat_buffer_new
+^^^^^^^^^^^^^^^^^^
+
+Apre un nuovo buffer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_buffer *weechat_buffer_new (const char *name,
+                                         int (*input_callback)(void *data,
+                                                               struct t_gui_buffer *buffer,
+                                                               const char *input_data),
+                                         void *input_callback_data,
+                                         int (*close_callback)(void *data,
+                                                               struct t_gui_buffer *buffer),
+                                         void *close_callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'name': nome del buffer (deve essere unico per il plugin)
+* 'input_callback': funzione chiamata quando il testo in input è stato
+  inserito nel buffer, argomenti:
+*** 'void *data': puntatore
+*** 'struct t_gui_buffer *buffer': puntatore al buffer
+*** 'const char *input_data': dati in input
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+* 'close_callback': funzione chiamata alla chiusura del buffer, argomenti:
+*** 'void *data': puntatore
+*** 'struct t_gui_buffer *buffer': puntatore al buffer
+* 'callback_data': puntatore fornito alla callback quando chiamata da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo buffer, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_input_cb (void *data, struct t_gui_buffer *buffer, const char *input_data)
+{
+    weechat_printf (buffer, "Text: %s", input_data);
+    return WEECHAT_RC_OK;
+}
+
+int
+my_close_cb (void *data, struct t_gui_buffer *buffer)
+{
+    weechat_printf (NULL, "Buffer '%s' will be closed!",
+                    weechat_buffer_get_string (buffer, "name"));
+    return WEECHAT_RC_OK;
+}
+
+struct t_gui_buffer *my_buffer = weechat_buffer_new ("my_buffer",
+                                                     &my_input_cb, NULL,
+                                                     &my_close_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+buffer = weechat.buffer_new(name, input_callback, input_callback_data,
+    close_callback, close_callback_data)
+
+# esempio
+def my_input_cb(data, buffer, input_data):
+    weechat.prnt(buffer, "Text: %s" % input_data)
+    return weechat.WEECHAT_RC_OK
+
+def my_close_cb(data, buffer):
+    weechat.prnt("", "Buffer '%s' will be closed!" % weechat.buffer_get_strinf(buffer, "name"))
+    return weechat.WEECHAT_RC_OK
+
+buffer = weechat.buffer_new("my_buffer", "my_input_cb", "", "my_close_cb", "")
+----------------------------------------
+
+weechat_current_buffer
+^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il puntatore al buffer corrente (buffer visualizzato nella
+finestra corrente).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_buffer *weechat_current_buffer ();
+----------------------------------------
+
+Valore restituito:
+
+* puntatore al buffer corrente
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (weechat_current_buffer (), "Testo sul buffer corrente");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+buffer = weechat.current_buffer()
+
+# esempio
+weechat.prnt(weechat.current_buffer(), "Testo sul buffer corrente")
+----------------------------------------
+
+weechat_buffer_search
+^^^^^^^^^^^^^^^^^^^^^
+
+Cerca un buffer tramite plugin e/o nome.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_buffer *weechat_buffer_search (const char *plugin,
+                                            const char *name);
+----------------------------------------
+
+Argomenti:
+
+* 'plugin': nome del plugin
+* 'name': nome del buffer, se NULL o la stringa è vuota, viene
+  restituito il buffer corrente (buffer visualizzato dalla finestra corrente)
+
+Valore restituito:
+
+* puntatore al buffer trovato, NULL in caso contrario
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_buffer *my_buffer = weechat_buffer_search ("my_plugin",
+                                                        "my_buffer");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+buffer = weechat.buffer_search(plugin, name)
+
+# esempio
+buffer = weechat.buffer_search("my_plugin", "my_buffer")
+----------------------------------------
+
+weechat_buffer_search_main
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Cerca nel buffer principale di WeeChat (per primo nel buffer 'core', il primo
+visualizzato all'avvio di WeeChat).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_buffer *weechat_buffer_search_main ();
+----------------------------------------
+
+Valore restituito:
+
+* puntatore al buffer principale di WeeChat (buffer 'core')
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_buffer *weechat_buffer = weechat_buffer_search_main ();
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+buffer = weechat.buffer_search_main()
+
+# esempio
+buffer = weechat.buffer_search_main()
+----------------------------------------
+
+weechat_buffer_clear
+^^^^^^^^^^^^^^^^^^^^
+
+Pulisce il contenuto del buffer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_buffer_clear (struct t_gui_buffer *buffer);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_buffer *my_buffer = weechat_buffer_search ("my_plugin",
+                                                        "my_buffer");
+if (my_buffer)
+{
+    weechat_buffer_clear (my_buffer);
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.buffer_clear(buffer)
+
+# esempio
+buffer = weechat.buffer_search("my_plugin", "my_buffer")
+if buffer != "":
+    weechat.buffer_clear(buffer)
+----------------------------------------
+
+weechat_buffer_close
+^^^^^^^^^^^^^^^^^^^^
+
+Chiude un buffer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_buffer_close (struct t_gui_buffer *buffer);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_buffer *my_buffer = weechat_buffer_new ("my_buffer",
+                                                     &my_input_cb, NULL,
+                                                     &my_close_cb, NULL);
+/* ... */
+weechat_buffer_close (my_buffer);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.buffer_close(buffer)
+
+# esempio
+buffer = weechat.buffer_new("my_buffer", "my_input_cb", "", "my_close_cb", "")
+# ...
+weechat.buffer_close(buffer)
+----------------------------------------
+
+weechat_buffer_merge
+^^^^^^^^^^^^^^^^^^^^
+
+Unisce un buffer in un altro: entrambi i buffer esistono separatamente, ma
+con lo stesso numero, e WeeChat visualizzerà le righe di entrambi i
+buffer (righe mischiate).
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_buffer_merge (struct t_gui_buffer *buffer,
+                           struct t_gui_buffer *target_buffer);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'target_buffer': buffer di destinazione, dove il buffer verrà unito
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+/* merge current buffer with weechat "core" buffer */
+weechat_buffer_merge (weechat_current_buffer (),
+                      weechat_buffer_search_main ());
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.buffer_merge(buffer, target_buffer)
+
+# esempio
+# merge current buffer with WeeChat "core" buffer
+weechat.buffer_merge(weechat.current_buffer(), weechat.buffer_search_main())
+----------------------------------------
+
+weechat_buffer_unmerge
+^^^^^^^^^^^^^^^^^^^^^^
+
+Stacca un buffer da un gruppo di buffer uniti.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_buffer_unmerge (struct t_gui_buffer *buffer,
+                             int number);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'number': numero di destinazione per il buffer staccato,
+  se è < 1, allora il buffer verrà spostato al numero di
+  'buffer' +1
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_buffer_unmerge (weechat_current_buffer (), 1);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.buffer_unmerge(buffer, number)
+
+# esempio
+weechat.buffer_unmerge(weechat.current_buffer(), 1)
+----------------------------------------
+
+weechat_buffer_get_integer
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore intero della proprietà di
+un buffer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_buffer_get_integer (struct t_gui_buffer *buffer,
+                                const char *property);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'property': nome della proprietà:
+** 'number': numero del buffer (inizia da 1)
+** 'num_displayed': numero delle finestre che visualizzano il buffer
+** 'notify': livello di notifica per il buffer
+** 'lines_hidden': 1 se almeno una riga è nascosta sul buffer (filtrata),
+   oppure 0 se vengono visualizzate tutte le righe
+** 'prefix_max_length': lunghezza massima del prefisso in questo buffer
+** 'time_for_each_line': 1 se l'ora è visualizzata per ogni riga nel buffer
+   (predefinito), altrimenti 0
+** 'text_search': tipo di ricerca nel testo:
+*** 0: nessuna ricerca in questo momento
+*** 1: ricerca all'indietro (direzione: messaggi più vecchi)
+*** 2: ricerca in avanti (direzione: messaggi più nuovi)
+** 'text_search_exact': 1 se la ricerca testo è esatta
+** 'text_search_found': 1 se il testo viene trovato, altrimenti 0
+
+Valore restituito:
+
+* valore intero della proprietà
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "my buffer number is: %d",
+                weechat_buffer_get_integer (my_buffer, "number"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.buffer_get_integer(buffer, property)
+
+# esempio
+weechat.prnt("", "my buffer number is: %d" % weechat.buffer_get_integer(my_buffer, "number"))
+----------------------------------------
+
+weechat_buffer_get_string
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore stringa di una proprietà del buffer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_buffer_get_string (struct t_gui_buffer *buffer,
+                                       const char *property);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'property': nome proprietà:
+** 'plugin': nome del plugin che ha creato questo buffer ("core"
+   per il buffer principale di WeeChat) 
+** 'name': nome del buffer
+** 'short_name': nome breve del buffer
+** 'tilte': titolo del buffer
+** 'input': testo in ingresso
+** 'localvar_xxx': ottiene il contenuto della variabile locale "xxx"
+   (sostituire "xxx" con il nome della variabile da leggere)
+
+Valore restituito:
+
+* valore stringa della proprietà
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "name / short name of buffer are: %s / %s",
+                weechat_buffer_get_string (my_buffer, "name"),
+                weechat_buffer_get_string (my_buffer, "short_name"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.buffer_get_string(buffer, property)
+
+# esempio
+weechat.prnt("", "name / short name of buffer are: %s / %s"
+    % (weechat.buffer_get_string(my_buffer, "name"),
+    weechat.buffer_get_string(my_buffer, "short_name")))
+----------------------------------------
+
+weechat_buffer_get_pointer
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore puntatore della proprietà di un buffer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_buffer_pointer (struct t_gui_buffer *buffer,
+                                    const char *property);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'property': nome proprietà:
+** 'plugin': puntatore al plugin che ha creato questo buffer (NULL
+   per il buffer principale di WeeChat)
+
+Valore restituito:
+
+* valore puntatore della proprietà
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "plugin pointer of my buffer: %lx",
+                weechat_buffer_get_pointer (my_buffer, "plugin"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.buffer_get_pointer(buffer, property)
+
+# esempio
+weechat.prnt("", "plugin pointer of my buffer: %lx" % weechat.buffer_get_pointer(my_buffer, "plugin"))
+----------------------------------------
+
+weechat_buffer_set
+^^^^^^^^^^^^^^^^^^
+
+Imposta il valore stringa della proprietà di un buffer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_buffer_set (struct t_gui_buffer *buffer, const char *property,
+                         const char *value);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'property' e 'value': nome della proprietà, con il proprio valore:
+
+[width="100%",cols="^2,4,8",options="header"]
+|========================================
+| Name | Value | Description
+
+| hotlist | "+", "-", WEECHAT_HOTLIST_LOW, WEECHAT_HOTLIST_MESSAGE,
+  WEECHAT_HOTLIST_PRIVATE, WEECHAT_HOTLIST_HIGHLIGHT |
+  "+": abilita hotlist (impostazione globale , il puntatore al buffer pointer non
+  è utilizzato) +
+  "-": disabilita hotlist (impostazione globale, il puntatore al buffer non è
+  utilizzato) +
+  priorità: aggiunge il buffer alla hotlist con questa proprietà
+
+| unread | (N/D) |
+  imposta l'evidenziatore di lettura dopo l'ultima riga del buffer
+
+| display | "1", "auto" |
+  "1": passa a questo buffer nella finestra corrente +
+  "auto": passa a questo buffer nella finestra corrente, l'evidenziatore di
+  lettura non viene resettato
+
+| number | numero |
+  sposta buffer a questo numero
+
+| name | qualsiasi stringa |
+  imposta nuovo nome per il buffer
+
+| short_name | qualsiasi stringa |
+  imposta nuovo nome breve per il buffer
+
+| type | "formatted" o "free" |
+  imposta tipo per il: "formatted" (per stampare i messaggi di chat),
+  oppure "free" (per contenuto libero)
+
+| notify | "0", "1", "2", "3" |
+  set notify level for buffer: "0" = never add to hotlist, "1" = add for
+  highlights only, "2" = add for highlights and messages, "3" = add for all
+  messages 
+
+| title | any string |
+  set new title for buffer
+
+| time_for_each_line | "0" or "1" |
+  "0" to hide time for all lines in buffer, "1" to see time for all lines
+  (default for a new buffer) 
+
+| nicklist | "0" or "1" |
+  "0" to remove nicklist for buffer, "1" to add nicklist for buffer
+
+| nicklist_case_sensitive | "0" or "1" |
+  "0" to have case insensitive nicklist, "1" to have case sensitive nicklist
+
+| nicklist_display_groups | "0" or "1" |
+  "0" to hide nicklist groups, "1" to display nicklist groups
+
+| highlight_words | "-" or comma separated list of words |
+  "-" is a special value to disable any highlight on this buffer, or comma
+  separated list of words to highlight in this buffer, for example:
+  "abc,def,ghi" 
+
+| highlight_tags | comma separated list of tags |
+  comma separated list of tags to highlight in this buffer
+
+| key_bind_xxx | any string |
+  bind a new key 'xxx', specific to this buffer, value is command to execute
+  for this key
+
+| key_unbind_xxx | (N/A) |
+  unbind key 'xxx' for this buffer
+
+| input | any string |
+  set new value for buffer input
+
+| input_get_unknown_commands | "0" or "1" |
+  "0" to disable unknown commands on this buffer (default behaviour), "1" to
+  get unknown commands, for example if user type "/unknowncmd", buffer will
+  receive it (no error about unknown command)
+
+| localvar_set_xxx | any string |
+  set new value for local variable 'xxx' (variable is created if it does not
+  exist)
+
+| localvar_del_xxx | (N/A) |
+  remove local variable 'xxx'
+|========================================
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+/* disabilita hotlist (per tutti i buffer) */
+weechat_buffer_set (NULL, "hotlist", "-");
+
+/* abilita nuovamente hotlist */
+weechat_buffer_set (NULL, "hotlist", "+");
+
+/* cambia il nome buffer */
+weechat_buffer_set (my_buffer, "name", "my_new_name");
+
+/* aggiunge una nuova variabile locale "tizio" con il valore "abc" */
+weechat_buffer_set (my_buffer, "localvar_set_tizio", "abc");
+
+/* rimuove la variabile locale "tizio" */
+weechat_buffer_set (my_buffer, "localvar_del_tizio", NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.buffer_set(buffer, property, value)
+
+# esempi
+
+# disabilita hotlist (per tutti i buffer)
+weechat.buffer_set("", "hotlist", "-")
+
+# abilita nuovamente hotlist
+weechat.buffer_set("", "hotlist", "+")
+
+# cambia il nome buffer
+weechat.buffet_set(my_buffer, "name", "my_new_name")
+
+# aggiunge una nuova variabile locale "tizio" con il valore "abc"
+weechat.buffet_set(my_buffer, "localvar_set_tizio", "abc")
+
+# rimuove la variabile locale "tizio"
+weechat.buffet_set(my_buffer, "localvar_del_toto", "")
+----------------------------------------
+
+weechat_buffer_set_pointer
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Imposta il valore puntatore per la proprietà di un buffer.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_buffer_set_pointer (struct t_gui_buffer *buffer, const char *property,
+                                 void *pointer);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'property' e 'value': nome della proprietà, con il proprio valore:
+** 'close_callback': set close callback function
+** 'close_callback_data': set close callback data
+** 'input_callback': set input callback function
+** 'input_callback_data': set input callback data
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_close_cb (void *data, struct t_gui_buffer *buffer)
+{
+    /* ... */
+    return WEECHAT_RC_OK;
+}
+
+weechat_buffer_set_pointer (my_buffer, "close_callback", &my_close_cb);
+----------------------------------------
+
+weechat_buffer_string_replace_local_var
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Sostituisce le variabili globali in una stringa con i loro valori, utilizzando
+le variabili del buffer locale.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+char *weechat_buffer_string_replace_local_var (struct t_gui_buffer *buffer,
+                                               const char *string);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'string': stringa con testo e variabili locali che utilizzano il formato "$var"
+
+Valore restituito:
+
+* stringa con i valori delle variabili locali
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_buffer_set (my_buffer, "localvar_set_toto", "abc");
+
+char *str = weechat_buffer_string_replace_local_var (my_buffer,
+                                                     "test with $toto");
+/* str contains "test with abc" */
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.buffer_string_replace_local_var(buffer, string)
+
+# esempio
+weechat.buffer_set(my_buffer, "localvar_set_toto", "abc")
+str = weechat.buffer_string_replace_local_var(my_buffer, "test with $toto")
+# str contains "test with abc"
+----------------------------------------
+
+[[windows]]
+Windows
+~~~~~~~
+
+Functions to query windows.
+
+weechat_current_window
+^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il puntatore alla finestra corrente
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_window *weechat_current_window ();
+----------------------------------------
+
+Valore restituito:
+
+* puntatore alla finestra corrente
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_window *current_window = weechat_current_window ();
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+window = weechat.current_window()
+
+# esempio
+current_window = weechat.current_window()
+----------------------------------------
+
+weechat_window_get_integer
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+ il valore intero della proprietà di una finestra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_window_get_integer (struct t_gui_window *window,
+                                const char *property);
+----------------------------------------
+
+Argomenti:
+
+* 'window': puntatore alla finestra
+* 'property': nome della proprietà:
+** 'win_x': posizione X della finestra nel terminale (la prima colonna è 0)
+** 'win_y': posizione Y della finestra nel terminale (la prima riga è 0)
+** 'win_width': larghezza della finestra, in caratteri
+** 'win_height': altezza della finestra, in caratteri
+** 'win_width_pct': misura percentuale, paragonata alla finestra genitore
+   (ad esempio 50 vuol dire metà grandezza)
+** 'win_height_pct': misura percentuale, paragonata alla finestra genitore
+   (ad esempio 50 vuol dire metà grandezza)
+** 'win_chat_x': posizione X della finestra di chat nel terminale
+   (la prima colonna è 0)
+** 'win_chat_y': posizione Y della finestra di chat nel terminale
+   (la prima riga è 0)
+** 'win_chat_width': larghezza della finestra di chat, in caratteri
+** 'win_chat_height': altezza della finestra di chat, in caratteri
+** 'first_line_displayed': 1 se la prima riga del buffer viene visualizzata
+   su schermo, altrimenti 0
+** 'scroll': 1 se lo scorrimento è attivo sulla finestra (ultima riga non
+   visualizzata)
+** 'scroll_lines_after': numero di righe non visualizzate dopo l'ultima
+   visualizzata (durante lo scorrimento)
+
+Valore restituito:
+
+* valore intero della proprietà
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "current window is at position (x,y): (%d,%d)",
+                weechat_window_get_integer (weechat_current_window (), "win_x"),
+                weechat_window_get_integer (weechat_current_window (), "win_y"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.window_get_integer(window, property)
+
+# esempio
+weechat.prnt("", "current window is at position (x,y): (%d,%d)"
+    % (weechat.window_get_integer(weechat.current_window(), "win_x"),
+    weechat.window_get_integer(weechat.current_window(), "win_y")))
+----------------------------------------
+
+weechat_window_get_string
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore stringa della proprietà di una finestra.
+
+[NOTE]
+La funzione non è utilizzata oggi, è riservata per una versione futura.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_window_get_string (struct t_gui_window *window,
+                               const char *property);
+----------------------------------------
+
+Argomenti:
+
+* 'window': puntatore alla finestra
+* 'property': nome della proprietà
+
+Valore restituito:
+
+* valore stringa della proprietà
+
+weechat_window_get_pointer
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore puntatore della proprietà di una finestra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void *weechat_window_get_pointer (struct t_gui_window *window,
+                                  const char *property);
+----------------------------------------
+
+Argomenti:
+
+* 'window': puntatore alla finestra
+* 'property': nome della proprietà:
+** 'current': puntatore alla finestra corrente
+** 'buffer': puntatore al buffer visualizzato dalla finestra
+
+Valore restituito:
+
+* valore puntatore della proprietà
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL,
+                "buffer displayed in current window: %lx",
+                weechat_window_get_pointer (weechat_current_window (), "buffer"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.window_get_pointer(window, property)
+
+# esempio
+weechat.prnt("", "buffer displayed in current window: %lx"
+    % weechat.window_get_pointer(weechat.current_window(), "buffer"))
+----------------------------------------
+
+weechat_window_set_title
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+ il titolo per il terminale.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_window_set_title (const char *title);
+----------------------------------------
+
+Argomenti:
+
+* 'title': nuovo titolo per il terminale (NULL per resettarlo)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_window_set_title ("nuovo titolo qui");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.window_set_title(window, title)
+
+# esempio
+weechat.window_set_title("nuovo titolo qui")
+----------------------------------------
+
+[[nicklist]]
+Nicklist
+~~~~~~~~
+
+ per il buffer nicklist.
+
+weechat_nicklist_add_group
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiunge un gruppo in una nicklist.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_nick_group *weechat_nicklist_add_group (struct t_gui_buffer *buffer,
+                                                     struct t_gui_nick_group *parent_group,
+                                                     const char *name,
+                                                     const char *color,
+                                                     int visible);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'parent_group': puntatore al genitore del gruppo, NULL se il gruppo non ha genitore
+  (nicklist radice)
+* 'name': nome del gruppo
+* 'visible':
+** '1': gruppi e sottogruppi/nick sono visibili
+** '0': gruppi e sottogruppi/nick sono nascosti
+* 'color': nome per l'opzione colore:
+** nome opzione per WeeChat, ad esempio 'weechat.color.nicklist_group'
+** colore con sfondo opzionale, ad esempio 'yellow' o 'yellow,red'
+** nome colore per la barra:
+*** 'bar_fg': colore di primo piando per la barra
+*** 'bar_delim': colore dei delimitatori per la barra
+*** 'bar_bg': colore di sfondo per la barra
+
+[NOTE]
+Il nome del gruppo può iniziare con uno o più numeri, seguiti da una pipe, e
+infine dal nome del gruppo. Quando questa stringa si trova all'inizio, viene
+utilizzata per ordinare i gruppi nella lista nick. Ad esempio i gruppi "1|test" e
+"2|abc" verranno visualizzati in quest'ordine: prima "test" poi "abc".
+
+Valore restituito:
+
+* puntatore al nuovo gruppo, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_nick_group *my_group =
+    weechat_nicklist_add_group (my_buffer,
+                                my_parent_group,
+                                "test_group",
+                                "weechat.color.nicklist_group",
+                                1);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+group = weechat.nicklist_add_group(buffer, parent_group, name, color, visible)
+
+# esempio
+group = weechat.nicklist_add_group(my_buffer, my_parent_group, "test_group",
+    "weechat.color.nicklist_group", 1)
+----------------------------------------
+
+weechat_nicklist_search_group
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Cerca un gruppo in una lista nick.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_nick_group *weechat_nicklist_search_group (struct t_gui_buffer *buffer,
+                                                        struct t_gui_nick_group *from_group,
+                                                        const char *name);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'from_group': ricerca solo da questo gruppo, se NULL, allora la cerca in
+  tutta la lista nick
+* 'name': nome gruppo da cercare
+
+Valore restituito:
+
+* puntatore al gruppo trovato, NULL se non trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_nick_group *ptr_group = weechat_nicklist_search_group (my_buffer,
+                                                                    NULL, "test_group");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+group = weechat.nicklist_search_group(buffer, from_group, name)
+
+# esempio
+group = weechat.nicklist_search_group(my_buffer, "", "test_group")
+----------------------------------------
+
+weechat_nicklist_add_nick
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiunge un nick in un gruppo.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_nick_group *weechat_nicklist_add_nick (struct t_gui_buffer *buffer,
+                                                    struct t_gui_nick_group *group,
+                                                    const char *name,
+                                                    const char *color,
+                                                    const char *prefix,
+                                                    const char *prefix_color,
+                                                    int visible);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'group': puntatore al gruppo
+* 'name': nome nick
+* 'color': nome dell'opzione per il colore:
+*** nome opzione per WeeChat (da weechat.color.xxx), ad esempio 'chat_delimiters'
+*** colore con sfondo opzionale, ad esempio 'yellow' o 'yellow,red'
+*** nome colore per la barra:
+**** 'bar_fg': colore di primo piano per la barra
+**** 'bar_delim': colore dei delimitatori per la barra
+**** 'bar_bg': colore di sfondo per la barra
+* 'prefix': prefisso visualizzato prima del nick
+* 'prefix_color': nome dell'opzione per il colore:
+** nome opzione per WeeChat (da weechat.color.xxx), ad esempio 'chat_delimiters'
+** colore con sfondo opzionale, ad esempio 'yellow' o 'yellow,red'
+** nome colore per la barra:
+*** 'bar_fg': colore di primo piano per la barra
+*** 'bar_delim': colore dei delimitatori per la barra
+*** 'bar_bg': colore di sfondo per la barra
+* 'visible':
+** '1': il nick è visibile
+** '0': il nick è nascosto
+
+Valore restituito:
+
+* puntatore al nuovo nick, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_nick *my_nick =
+    weechat_nicklist_add_nick (my_buffer, my_group,
+                               "test_nick",
+                               (nick_away) ? "weechat.color.nicklist_away" : "bar_fg",
+                               "@", "lightgreen",
+                               1);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+nick = weechat.nicklist_add_nick(buffer, group, name, color, prefix, prefix_color, visible)
+
+# esempio
+if nick_away:
+    color = "weechat.color.nicklist_away"
+else:
+    color = "bar_fg"
+nick = weechat.nicklist_add_nick(my_buffer, my_group, "test_nick", color, "@", "lightgreen", 1)
+----------------------------------------
+
+weechat_nicklist_search_nick
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Cerca un nick nella lista nick.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_nick *weechat_nicklist_search_nick (struct t_gui_buffer *buffer,
+                                                 struct t_gui_nick_group *from_group,
+                                                 const char *name);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'from_group': cerca solo da questo gruppo, se NULL, allora cerca
+  nell'intera lista nick
+* 'name': nick da cercare
+
+Valore restituito:
+
+* puntatore al nuovo nick, NULL se non trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_nick *ptr_nick = weechat_nicklist_search_nick (my_buffer,
+                                                            NULL, "test_nick");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+nick = weechat.nicklist_search_nick(buffer, from_group, name)
+
+# esempio
+nick = weechat.nicklist_search_nick(my_buffer, "", "test_nick")
+----------------------------------------
+
+weechat_nicklist_remove_group
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Rimuove un gruppo da una lista nick.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_nicklist_remove_group (struct t_gui_buffer *buffer,
+                                    struct t_gui_nick_group *group);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'group': puntatore al gruppo da rimuovere (verranno rimossi anhe
+  i sottogruppi/nick)
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_nicklist_remove_group (my_buffer, my_group);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.nicklist_remove_group(buffer, group)
+
+# esempio
+weechat.nicklist_remove_group(my_buffer, my_group)
+----------------------------------------
+
+weechat_nicklist_remove_nick
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Rimuove un nick dalla lista nick.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_nicklist_remove_nick (struct t_gui_buffer *buffer,
+                                   struct t_gui_nick *nick);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+* 'nick': puntatore al nick da rimuovere
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_nicklist_remove_nick (my_buffer, my_nick);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.nicklist_remove_nick(buffer, nick)
+
+# esempio
+weechat.nicklist_remove_nick(my_buffer, my_nick)
+----------------------------------------
+
+weechat_nicklist_remove_all
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Rimuove tutti i gruppi/nick da una lista nick.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_nicklist_remove_all (struct t_gui_buffer *buffer);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_nicklist_remove_all (my_buffer);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.nicklist_remove_all(buffer)
+
+# esempio
+weechat.nicklist_remove_all(my_buffer)
+----------------------------------------
+
+[[bars]]
+Barre
+~~~~~
+
+Functions for bars.
+
+weechat_bar_item_search
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Cerca un elemento barra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_bar_item *weechat_bar_item_search (const char *name);
+----------------------------------------
+
+Argomenti:
+
+* 'name': nome dell'elemento barra
+
+Valore restituito:
+
+* puntatore all'elemento barra trovato, NULL se non trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_bar_item *bar_item = weechat_bar_item_search ("myitem");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+bar_item = weechat.bar_item_search(name)
+
+# esempio
+bar_item = weechat.bar_item_search("myitem")
+----------------------------------------
+
+weechat_bar_item_new
+^^^^^^^^^^^^^^^^^^^^
+
+Crea un nuovo elemento barra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_bar_item *weechat_bar_item_new (const char *name,
+                                             char *(build_callback)(void *data,
+                                                                    struct t_gui_bar_item *item,
+                                                                    struct t_gui_window *window),
+                                             void *build_callback_data);
+----------------------------------------
+
+Argomenti:
+
+* 'name': nome dell'elemento barra
+* 'build_callback': funzione chiamata quando l'elemento barra viene
+  compilato; deve restituire il contenuto dell'elemento barra
+* 'build_callback_data': puntatore fornito alla callback quando
+  chiamata da WeeChat
+
+Valore restituito:
+
+* puntatore al nuovo elemento barra, NULL se non trovato
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char *
+my_build_callback (void *data,
+                   struct t_gui_bar_item *item,
+                   struct t_gui_window *window)
+{
+    return strdup ("my content");
+}
+
+struct t_gui_bar_item *my_item = weechat_bar_item_new ("myitem",
+                                                       &my_build_callback,
+                                                       NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+bar_item = weechat.bar_item_new(name, build_callback, build_callback_data)
+
+# esempio
+def my_build_callback(data, item, window):
+    return "my content"
+
+bar_item = weechat.bar_item_new("myitem", "my_build_callback", "")
+----------------------------------------
+
+weechat_bar_item_update
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiorna il contenuto dell'elemento barra, chiamando la callback
+che lo ha compilato.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_bar_item_update (const char *name);
+----------------------------------------
+
+Argomenti:
+
+* 'name': nome dell'elemento barra
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_bar_item_update ("myitem");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.bar_item_update(name)
+
+# esempio
+weechat.bar_item_update("myitem")
+----------------------------------------
+
+weechat_bar_item_remove
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Rimuove un elemento barra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_bar_item_remove (struct t_gui_bar_item *item);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento barra
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_bar_item_remove (&my_item);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.bar_item_remove(item)
+
+# esempio
+weechat.bar_item_remove(myitem)
+----------------------------------------
+
+weechat_bar_search
+^^^^^^^^^^^^^^^^^^
+
+Cerca una barra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_bar *weechat_bar_search (const char *name);
+----------------------------------------
+
+Argomenti:
+
+* 'name': nome della barra
+
+Valore restituito:
+
+* puntatore alla barra trovata, NULL se non trovata
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_bar *bar = weechat_bar_search ("mybar");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+bar = weechat.bar_search(name)
+
+# esempio
+bar = weechat.bar_search("mybar")
+----------------------------------------
+
+weechat_bar_new
+^^^^^^^^^^^^^^^
+
+Crea una nuova barra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_gui_bar *weechat_bar_new (const char *name,
+                                   const char *hidden,
+                                   const char *priority,
+                                   const char *type,
+                                   const char *condition,
+                                   const char *position,
+                                   const char *filling_top_bottom,
+                                   const char *filling_left_right,
+                                   const char *size,
+                                   const char *size_max,
+                                   const char *color_fg,
+                                   const char *color_delim,
+                                   const char *color_bg,
+                                   const char *separator,
+                                   const char *items);
+----------------------------------------
+
+Argomenti:
+
+* 'name': nome della barra
+* 'hidden':
+** 'on': la barra è nascosta
+** 'off': la barra è visibile
+* 'priority': priorità per la barra (intero)
+* 'type':
+** 'root': barra visualizzata una sola volta, al di fuori delle finestre
+** 'window': barra visualizzata in ogni finestra
+* 'condition': condizioni per la visualizzazione della barra:
+** 'active': la barra viene visualizzata solo nella finestra attiva
+** 'inactive': la barra viene visualizzata solo nelle finestre inattive
+** 'nicklist': la barra viene visualizzata nelle finestre con liste nick
+* 'position': 'top', 'bottom', 'left' o 'right'
+* 'filling_top_bottom':
+** 'horizontal': gli elementi sono posizionati in orizzontale
+   (spazio dopo ogni elemento)
+** 'vertical': gli elementi sono posizionati in verticale
+   (nuova riga dopo ogni elemento)
+** 'columns_horizontal': gli elementi sono posizionati in orizzontale,
+   visualizzati su colonne
+** 'columns_vertical': gli elementi sono posizionati in verticale,
+   visualizzati su colonne
+* 'filling_left_right':
+** 'horizontal': gli elementi sono posizionati in orizzontale
+   (spazio dopo ogni elemento)
+** 'vertical': gli elementi sono posizionati in verticale
+   (nuova riga dopo ogni elemento)
+** 'columns_horizontal': gli elementi sono posizionati in orizzontale,
+   visualizzati su colonne 
+** 'columns_vertical': gli elementi sono posizionati in verticale,
+   visualizzati su colonne
+* 'size': dimensione della barra in caratteri
+  (0 corrisponde a dimensione automatica)
+* 'size_max': dimensione massima per la barra
+  (0 corrisponde a nessuna dimensione massima)
+* 'color_fg': colore per il testo nella barra
+* 'color_delim': colore per i delimitatori nella barra
+* 'color_bg': colore di sfondo per la barra
+* 'separator':
+** 'on': la barra ha una riga di separazione con altre finestre/barre
+** 'off': nessun separatore
+* 'items': elenco di elemento nella barra, separati da virgola (spazio tra
+  gli elementi), o "+" (elementi incollati)
+
+Valore restituito:
+
+* puntatore alla nuova barra, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_gui_bar *my_bar = weechat_bar_new ("mybar",
+                                            "off",
+                                            100,
+                                            "window",
+                                            "",
+                                            "top",
+                                            "horizontal",
+                                            "vertical",
+                                            "0",
+                                            "5",
+                                            "default",
+                                            "cyan",
+                                            "blue",
+                                            "off",
+                                            "time,buffer_number+buffer_name");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+bar = weechat.bar_new(name, hidden, priority, type, condition, position,
+    filling_top_bottom, filling_left_right, size, size_max,
+    color_fg, color_delim, color_bg, separator, items)
+
+# esempio
+bar = weechat.bar_new("mybar", "off", 100, "window", "", "top", "horizontal", "vertical",
+    "0", "5", "default", "cyan", "blue", "off", "time,buffer_number+buffer_name")
+----------------------------------------
+
+weechat_bar_set
+^^^^^^^^^^^^^^^
+
+Imposta un nuovo valore per la proprietà di una barra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_bar_set (struct t_gui_bar *bar, const char *property,
+                     const char *value);
+----------------------------------------
+
+Argomenti:
+
+* 'bar': puntatore alla barra
+* 'property': name, hidden, priority, conditions, position, filling_top_bottom,
+  filling_left_right, size, size_max, color_fg, color_delim, color_bg,
+  separator, items (consultare <<_weechat_bar_new>>)
+* 'value': nuovo valore per la proprietà
+
+Valore restituito:
+
+* 1 se il nuovo valore è stato impostato, 0 in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_bar_set (mybar, "position", "bottom");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.bar_set(bar, property, value)
+
+# esempio
+weechat.bar_set(my_bar, "position", "bottom")
+----------------------------------------
+
+weechat_bar_update
+^^^^^^^^^^^^^^^^^^
+
+Aggiorna il contenuto di una barra su schermo.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_bar_update (const char *name);
+----------------------------------------
+
+Argomenti:
+
+* 'name': nome della barra
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_bar_update ("mybar");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.bar_update(name)
+
+# esempio
+weechat.bar_update("mybar")
+----------------------------------------
+
+weechat_bar_remove
+^^^^^^^^^^^^^^^^^^
+
+Rimuove una barra.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_bar_remove (struct t_gui_bar *bar);
+----------------------------------------
+
+Argomenti:
+
+* 'bar': puntatore alla barra
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_bar_remove (mybar);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.bar_remove(bar)
+
+# esempio
+weechat.bar_remove(my_bar)
+----------------------------------------
+
+[[commands]]
+Comandi
+~~~~~~~
+
+Funzioni per eseguire comandi di WeeChat.
+
+weechat_command
+^^^^^^^^^^^^^^^
+
+Esegue un comando.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_command (struct t_gui_buffer *buffer, const char *command);
+----------------------------------------
+
+Argomenti:
+
+* 'buffer': puntatore al buffer (il comando viene eseguito su questo buffer,
+  utilizzare NULL per il buffer core di WeeChat)
+* 'command': comando da eseguire (se preceduto da "/"), oppure il testo
+  viene inviato sul buffer
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_command (weechat_buffer_search ("irc", "freenode.#weechat"),
+                 "/whois FlashCode");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.command(buffer, command)
+
+# esempio
+weechat.command(weechat.buffer_search("irc", "freenode.#weechat"), "/whois FlashCode")
+----------------------------------------
+
+[[network]]
+Network
+~~~~~~~
+
+Funzioni di rete.
+
+weechat_network_pass_proxy
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Stabilisce una connessione/autenticazione con un proxy.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_network_pass_proxy (const char *proxy,
+                                int sock,
+                                const char *address,
+                                int port);
+----------------------------------------
+
+Argomenti:
+
+* 'proxy': nome del proxy da utilizzare
+* 'sock': socket da utilizzare
+* 'address': indirizzo (nome host o indirizzo IP)
+* 'port': port
+
+Valore restituito:
+
+* 1 se la connessione è andata a buon fine, 0 in caso di
+  errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_network_pass_proxy ("my_proxy", sock, "irc.freenode.net", 6667))
+{
+    /* OK */
+}
+else
+{
+    /* error */
+}
+----------------------------------------
+
+weechat_network_connect_to
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Stabilisce una connessione con un host remoto.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_network_connect_to (const char *proxy,
+                                int sock,
+                                unsigned long address,
+                                int port);
+----------------------------------------
+
+Argomenti:
+
+* 'proxy': nome del proxy da utilizzare
+* 'sock': socket da utilizzare
+* 'address': indirizzo
+* 'port': porta
+
+Valore restituito:
+
+* 1 se la connessione è andata a buon fine, 0 in
+  caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct sockaddr_in addr;
+socklen_t length;
+unsigned long address;
+
+memset (&addr, 0, sizeof (struct sockaddr_in));
+length = sizeof (addr);
+getsockname (sock, (struct sockaddr *) &addr, &length);
+addr.sin_family = AF_INET;
+address = ntohl (addr.sin_addr.s_addr);
+
+if (weechat_network_connect_to (NULL, sock, address, 6667))
+{
+    /* OK */
+}
+else
+{
+    /* errore */
+}
+----------------------------------------
+
+[[infos]]
+Info
+~~~~
+
+Funzioni per ottenere info.
+
+weechat_info_get
+^^^^^^^^^^^^^^^^
+
+Restituisce informazioni da WeeChat o da un plugin.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_info_get (const char *info_name, const char *arguments);
+----------------------------------------
+
+Argomenti:
+
+* 'info_name': nome delle informazioni da leggere:
+include::autogen/plugin_api/infos.txt[]
+* 'arguments': argomenti per l'informazione richiesta (opzionake, NULL se non
+  è richiesto alcun argomento)
+
+Valore restituito:
+
+* stringa con l'informazione richiesta, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "Current WeeChat version is: %s (compiled on %s)",
+                weechat_info_get ("version", NULL),
+                weechat_info_get ("date", NULL));
+weechat_printf (NULL, "WeeChat home is: %s",
+                weechat_info_get ("weechat_dir"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.info_get(info_name, arguments)
+
+# esempio
+weechat.prnt("", "Current WeeChat version is: %s (compiled on %s)"
+    % (weechat.info_get("version", ""), weechat.info_get("date", ""))
+weechat.prnt("", "WeeChat home is: %s" % weechat.info_get("weechat_dir"))
+----------------------------------------
+
+[[infolists]]
+Liste info
+~~~~~~~~~~
+
+Una lista info è una lista di "elementi". Ciascun elemento contiene
+delle variabili.
+
+Ad esempio, la lista info "irc_server" ha N elementi (N è il numero di
+server IRC definiti). Per ogni elemento, esistono variabili come "name",
+"buffer", "is connected",...
+
+Ogni variabile ha un tipo e un valore. I tipi possibili sono:
+
+* 'integer': qualunque valore intero
+* 'string': qualunque valore stringa
+* 'pointer': qualunque puntatore
+* 'buffer': buffer di lunghezza fissa, contenente qualunque dato
+* 'time': valore tempo
+
+weechat_infolist_new
+^^^^^^^^^^^^^^^^^^^^
+
+Crea una nuova lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_infolist *weechat_infolist_new ();
+----------------------------------------
+
+Valore restituito:
+
+* puntatore alla nuova lista info
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_infolist *infolist = weechat_infolist_new ();
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+infolist = weechat.infolist_new()
+
+# esempio
+infolist = weechat.infolist_new()
+----------------------------------------
+
+weechat_infolist_new_item
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiunge un elemento alla lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_infolist_item *weechat_infolist_new_item (struct t_infolist *infolist);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+
+Valore restituito:
+
+* puntatore al nuovo elemento
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_infolist_item *item = weechat_infolist_new_item (infolist);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+item = weechat.infolist_new_item(infolist)
+
+# esempio
+item = weechat.infolist_new_item(infolist)
+----------------------------------------
+
+weechat_infolist_new_var_integer
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiunge una variabile intera ad un elemento della
+lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_infolist_var *weechat_infolist_new_var_integer (struct t_infolist_item *item,
+                                                         const char *name,
+                                                         int value);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento della lista info
+* 'name': nome variabile
+* 'value': valore intero
+
+Valore restituito:
+
+* puntatore alla nuova variabile
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_infolist_var *var = weechat_infolist_new_var_integer (item,
+                                                               "my_integer",
+                                                               123);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+var = weechat.infolist_new_var_integer(item, name, value)
+
+# esempio
+var = weechat.infolist_new_var_integer(item, "my_integer", 123)
+----------------------------------------
+
+weechat_infolist_new_var_string
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiunge una variabile stringa ad un elemento
+della lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_infolist_var *weechat_infolist_new_var_string (struct t_infolist_item *item,
+                                                        const char *name,
+                                                        const char *value);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento della lista info
+* 'name': nome variabile
+* 'value': valore stringa
+
+Valore restituito:
+
+* puntatore alla nuova variabile
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_infolist_var *var = weechat_infolist_new_var_string (item,
+                                                              "my_string",
+                                                              "value");
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+var = weechat.infolist_new_var_string(item, name, value)
+
+# esempio
+var = weechat.infolist_new_var_string(item, "my_string", "value")
+----------------------------------------
+
+weechat_infolist_new_var_pointer
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiunge una variabile puntatore ad un elemento
+della lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_infolist_var *weechat_infolist_new_var_pointer (struct t_infolist_item *item,
+                                                         const char *name,
+                                                         void *pointer);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento della lista info
+* 'name': nome variabile
+* 'pointer': puntatore
+
+Valore restituito:
+
+* puntatore alla nuova variabile
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_infolist_var *var = weechat_infolist_new_var_pointer (item,
+                                                               "my_pointer",
+                                                               &pointer);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+var = weechat.infolist_new_var_pointer(item, name, pointer)
+
+# esempio
+var = weechat.infolist_new_var_pointer(item, "my_pointer", pointer)
+----------------------------------------
+
+weechat_infolist_new_var_buffer
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiunge una variabile puntatore ad un elemento della lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_infolist_var *weechat_infolist_new_var_buffer (struct t_infolist_item *item,
+                                                        const char *name,
+                                                        void *pointer,
+                                                        int size);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento della lista info
+* 'name': nome della variabile
+* 'pointer': puntatore al buffer
+* 'size': dimensione del buffer
+
+Valore restituito:
+
+* puntatore alla nuova variabile
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+char buffer[256];
+/* ... */
+struct t_infolist_var *var = weechat_infolist_new_variable_buffer (item,
+                                                                   "my_buffer",
+                                                                   &buffer,
+                                                                   sizeof (buffer));
+----------------------------------------
+
+weechat_infolist_new_var_time
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Aggiunge una variabile tempo ad un elemento della lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_infolist_var *weechat_infolist_new_var_time (struct t_infolist_item *item,
+                                                      const char *name,
+                                                      time_t time);
+----------------------------------------
+
+Argomenti:
+
+* 'item': puntatore all'elemento della lista info
+* 'name': nome della variabile
+* 'time': valore tempo
+
+Valore restituito:
+
+* puntatore alla nuova variabile
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_infolist_var *var = weechat_infolist_new_variable_time (item,
+                                                                 "my_time",
+                                                                 time (NULL));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+var = weechat.infolist_new_var_time(item, name, time)
+
+# esempio
+var = weechat.infolist_new_var_time(item, "my_time", int(time.time()))
+----------------------------------------
+
+weechat_infolist_get
+^^^^^^^^^^^^^^^^^^^^
+
+Restituisce una lista info da WeeChat o da un plugin.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_infolist *weechat_infolist_get (const char *infolist_name,
+                                         void *pointer,
+                                         const char *arguments);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist_name': nome della lista info da leggere:
+include::autogen/plugin_api/infolists.txt[]
+* 'pointer': puntatore ad un elemento, per ricevere solo questo 
+  elemento nella lista info (opzionale, può essere NULL)
+* 'arguments': argomenti per la lista info richiesta (opzionale, NULL se
+  non è necessario alcun argomento)
+
+Valore restituito:
+
+* puntatore alla lista info, NULL in caso di errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_infolist *infolist = weechat_infolist_get ("irc_server", NULL, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+infolist = weechat.infolist_get(infolist_name, pointer, arguments)
+
+# esempio
+infolist = weechat.infolist_get("irc_server, "", "")
+----------------------------------------
+
+weechat_infolist_next
+^^^^^^^^^^^^^^^^^^^^^
+
+Sposta "cursor" all'elemento successivo nella lista info. La prima chiamata
+a questa funzione per una lista info sposta il cursore al primo elemento
+nella lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_infolist_next (struct t_infolist *infolist);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+
+Valore restituito:
+
+* 1 se il cursore è stato spostato sull'elemento successivo, 0 se è
+  stata raggiunta la fine della lista
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_infolist_next (infolist))
+{
+    /* legge variabili nell'elemento... */
+}
+else
+{
+    /* nessun altro elemento disponibile */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.infolist_next(infolist)
+
+# esempio
+rc = weechat.infolist_next(infolist)
+if rc:
+    # legge variabili nell'elemento...
+else:
+    # nessun altro elemento disponibile
+----------------------------------------
+
+weechat_infolist_prev
+^^^^^^^^^^^^^^^^^^^^^
+
+Sposta "cursor" all'elemento precedente nella lista info. La prima
+chiamata a questa funzione per una lista info sposta il cursore
+all'ultimo elemento.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_infolist_prev (struct t_infolist *infolist);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+
+Valore restituito:
+
+* 1 se il cursore è stato spostato sull'elemento precedente, 0 se
+  è stato raggiunto l'inizio della lista
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_infolist_prev (infolist))
+{
+    /* legge variabili nell'elemento... */
+}
+else
+{
+    /* nessun altro elemento disponibile */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+rc = weechat.infolist_prev(infolist)
+
+# esempio
+rc = weechat.infolist_prev(infolist)
+if rc:
+    # read variables in item...
+else:
+    # no more item available
+----------------------------------------
+
+weechat_infolist_reset_item_cursor
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Ripristina "cursor" per la lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_infolist_reset_item_cursor (struct t_infolist *infolist);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_infolist_reset_item_cursor (infolist);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.infolist_reset_item_cursor(infolist)
+
+# esempio
+weechat.infolist_reset_item_cursor(infolist)
+----------------------------------------
+
+weechat_infolist_fields
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce una lista di campi per l'elemento della
+lista info corrente.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_infolist_fields (struct t_infolist *infolist);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+
+Valore restituito:
+
+* stringa con una lista di campi per l'elemento della lista info corrente.
+  La lista è separata da virgole, e contiene lettere per tipo, seguite dal
+  nome della variabile. I tipi sono: "i" (intero), "s" (stringa), "p" (puntatore),
+  "b" (buffer), "t" (tempo).
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+const char *fields = weechat_infolist_fields (infolist);
+/* i campi contengono qualcosa come:
+   "i:my_integer,s:my_string,p:my_pointer,b:my_buffer,t:my_time" */
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+fields = weechat.infolist_fields(infolist)
+
+# esempio
+fields = weechat.infolist_fields(infolist)
+# i campi contengono qualcosa come:
+# "i:my_integer,s:my_string,p:my_pointer,b:my_buffer,t:my_time"
+----------------------------------------
+
+weechat_infolist_integer
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore della variabile intera nell'elemento
+corrente della lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+int weechat_infolist_integer (struct t_infolist *infolist, const char *var);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+* 'var': nome della variabile (deve essere di tipo "integer")
+
+Valore restituito:
+
+* valore intero della variabile
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "integer = %d",
+                weechat_infolist_integer (infolist, "mio_intero"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.infolist_integer(infolist, var)
+
+# esempio
+weechat.prnt("", "integer = %d" % weechat.infolist_integer(infolist, "mio_intero"))
+----------------------------------------
+
+weechat_infolist_string
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore della variabile stringa nell'elemento
+della lista info corrente.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+const char *weechat_infolist_string (struct t_infolist *infolist, const char *var);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+* 'var': nome della variabile (deve essere di tipo "string")
+
+Valore restituito:
+
+* valore stringa della variabile
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "string = %s",
+                weechat_infolist_string (infolist, "mia_stringa"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.infolist_string(infolist, var)
+
+# esempio
+weechat.prnt("", "string = %s" % weechat.infolist_string(infolist, "mia_stringa"))
+----------------------------------------
+
+weechat_infolist_pointer
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore della variabile puntatore nell'elemento
+della lista info corrente.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void *weechat_infolist_pointer (struct t_infolist *infolist, const char *var);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+* 'var': nome della variabile (deve essere di tipo "pointer")
+
+Valore restituito:
+
+* puntatore al valore della variabile
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "pointer = 0x%lx",
+                weechat_infolist_pointer (infolist, "mio_puntatore"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.infolist_pointer(infolist, var)
+
+# esempio
+weechat.prnt("", "pointer = 0x%lx" % weechat.infolist_pointer(infolist, "mio_puntatore"))
+----------------------------------------
+
+weechat_infolist_buffer
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore della variabile buffer nell'elemento corrente
+della lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void *weechat_infolist_buffer (struct t_infolist *infolist, const char *var,
+                               int *size);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+* 'var': nome della variabile (deve essere di tipo "buffer")
+* 'size': puntatore ad una variabile intera, verrà impostata con la
+  dimensione del buffer
+
+Valore restituito:
+
+* puntatore al buffer
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int size;
+void *pointer = weechat_infolist_buffer (infolist, "my_buffer", &size);
+weechat_printf (NULL, "buffer = 0x%lx, size = %d",
+                pointer, size);
+----------------------------------------
+
+weechat_infolist_time
+^^^^^^^^^^^^^^^^^^^^^
+
+Restituisce il valore della variabile data/ora nell'elemento
+attivo della lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+time_t weechat_infolist_time (struct t_infolist *infolist, const char *var);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+* 'var': nome della variabile (deve essere di tipo "time")
+
+Valore restituito:
+
+* valore della variabile nel formato data/ora
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_printf (NULL, "time = %ld",
+                weechat_infolist_time (infolist, "my_time"));
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+value = weechat.infolist_time(infolist, var)
+
+# esempio
+weechat.prnt("", "time = %ld" % weechat.infolist_time(infolist, "my_time"))
+----------------------------------------
+
+weechat_infolist_free
+^^^^^^^^^^^^^^^^^^^^^
+
+Libera una lista info.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_infolist_free (struct t_infolist *infolist);
+----------------------------------------
+
+Argomenti:
+
+* 'infolist': puntatore alla lista info
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_infolist_free (infolist);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.infolist_free(infolist)
+
+# esempio
+weechat.infolist_free(infolist)
+----------------------------------------
+
+[[upgrade]]
+Upgrade
+~~~~~~~
+
+Funzioni per l'aggiornamento di WeeChat (comando "/upgrade").
+
+weechat_upgrade_new
+^^^^^^^^^^^^^^^^^^^
+
+Crea o legge un file per l'aggiornamento.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_upgrade_file *weechat_upgrade_new (const char *filename, int write);
+----------------------------------------
+
+Argomenti:
+
+* 'filename': nome del file (l'estensione ".upgrade" verrà aggiunta a questo nome
+  da WeeChat)
+* 'write':
+** '1': crea il file (in modalità scrittura, prima dell'aggiornamento)
+** '0': legge il file (dopo l'aggiornamento)
+
+Valore restituito:
+
+* puntatore al file di aggiornamento
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+struct t_upgrade_file *upgrade_file = weechat_upgrade_new ("mio_file", 1);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+upgrade_file = weechat.upgrade_new(filename, write)
+
+# esempio
+upgrade_file = weechat.upgrade_new("mio_file", 1)
+----------------------------------------
+
+weechat_upgrade_write_object
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Scrive un oggetto nel file di aggiornamento.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_upgrade_file *weechat_upgrade_write_object (struct t_upgrade_file *upgrade_file,
+                                                     int object_id,
+                                                     struct t_infolist *infolist);
+----------------------------------------
+
+Argomenti:
+
+* 'upgrade_file': puntatore al file di aggiornamento
+* 'object_id': id per l'oggetto
+* 'infolist': lista info da scrivere nel file
+
+Valore restituito:
+
+* 1 se ok, 0 se errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+if (weechat_upgrade_write_object (upgrade_file, 1, &infolist))
+{
+    /* ok */
+}
+else
+{
+    /* errore */
+}
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.upgrade_write_object(upgrade_file, object_id, infolist)
+
+# esempio
+weechat.upgrade_write_object(upgrade_file, 1, infolist)
+----------------------------------------
+
+weechat_upgrade_read
+^^^^^^^^^^^^^^^^^^^^
+
+Legge un file di aggiornamento.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+struct t_upgrade_file *weechat_upgrade_read (struct t_upgrade_file *upgrade_file,
+                                             int (*callback_read)(void *data,
+                                                                  struct t_upgrade_file *upgrade_file,
+                                                                  int object_id,
+                                                                  struct t_infolist *infolist),
+                                             void *callback_read_data);
+----------------------------------------
+
+Argomenti:
+
+* 'upgrade_file': puntatore al file di aggiornamento
+* 'callback_read': funzione chiamata per ogni oggetto letto nel file
+  di aggiornamento
+* 'callback_read_data': puntatore assegnato per la lettura della chiamata
+  quando chiamato da WeeChat
+
+Valore restituito:
+
+* 1 se ok, 0 se errore
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+int
+my_upgrade_read_cb (struct t_upgrade_file *upgrade_file,
+                    int object_id,
+                    struct t_infolist *infolist)
+{
+    /* read variables... */
+    return WEECHAT_RC_OK;
+}
+
+weechat_upgrade_read (upgrade_file, &my_upgrade_read_cb, NULL);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.upgrade_read(upgrade_file, callback_read, callback_read_data)
+
+# esempio
+def my_upgrade_read_cb(upgrade_file, object_id, infolist):
+    # read variables...
+    return weechat.WEECHAT_RC_OK
+
+weechat.upgrade_read(upgrade_file, "my_upgrade_read_cb", ""))
+----------------------------------------
+
+weechat_upgrade_close
+^^^^^^^^^^^^^^^^^^^^^
+
+Chiude un file di aggiornamento.
+
+Prototipo:
+
+[source,C]
+----------------------------------------
+void weechat_upgrade_close (struct t_upgrade_file *upgrade_file);
+----------------------------------------
+
+Argomenti:
+
+* 'upgrade_file': puntatore al file di aggiornamento
+
+Esempio in C:
+
+[source,C]
+----------------------------------------
+weechat_upgrade_close (upgrade_file);
+----------------------------------------
+
+Script (Python):
+
+[source,python]
+----------------------------------------
+# prototipo
+weechat.upgrade_close(upgrade_file)
+
+# esempio
+weechat.upgrade_close(upgrade_file)
+----------------------------------------