diff options
Diffstat (limited to 'doc/it/weechat_plugin_api.it.txt')
| -rw-r--r-- | doc/it/weechat_plugin_api.it.txt | 3922 |
1 files changed, 1808 insertions, 2114 deletions
diff --git a/doc/it/weechat_plugin_api.it.txt b/doc/it/weechat_plugin_api.it.txt index f3add0bbc..f23c3facb 100644 --- a/doc/it/weechat_plugin_api.it.txt +++ b/doc/it/weechat_plugin_api.it.txt @@ -1,5 +1,4 @@ -Referenze API per Plugin di WeeChat -=================================== += Referenze API per Plugin di WeeChat Sébastien Helleu <flashcode@flashtux.org> @@ -11,8 +10,7 @@ http://weechat.org/doc [[introduction]] -Introduzione ------------- +== Introduzione WeeChat (Wee Enhanced Environment for Chat) è un client di chat libero, veloce e leggero, realizzato per molti sistemi operativi. @@ -21,8 +19,7 @@ Questo manuale documenta le API per i plugin di WeeChat, utilizzate dai plugin C per interagire con il core di WeeChat. [[plugins_in_weechat]] -Plugin in WeeChat ------------------ +== Plugin in WeeChat Un plugin è un programma C che può richiamare le funzioni di WeeChat definite in un'interfaccia. @@ -39,8 +36,7 @@ sorgente di WeeChat). Il file definisce strutture e tipi utilizzati per comunicare con WeeChat. [[macros]] -Macro -~~~~~ +=== Macro Il plugin deve utilizzare alcune macro (per definire alcune variabili): @@ -57,16 +53,14 @@ WEECHAT_PLUGIN_LICENSE("GPL3"):: licenza del plugin [[main_functions]] -Funzioni principali -~~~~~~~~~~~~~~~~~~~ +=== Funzioni principali Il plugin deve usare due funzioni: * weechat_plugin_init * weechat_plugin_end -weechat_plugin_init -^^^^^^^^^^^^^^^^^^^ +==== weechat_plugin_init Questa funzione viene chiamata quando il plugin è caricato. da WeeChat. @@ -74,10 +68,10 @@ da WeeChat. Prototipo: [source,C] ----------------------------------------- +---- int weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[]); ----------------------------------------- +---- Argomenti: @@ -93,8 +87,7 @@ Valori restituiti: * 'WEECHAT_RC_ERROR' se c'è un errore (il plugin NON verrà caricato) -weechat_plugin_end -^^^^^^^^^^^^^^^^^^ +==== weechat_plugin_end Questa funzione viene chiamata quando il plugin viene scaricato da WeeChat. @@ -102,9 +95,9 @@ scaricato da WeeChat. Prototipo: [source,C] ----------------------------------------- +---- int weechat_plugin_end (struct t_weechat_plugin *plugin); ----------------------------------------- +---- Argomenti: @@ -116,22 +109,20 @@ Valori restituiti: * 'WEECHAT_RC_ERROR' se c'è un errore [[compile_plugin]] -Compilazione del 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 -~~~~~~~~~~~~~~~~~~~~~~ +=== Caricamento del plugin Copiare il file 'libtizio.so' nella cartella plugin di sistema (ad esempio '/usr/local/lib/weechat/plugins') oppure nella cartella @@ -139,20 +130,19 @@ plugin dell'utente (ad esempio '/home/xxx/.weechat/plugins'). In WeeChat: ----------------------------------------- +---- /plugin load tizio ----------------------------------------- +---- [[plugin_example]] -Plugin di esempio -~~~~~~~~~~~~~~~~~ +=== 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" @@ -212,11 +202,10 @@ weechat_plugin_end (struct t_weechat_plugin *plugin) return WEECHAT_RC_OK; } ----------------------------------------- +---- [[plugin_api]] -Plugin API ----------- +== Plugin API I capitoli seguenti descrivono le funzioni nelle API, organizzate in categorie. @@ -232,22 +221,20 @@ Per ogni funzione, viene fornita: scripting). [[plugins]] -Plugin -~~~~~~ +=== Plugin Funzioni per ottenere informazioni sui plugin. -weechat_plugin_get_name -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_plugin_get_name Ottiene il nome del plugin. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_plugin_get_name (struct t_weechat_plugin *plugin); ----------------------------------------- +---- Argomenti: @@ -261,32 +248,30 @@ Valore restituito: 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 -~~~~~~~~ +=== Stringhe Molte delle funzioni stringa che seguono sono già disponibili tramite funzioni standard in C, ma si raccomanda di utilizzare le funzioni in questa API perché compatibili con UTF-8 e il locale. -weechat_charset_set -^^^^^^^^^^^^^^^^^^^ +==== 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 @@ -295,9 +280,9 @@ funzione). Prototipo: [source,C] ----------------------------------------- +---- void weechat_charset_set (const char *charset); ----------------------------------------- +---- Argomenti: @@ -306,23 +291,22 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_charset_set ("iso-8859-1"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.charset_set(charset) # esempio weechat.charset_set("iso-8859-1") ----------------------------------------- +---- -weechat_iconv_to_internal -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_iconv_to_internal Converte le stringhe per il set caratteri interno di WeeChat (UTF-8). @@ -330,9 +314,9 @@ WeeChat (UTF-8). Prototipo: [source,C] ----------------------------------------- +---- char *weechat_iconv_to_internal (const char *charset, const char *string); ----------------------------------------- +---- Argomenti: @@ -347,25 +331,24 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *str = weechat_iconv_to_internal ("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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_iconv_from_internal Converte la stringa dal set caratteri interno di WeeChat (UTF-8) in un'altra. @@ -373,9 +356,9 @@ in un'altra. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_iconv_from_internal (const char *charset, const char *string); ----------------------------------------- +---- Argomenti: @@ -390,34 +373,33 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^ +==== weechat_gettext Restituisce la stringa tradotta (dipende dalla lingua). Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_gettext (const char *string); ----------------------------------------- +---- Argomenti: @@ -430,23 +412,22 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^ +==== weechat_ngettext Restituisce la stringa tradotta, utilizzando il singolare o il plurale, in base all'argomento 'count' (contatore). @@ -454,10 +435,10 @@ all'argomento 'count' (contatore). Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_ngettext (const char *string, const char *plural, int count); ----------------------------------------- +---- Argomenti: @@ -473,24 +454,23 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^ +==== weechat_strndup Restituisce una stringa duplicata, con un massimo di caratteri impostato su 'chars'. @@ -498,9 +478,9 @@ impostato su 'chars'. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_strndup (const char *string, int length); ----------------------------------------- +---- Argomenti: @@ -515,26 +495,25 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *str = weechat_strndup ("abcdef", 3); /* result: "abc" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_tolower -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_tolower Converte una stringa UTF-8 in minuscolo. Prototipo: [source,C] ----------------------------------------- +---- void weechat_string_tolower (const char *string); ----------------------------------------- +---- Argomenti: @@ -543,25 +522,24 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- char *str = "AbCdé"; weechat_string_tolower (str); /* str ora è: "abcdé" */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_toupper -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_toupper Converte una stringa UTF-8 in maiuscolo. Prototipo: [source,C] ----------------------------------------- +---- void weechat_string_toupper (const char *string); ----------------------------------------- +---- Argomenti: @@ -570,25 +548,24 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- char *str = "AbCdé"; weechat_string_toupper (str); /* str ora è: "ABCDé" */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_strcasecmp -^^^^^^^^^^^^^^^^^^ +==== weechat_strcasecmp Confronta stringa non sensibile alle maiuscole e alla localizzazione. Prototipo: [source,C] ----------------------------------------- +---- int weechat_strcasecmp (const char *string1, const char *string2); ----------------------------------------- +---- Argomenti: @@ -605,15 +582,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int diff = weechat_strcasecmp ("aaa", "CCC"); /* == -2 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_strcasecmp_range -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_strcasecmp_range Confronta stringa non sensibile alle maiuscole e alla localizzazione, usando una serie per il confronto. @@ -621,9 +597,9 @@ serie per il confronto. Prototipo: [source,C] ----------------------------------------- +---- int weechat_strcasecmp_range (const char *string1, const char *string2, int range); ----------------------------------------- +---- Argomenti: @@ -647,15 +623,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int diff = weechat_strcasecmp ("nick{away}", "NICK[AWAY]"); /* == 0 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_strncasecmp -^^^^^^^^^^^^^^^^^^^ +==== weechat_strncasecmp Confronta stringa indipendente non sensibile alle maiuscole e alla localizzazione, per un numero 'max' di caratteri. @@ -663,9 +638,9 @@ localizzazione, per un numero 'max' di caratteri. Prototipo: [source,C] ----------------------------------------- +---- int weechat_strncasecmp (const char *string1, const char *string2, int max); ----------------------------------------- +---- Argomenti: @@ -683,15 +658,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int diff = weechat_strncasecmp ("aabb", "aacc", 2); /* == 0 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_strncasecmp_range -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_strncasecmp_range Confronta una stringa non sensibile alle maiuscole e alla localizzazione, per un numero 'max' di caratteri, usando una serie per il confronto. @@ -699,9 +673,9 @@ numero 'max' di caratteri, usando una serie per il confronto. Prototipo: [source,C] ----------------------------------------- +---- int weechat_strncasecmp_range (const char *string1, const char *string2, int max, int range); ----------------------------------------- +---- Argomenti: @@ -726,15 +700,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int diff = weechat_strncasecmp_range ("nick{away}", "NICK[away]", 6, 29); /* == 0 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_strcmp_ignore_chars -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_strcmp_ignore_chars Confronta una stringa localizzata (e opzionalmente non sensibile alle maiuscole), ignorando alcuni caratteri. @@ -742,11 +715,11 @@ maiuscole), ignorando alcuni caratteri. Prototipo: [source,C] ----------------------------------------- +---- int weechat_strcmp_ignore_chars (const char *string1, const char *string2, const char *chars_ignored, int case_sensitive); ----------------------------------------- +---- Argomenti: @@ -765,15 +738,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int diff = weechat_strcmp_ignore_chars ("a-b", "--a-e", "-", 1); /* == -3 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_strcasestr -^^^^^^^^^^^^^^^^^^ +==== weechat_strcasestr Cerca una stringa non sensibile alle maiuscole e indipendente dalla localizzazione. @@ -781,9 +753,9 @@ localizzazione. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_strcasestr (const char *string, const char *search); ----------------------------------------- +---- Argomenti: @@ -797,15 +769,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *pos = weechat_strcasestr ("aBcDeF", "de"); /* risultato: puntatore a "DeF" */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_strlen_screen -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_strlen_screen _WeeChat ≥ 0.4.2._ @@ -818,9 +789,9 @@ Non-printable chars have a width of 1 (this is the difference with the function Prototipo: [source,C] ----------------------------------------- +---- int weechat_strlen_screen (const char *string); ----------------------------------------- +---- Argomenti: @@ -834,33 +805,32 @@ su schermo Esempio in C: [source,C] ----------------------------------------- +---- int length_on_screen = weechat_strlen_screen ("é"); /* == 1 */ ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo length = weechat.strlen_screen(string) # esempio length = weechat.strlen_screen("é") # 1 ----------------------------------------- +---- -weechat_string_match -^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -876,17 +846,17 @@ Valore restituito: 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 */ ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo match = weechat.string_match(string, mask, case_sensitive) @@ -895,20 +865,19 @@ match1 = weechat.string_match("abcdef", "abc*", 0) # 1 match2 = weechat.string_match("abcdef", "*dd*", 0) # 0 match3 = weechat.string_match("abcdef", "*def", 0) # 1 match4 = weechat.string_match("abcdef", "*de*", 0) # 1 ----------------------------------------- +---- -weechat_string_replace -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_replace 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: @@ -924,17 +893,16 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *str = weechat_string_replace ("test", "s", "x"); /* result: "text" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_expand_home -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_expand_home _WeeChat ≥ 0.3.3._ @@ -944,9 +912,9 @@ non inizia con `~`, viene restituita la stessa stringa. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_string_expand_home (const char *path); ----------------------------------------- +---- Argomenti: @@ -960,18 +928,17 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *str = weechat_string_expand_home ("~/file.txt"); /* result: "/home/xxx/file.txt" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_remove_quotes -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_remove_quotes Rimuove le virgolette all'inizio e alla fine della stringa (ignora gli spazi se presenti prima delle prime virgolette o dopo le ultime virgolette). @@ -979,9 +946,9 @@ spazi se presenti prima delle prime virgolette o dopo le ultime virgolette). Prototipo: [source,C] ----------------------------------------- +---- char *weechat_string_remove_quotes (const char *string, const char *quotes); ----------------------------------------- +---- Argomenti: @@ -996,28 +963,27 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *str = weechat_string_remove_quotes (string, " 'Non posso' ", "'"); /* risultato: "Non posso" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_strip -^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_strip Rimuove i caratteri ad inizio/fine della stringa. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_string_strip (const char *string, int left, int right, const char *chars); ----------------------------------------- +---- Argomenti: @@ -1033,17 +999,16 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *str = weechat_string_strip (".abc -", 0, 1, "- ."); /* risultato: ".abc" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_mask_to_regex -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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 @@ -1052,9 +1017,9 @@ non vengono riconosciuti. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_string_mask_to_regex (const char *mask); ----------------------------------------- +---- Argomenti: @@ -1068,26 +1033,25 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *str_regex = weechat_string_mask_to_regex ("test*mask"); /* result: "test.*mask" */ /* ... */ free (str_regex); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo regex = weechat.string_mask_to_regex(mask) # esempio regex = weechat.string_mask_to_regex("test*mask") # "test.*mask" ----------------------------------------- +---- -weechat_string_regex_flags -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_regex_flags _WeeChat ≥ 0.3.7._ @@ -1097,9 +1061,9 @@ per compilare l'espressione regolare. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_string_regex_flags (const char *regex, int default_flags, int *flags) ----------------------------------------- +---- Argomenti: @@ -1134,18 +1098,17 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- const char *regex = "(?i)test"; int flags; const char *ptr_regex = weechat_string_regex_flags (regex, REG_EXTENDED, &flags); /* ptr_regex == "test", flags == REG_EXTENDED | REG_ICASE */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_regcomp -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_regcomp _WeeChat ≥ 0.3.7._ @@ -1156,9 +1119,9 @@ Compila un'espressione regolare usando flag opzionali all'inizio della stringa Prototipo: [source,C] ----------------------------------------- +---- int weechat_string_regcomp (void *preg, const char *regex, int default_flags) ----------------------------------------- +---- Argomenti: @@ -1180,19 +1143,18 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- regex_t my_regex; if (weechat_string_regcomp (&my_regex, "(?i)test", REG_EXTENDED) != 0) { /* error */ } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_has_highlight -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_has_highlight Controlla se una stringa ha uno o più eventi, usando la lista di parole per gli eventi. @@ -1200,10 +1162,10 @@ gli eventi. Prototipo: [source,C] ----------------------------------------- +---- int weechat_string_has_highlight (const char *string, const char highlight_words); ----------------------------------------- +---- Argomenti: @@ -1217,34 +1179,33 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int hl = weechat_string_has_highlight ("my test string", "test,word2"); /* == 1 */ ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo highlight = weechat.string_has_highlight(string, highlight_words) # esempio highlight = weechat.string_has_highlight("my test string", "test,word2") # 1 ----------------------------------------- +---- -weechat_string_split -^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1267,7 +1228,7 @@ Valore restituito: Esempi: [source,C] ----------------------------------------- +---- char **argv; int argc; argv = weechat_string_split ("abc de fghi", " ", 0, 0, &argc); @@ -1287,19 +1248,18 @@ argv = weechat_string_split ("abc de fghi", " ", 1, 0, &argc); argc == 3 */ weechat_string_free_split (argv); ----------------------------------------- +---- -weechat_string_free_split -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1309,29 +1269,28 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- char *argv; int argc; argv = weechat_string_split (string, " ", 0, 0, &argc); /* ... */ weechat_string_free_split (argv); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_build_with_split_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1347,7 +1306,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char **argv; int argc; argv = weechat_string_split ("abc def ghi", " ", 0, 0, &argc); @@ -1355,13 +1314,12 @@ char *str = weechat_string_build_with_split_string (argv, ";"); /* str == "abc;def;ghi" */ /* ... */ free (str); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_split_command -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_split_command Divide una lista di comandi separata da 'separator' (che può essere omesso aggiungendo "\" nella stringa). @@ -1369,9 +1327,9 @@ omesso aggiungendo "\" nella stringa). Prototipo: [source,C] ----------------------------------------- +---- char **weechat_string_split_command (const char *command, char separator); ----------------------------------------- +---- Argomenti: @@ -1386,28 +1344,27 @@ Valore restituito: 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); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_free_split_command -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1417,17 +1374,16 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- char **argv = weechat_string_split_command ("/command1 arg;/command2", ';'); /* ... */ weechat_free_split_command (argv); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_format_size -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_format_size Compila una stringa con un file di dimensione fissa ed una unità tradotta nella lingua locale. @@ -1435,9 +1391,9 @@ tradotta nella lingua locale. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_string_format_size (unsigned long long size); ----------------------------------------- +---- Argomenti: @@ -1450,7 +1406,7 @@ Valore restituito: Esempi in C: [source,C] ----------------------------------------- +---- /* esempi in lingua inglese */ char *str = weechat_string_format_size (0); /* str == "0 byte" */ @@ -1468,20 +1424,19 @@ free (str); char *str = weechat_string_format_size (2097152); /* str == "2 MB" */ /* ... */ free (str); ----------------------------------------- +---- -weechat_string_remove_color -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1498,7 +1453,7 @@ Valore restituito: Esempi: [source,C] ----------------------------------------- +---- /* rimuove i codici colore */ char *str = weechat_string_remove_color (my_string1, NULL); /* ... */ @@ -1508,21 +1463,20 @@ free (str); 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, "?") ----------------------------------------- +---- -weechat_string_encode_base64 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_encode_base64 _WeeChat ≥ 0.3.2._ @@ -1531,9 +1485,9 @@ Codifica una stringa in base64. Prototipo: [source,C] ----------------------------------------- +---- void weechat_string_encode_base64 (const char *from, int length, char *to); ----------------------------------------- +---- Argomenti: @@ -1545,17 +1499,16 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- char *string = "abcdefgh", result[128]; weechat_string_encode_base64 (string, strlen (string), result); /* result == "YWJjZGVmZ2g=" */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_decode_base64 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_decode_base64 _WeeChat ≥ 0.3.2._ @@ -1564,9 +1517,9 @@ Decodifica una stringa in base64. Prototipo: [source,C] ----------------------------------------- +---- int weechat_string_decode_base64 (const char *from, char *to); ----------------------------------------- +---- Argomenti: @@ -1581,18 +1534,17 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *string = "YWJjZGVmZ2g=", result[128]; int length; length = weechat_string_decode_base64 (string, result); /* length == 8, result == "abcdefgh" */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_string_is_command_char -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_is_command_char _WeeChat ≥ 0.3.2._ @@ -1602,9 +1554,9 @@ Verifica che il primo carattere della stringa sia un carattere comando Prototipo: [source,C] ----------------------------------------- +---- int weechat_string_is_command_char (const char *string); ----------------------------------------- +---- Argomenti: @@ -1618,25 +1570,24 @@ Valore restituito: Esempi in C: [source,C] ----------------------------------------- +---- int command_char1 = weechat_string_is_command_char ("/test"); /* == 1 */ int command_char2 = weechat_string_is_command_char ("test"); /* == 0 */ ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo is_cmdchar = weechat.string_is_command_char(string) # esempi command_char1 = weechat.string_is_command_char("/test") # == 1 command_char2 = weechat.string_is_command_char("test") # == 0 ----------------------------------------- +---- -weechat_string_input_for_buffer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_input_for_buffer _WeeChat ≥ 0.3.2._ @@ -1646,9 +1597,9 @@ dell'argomento "string"), oppure NULL se è un comando. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_string_input_for_buffer (const char *string); ----------------------------------------- +---- Argomenti: @@ -1661,16 +1612,16 @@ Valore restituito: Esempi in C: [source,C] ----------------------------------------- +---- const char *str1 = weechat_string_input_for_buffer ("test"); /* "test" */ const char *str2 = weechat_string_input_for_buffer ("/test"); /* NULL */ const char *str3 = weechat_string_input_for_buffer ("//test"); /* "/test" */ ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo str = weechat.string_input_for_buffer(string) @@ -1678,10 +1629,9 @@ str = weechat.string_input_for_buffer(string) str1 = weechat.string_input_for_buffer("test") # "test" str2 = weechat.string_input_for_buffer("/test") # "" str3 = weechat.string_input_for_buffer("//test") # "/test" ----------------------------------------- +---- -weechat_string_eval_expression -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_string_eval_expression // TRANSLATION MISSING _WeeChat ≥ 0.4.0, updated in 0.4.2._ @@ -1694,12 +1644,12 @@ Special variables with format `${variable}` are expanded (see command `/eval` in Prototipo: [source,C] ----------------------------------------- +---- char *weechat_string_eval_expression (const char *expr, struct t_hashtable *pointers, struct t_hashtable *extra_vars, struct t_hashtable *options); ----------------------------------------- +---- Argomenti: @@ -1727,7 +1677,7 @@ Valore restituito: Esempi in C: [source,C] ----------------------------------------- +---- struct t_hashtable *options = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, @@ -1738,12 +1688,12 @@ if (options) char *str1 = weechat_string_eval_expression ("${buffer.full_name}", NULL, NULL, NULL); /* "core.weechat" */ char *str2 = weechat_string_eval_expression ("${window.win_width} > 100", NULL, NULL, options); /* "1" */ char *str3 = weechat_string_eval_expression ("abc =~ def", NULL, NULL, options); /* "0" */ ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo str = weechat.string_eval_expression(expr, pointers, extra_vars, options) @@ -1751,25 +1701,23 @@ str = weechat.string_eval_expression(expr, pointers, extra_vars, options) str1 = weechat.string_eval_expression("${buffer.full_name}", {}, {}, {}) # "core.weechat" str2 = weechat.string_eval_expression("${window.win_width} > 100", {}, {}, {"type": "condition"}) # "1" str3 = weechat.string_eval_expression("abc =~ def", {}, {}, {"type": "condition"}) # "0" ----------------------------------------- +---- [[utf-8]] -UTF-8 -~~~~~ +=== UTF-8 Alcune funzioni stringa UTF-8. -weechat_utf8_has_8bits -^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1782,27 +1730,26 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_utf8_has_8bits (string)) { /* ... */ } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_is_valid -^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1817,7 +1764,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *error; if (weechat_utf8_is_valid (string, &error)) { @@ -1827,13 +1774,12 @@ else { /* "error" punta al primo carattere non valido */ } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_normalize -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_normalize Normalizza le stringhe UTF-8: rimuove i caratteri non UTF-8 e li sostituisce con un carattere. @@ -1841,9 +1787,9 @@ un carattere. Prototipo: [source,C] ----------------------------------------- +---- void weechat_utf8_normalize (char *string, char replacement); ----------------------------------------- +---- Argomenti: @@ -1853,24 +1799,23 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_utf8_normalize (string, '?'); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_prev_char -^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1886,24 +1831,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *prev_char = weechat_utf8_prev_char (string, ptr_in_string); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_next_char -^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1917,24 +1861,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *next_char = weechat_utf8_next_char (string); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_char_int -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_char_int Restituisce un carattere UTF-8 come intero. Prototipo: [source,C] ----------------------------------------- +---- int weechat_utf8_char_int (const char *string); ----------------------------------------- +---- Argomenti: @@ -1947,24 +1890,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int char_int = weechat_utf8_char_int ("être"); /* "ê" come intero */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_char_size -^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -1977,24 +1919,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int char_size = weechat_utf8_char_size ("être"); /* == 2 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_strlen -^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -2007,15 +1948,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int length = weechat_utf8_strlen ("chêne"); /* == 5 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_strnlen -^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_strnlen Restituisce la lunghezza della stringa UTF-8 (in caratteri UTF-8), per un massimo di 'bytes' nella stringa. @@ -2023,9 +1963,9 @@ un massimo di 'bytes' nella stringa. Prototipo: [source,C] ----------------------------------------- +---- int weechat_utf8_strnlen (const char *string, int bytes); ----------------------------------------- +---- Argomenti: @@ -2039,15 +1979,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int length = weechat_utf8_strnlen ("chêne", 4); /* == 3 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_strlen_screen -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_strlen_screen Restituisce il numero di caratteri necessari per visualizzare la stringa UTF-8 su schermo. @@ -2055,9 +1994,9 @@ UTF-8 su schermo. Prototipo: [source,C] ----------------------------------------- +---- int weechat_utf8_strlen_screen (const char *string); ----------------------------------------- +---- Argomenti: @@ -2071,24 +2010,23 @@ su schermo Esempio in C: [source,C] ----------------------------------------- +---- int length_on_screen = weechat_utf8_strlen_screen ("é"); /* == 1 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_charcmp -^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_charcmp Confronta due caratteri UTF-8. Prototipo: [source,C] ----------------------------------------- +---- int weechat_utf8_charcmp (const char *string1, const char *string2); ----------------------------------------- +---- Argomenti: @@ -2105,24 +2043,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int diff = weechat_utf8_charcmp ("aaa", "ccc"); /* == -2 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_charcasecmp -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_charcasecmp Confronta due caratteri UTF-8, ignorando la sensibilità alle maiuscole. Prototipo: [source,C] ----------------------------------------- +---- int weechat_utf8_charcasecmp (const char *string1, const char *string2); ----------------------------------------- +---- Argomenti: @@ -2139,15 +2076,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int diff = weechat_utf8_charcasecmp ("aaa", "CCC"); /* == -2 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_char_size_screen -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_char_size_screen Restituisce il numero di caratteri necessari per visualizzare il carattere UTF-8 sullo schermo. @@ -2155,9 +2091,9 @@ carattere UTF-8 sullo schermo. Prototipo: [source,C] ----------------------------------------- +---- int weechat_utf8_char_size_screen (const char *string); ----------------------------------------- +---- Argomenti: @@ -2171,24 +2107,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int length_on_screen = weechat_utf8_char_size_screen ("é"); /* == 1 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_add_offset -^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -2202,25 +2137,24 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *str = "chêne"; char *str2 = weechat_utf8_add_offset (str, 3); /* points to "ne" */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_real_pos -^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -2234,24 +2168,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int pos = weechat_utf8_real_pos ("chêne", 3); /* == 4 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_pos -^^^^^^^^^^^^^^^^ +==== weechat_utf8_pos Restituisce la posizione nella stringa UTF-8. Prototipo: [source,C] ----------------------------------------- +---- int weechat_utf8_pos (const char *string, int real_pos); ----------------------------------------- +---- Argomenti: @@ -2265,24 +2198,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int pos = weechat_utf8_pos ("chêne", 4); /* == 3 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_utf8_strndup -^^^^^^^^^^^^^^^^^^^^ +==== weechat_utf8_strndup Restituisce la stringa duplicata, di lunghezza massima 'lenght'. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_utf8_strndup (const char *string, int length); ----------------------------------------- +---- Argomenti: @@ -2296,32 +2228,30 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *string = weechat_utf8_strndup ("chêne", 3); /* restituisce "chê" */ /* ... */ free (string); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. [[directories]] -Cartelle -~~~~~~~~ +=== Cartelle Alcune funzioni legate alle cartelle. -weechat_mkdir_home -^^^^^^^^^^^^^^^^^^ +==== weechat_mkdir_home Crea una cartella nella home di WeeChat. Prototipo: [source,C] ----------------------------------------- +---- int weechat_mkdir_home (char *directory, int mode); ----------------------------------------- +---- Argomenti: @@ -2335,35 +2265,34 @@ Valore restituito: 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 -^^^^^^^^^^^^^ +==== weechat_mkdir Crea una cartella. Prototipo: [source,C] ----------------------------------------- +---- int weechat_mkdir (char *directory, int mode); ----------------------------------------- +---- Argomenti: @@ -2377,35 +2306,34 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_mkdir_parents Crea una cartella e le cartelle genitore se necessario. Prototipo: [source,C] ----------------------------------------- +---- int weechat_mkdir_parents (char *directory, int mode); ----------------------------------------- +---- Argomenti: @@ -2419,39 +2347,38 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (!weechat_mkdir_parents ("/tmp/my/dir", 0755)) { /* errore */ } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.mkdir_parents(directory, mode) # esempio weechat.mkdir_parents("/tmp/my/dir", 0755) ----------------------------------------- +---- -weechat_exec_on_files -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_exec_on_files Cerca i file in una cartella ed esegue una 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: @@ -2465,20 +2392,19 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- void callback (void *data, const char *filename) { /* ... */ } ... weechat_exec_on_files ("/tmp", 0, NULL, &callback); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_file_get_content -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_file_get_content _WeeChat ≥ 0.3.1._ @@ -2487,9 +2413,9 @@ Ottiene il contenuto del file di testo in una stringa. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_file_get_content (const char *filename); ----------------------------------------- +---- Argomenti: @@ -2503,34 +2429,32 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *content; content = weechat_file_get_content ("/tmp/test.txt"); /* ... */ free (content); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. [[util]] -Utilità -~~~~~~~ +=== Utilità Alcune funzioni utili. -weechat_util_timeval_cmp -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_timeval_cmp Confronta due strutture "timeval". Prototipo: [source,C] ----------------------------------------- +---- int weechat_util_timeval_cmp (struct timeval *tv1, struct timeval *tv2); ----------------------------------------- +---- Argomenti: @@ -2546,27 +2470,26 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_util_timeval_cmp (&tv1, &tv2) > 0) { /* tv1 > tv2 */ } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_util_timeval_diff -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_timeval_diff Restituisce la differenza (in millisecondi) tra due strutture "timeval". Prototipo: [source,C] ----------------------------------------- +---- long weechat_util_timeval_diff (struct timeval *tv1, struct timeval *tv2); ----------------------------------------- +---- Argomenti: @@ -2580,24 +2503,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- long diff = weechat_util_timeval_diff (&tv1, &tv2); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_util_timeval_add -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_timeval_add Aggiungi intervallo (in millisecondi) ad una struttura timeval. Prototipo: [source,C] ----------------------------------------- +---- void weechat_util_timeval_add (struct timeval *tv, long interval); ----------------------------------------- +---- Argomenti: @@ -2607,15 +2529,14 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_util_timeval_add (&tv, 2000); /* aggiunge 2 secondi */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_util_get_time_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_get_time_string _WeeChat ≥ 0.3.2._ @@ -2624,9 +2545,9 @@ Riceve data/ora come stringa compilata con "strftime". Prototipo: [source,C] ----------------------------------------- +---- char *weechat_util_get_time_string (const time_t *date); ----------------------------------------- +---- Argomenti: @@ -2635,17 +2556,16 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- time_t date = time (NULL); weechat_printf (NULL, "date: %s", weechat_util_get_time_string (&date)); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_util_version_number -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_util_version_number _WeeChat ≥ 0.3.9._ @@ -2655,9 +2575,9 @@ Convert a string with WeeChat version to a number. Prototipo: [source,C] ----------------------------------------- +---- int weechat_util_version_number (const char *version); ----------------------------------------- +---- Argomenti: @@ -2667,33 +2587,31 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- version_number = weechat_util_version_number ("0.3.8"); /* == 0x00030800 */ version_number = weechat_util_version_number ("0.3.9-dev"); /* == 0x00030900 */ version_number = weechat_util_version_number ("0.3.9-rc1"); /* == 0x00030900 */ version_number = weechat_util_version_number ("0.3.9"); /* == 0x00030900 */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. [[sorted_lists]] -Elenchi ordinati -~~~~~~~~~~~~~~~~ +=== Elenchi ordinati Funzioni lista ordinata. -weechat_list_new -^^^^^^^^^^^^^^^^ +==== weechat_list_new Crea una nuova lista. Prototipo: [source,C] ----------------------------------------- +---- struct t_weelist *weechat_list_new (); ----------------------------------------- +---- Valore restituito: @@ -2702,35 +2620,34 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^ +==== 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: @@ -2749,34 +2666,33 @@ Valore restituito: 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, "my data", weechat.WEECHAT_LIST_POS_SORT, "") ----------------------------------------- +---- -weechat_list_search -^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -2790,23 +2706,22 @@ Valore restituito: 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, "my data") ----------------------------------------- +---- -weechat_list_search_pos -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_list_search_pos _WeeChat ≥ 0.3.4._ @@ -2815,10 +2730,10 @@ Cerca la posizione di un elemento nella lista. Prototipo: [source,C] ----------------------------------------- +---- int weechat_list_search_pos (struct t_weelist *weelist, const char *data); ----------------------------------------- +---- Argomenti: @@ -2832,23 +2747,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int pos_item = weechat_list_search_pos (list, "my data"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo pos_item = weechat.list_search_pos(list, data) # esempio pos_item = weechat.list_search_pos(list, "my data") ----------------------------------------- +---- -weechat_list_casesearch -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_list_casesearch Cerca un elemento nella lista, senza effettuare una ricerca esatta. @@ -2856,10 +2770,10 @@ esatta. Prototipo: [source,C] ----------------------------------------- +---- struct t_weelist_item *weechat_list_casesearch (struct t_weelist *weelist, const char *data); ----------------------------------------- +---- Argomenti: @@ -2873,23 +2787,22 @@ Valore restituito: 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_casesearch_pos -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_list_casesearch_pos _WeeChat ≥ 0.3.4._ @@ -2898,10 +2811,10 @@ Cerca la posizione di un elemento in una lista, ricerca normale. Prototipo: [source,C] ----------------------------------------- +---- int weechat_list_casesearch_pos (struct t_weelist *weelist, const char *data); ----------------------------------------- +---- Argomenti: @@ -2915,33 +2828,32 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int pos_item = weechat_list_casesearch_pos (list, "my data"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo pos_item = weechat.list_casesearch_pos(list, data) # esempio pos_item = weechat.list_casesearch_pos(list, "my data") ----------------------------------------- +---- -weechat_list_get -^^^^^^^^^^^^^^^^ +==== weechat_list_get Restituisce un elemento in una lista in base alla sua posizione. Prototipo: [source,C] ----------------------------------------- +---- struct t_weelist_item *weechat_list_get (struct t_weelist *weelist, int position); ----------------------------------------- +---- Argomenti: @@ -2955,32 +2867,31 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_weelist_item *item = weechat_list_get (list, 0); /* primo elemento */ ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo item = weechat.list_get(list, position) # esempio item = weechat.list_get(list, 0) ----------------------------------------- +---- -weechat_list_set -^^^^^^^^^^^^^^^^ +==== 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: @@ -2990,32 +2901,31 @@ Argomenti: 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, "nuovi dati") ----------------------------------------- +---- -weechat_list_next -^^^^^^^^^^^^^^^^^ +==== 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: @@ -3029,32 +2939,31 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^ +==== 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: @@ -3068,32 +2977,31 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^ +==== weechat_list_string Restituisce il valore stringa di un elemento. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_list_string (struct t_weelist_item *item); ----------------------------------------- +---- Argomenti: @@ -3106,32 +3014,31 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "valore dell'elemento: %s", weechat_list_string (item)); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.list_string(item) # esempio weechat.prnt("", "valore dell'elemento: %s" % weechat.list_string(item)) ----------------------------------------- +---- -weechat_list_size -^^^^^^^^^^^^^^^^^ +==== weechat_list_size Restituisce la dimensione della lista (numero di elementi). Prototipo: [source,C] ----------------------------------------- +---- char *weechat_list_size (struct t_weelist *weelist); ----------------------------------------- +---- Argomenti: @@ -3145,33 +3052,32 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "dimensione della lista: %d", weechat_list_size (list)); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo size = weechat.list_size(list) # esempio weechat.prnt("", "dimensione della lista: %d" % weechat.list_size(list)) ----------------------------------------- +---- -weechat_list_remove -^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -3181,32 +3087,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_list_remove_all Rimuove tutti gli elementi in una lista. Prototipo: [source,C] ----------------------------------------- +---- void weechat_list_remove_all (struct t_weelist *weelist); ----------------------------------------- +---- Argomenti: @@ -3215,32 +3120,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^ +==== weechat_list_free Libera una lista. Prototipo: [source,C] ----------------------------------------- +---- void weechat_list_free (struct t_weelist *weelist); ----------------------------------------- +---- Argomenti: @@ -3249,29 +3153,27 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_list_free (list); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.list_free(list) # esempio weechat.list_free(list) ----------------------------------------- +---- [[hashtables]] -Tabelle hash -~~~~~~~~~~~~ +=== Tabelle hash Funzioni per le tabelle hash. -weechat_hashtable_new -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_new _WeeChat ≥ 0.3.3._ @@ -3280,7 +3182,7 @@ Crea una nuova tabella hash. Prototipo: [source,C] ----------------------------------------- +---- struct t_hashtable *weechat_hashtable_new (int size, const char *type_keys, const char *type_values, @@ -3289,7 +3191,7 @@ struct t_hashtable *weechat_hashtable_new (int size, int (*callback_keycmp)(struct t_hashtable *hashtable, const void *key1, const void *key2)); ----------------------------------------- +---- Argomenti: @@ -3334,19 +3236,18 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hashtable *hashtable = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, NULL, NULL); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_set_with_size -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_set_with_size // TRANSLATION MISSING _WeeChat ≥ 0.3.3, updated in 0.4.2._ @@ -3357,11 +3258,11 @@ chiave ed il valore. Prototipo: [source,C] ----------------------------------------- +---- struct t_hashtable_item *weechat_hashtable_set_with_size (struct t_hashtable *hashtable, const void *key, int key_size, const void *value, int value_size); ----------------------------------------- +---- Argomenti: @@ -3381,16 +3282,15 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_hashtable_set_with_size (hashtable, "my_key", 0, my_buffer, sizeof (my_buffer_struct)); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_set -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_set // TRANSLATION MISSING _WeeChat ≥ 0.3.3, updated in 0.4.2._ @@ -3400,10 +3300,10 @@ Aggiunge o aggiorna un elemento nella tabella hash. Prototipo: [source,C] ----------------------------------------- +---- struct t_hashtable_item *weechat_hashtable_set (struct t_hashtable *hashtable, const void *key, const void *value); ----------------------------------------- +---- Argomenti: @@ -3419,12 +3319,11 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_hashtable_set (hashtable, "my_key", "my_value"); ----------------------------------------- +---- -weechat_hashtable_get -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_get _WeeChat ≥ 0.3.3._ @@ -3433,9 +3332,9 @@ Ottiene il valore associato ad una chiave in una tabella hash. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_hashtable_get (struct t_hashtable *hashtable, void *key); ----------------------------------------- +---- Argomenti: @@ -3449,15 +3348,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- void *value = weechat_hashtable_get (hashtable, "my_key"); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_has_key -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_has_key _WeeChat ≥ 0.3.4._ @@ -3466,9 +3364,9 @@ Restituisce 1 se la tabella hash ha una chiave, altrimenti 0. Prototipo: [source,C] ----------------------------------------- +---- int weechat_hashtable_has_key (struct t_hashtable *hashtable, void *key); ----------------------------------------- +---- Argomenti: @@ -3482,19 +3380,18 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_hashtable_has_key (hashtable, "my_key")) { /* la chiave è nella tabella hash */ /* ... */ } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_map -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_map _WeeChat ≥ 0.3.3._ @@ -3503,14 +3400,14 @@ Chiama una funzione su tutte le voci della tabella hash. Prototipo: [source,C] ----------------------------------------- +---- void hashtable_map (struct t_hashtable *hashtable, void (*callback_map)(void *data, struct t_hashtable *hashtable, const void *key, const void *value), void *callback_map_data); ----------------------------------------- +---- Argomenti: @@ -3521,7 +3418,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- void map_cb (void *data, struct t_hashtable *hashtable, const void *key, const void *value) @@ -3533,13 +3430,12 @@ map_cb (void *data, struct t_hashtable *hashtable, } /* ... */ weechat_hashtable_map (hashtable, &map_cb, NULL); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_map_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_map_string _WeeChat ≥ 0.3.7._ @@ -3549,14 +3445,14 @@ valori come stringhe. Prototipo: [source,C] ----------------------------------------- +---- void hashtable_map_string (struct t_hashtable *hashtable, void (*callback_map)(void *data, struct t_hashtable *hashtable, const char *key, const char *value), void *callback_map_data); ----------------------------------------- +---- Argomenti: @@ -3571,7 +3467,7 @@ eliminate dopo la chiamata alla callback. Esempio in C: [source,C] ----------------------------------------- +---- void map_cb (void *data, struct t_hashtable *hashtable, const char *key, const char *value) @@ -3582,13 +3478,12 @@ map_cb (void *data, struct t_hashtable *hashtable, } /* ... */ weechat_hashtable_map_string (hashtable, &map_cb, NULL); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_get_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_get_integer _WeeChat ≥ 0.3.3._ @@ -3597,10 +3492,10 @@ Restituisce un valore intero per la proprietà di una tabella hash. Prototipo: [source,C] ----------------------------------------- +---- int weechat_hashtable_get_integer (struct t_hashtable *hashtable, void *property); ----------------------------------------- +---- Argomenti: @@ -3616,15 +3511,14 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int items_count = weechat_hashtable_get_integer (hashtable, "items_count"); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_get_string _WeeChat ≥ 0.3.4._ @@ -3633,10 +3527,10 @@ Restituisce il valore stringa della proprietà di una tabella hash. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_hashtable_get_string (struct t_hashtable *hashtable, const char *property); ----------------------------------------- +---- Argomenti: @@ -3669,18 +3563,17 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "keys are type: %s", weechat_hashtable_get_string (hashtable, "type_keys")); weechat_printf (NULL, "list of keys: %s", weechat_hashtable_get_string (hashtable, "keys")); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_set_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_set_pointer _WeeChat ≥ 0.3.4._ @@ -3689,10 +3582,10 @@ Imposta il valore puntatore della proprietà di una tabella hash. Prototipo: [source,C] ----------------------------------------- +---- void weechat_hashtable_set_pointer (struct t_hashtable *hashtable, const char *property, void *pointer); ----------------------------------------- +---- Argomenti: @@ -3707,7 +3600,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- void my_free_value_cb (struct t_hashtable *hashtable, const void *key, void *value) { @@ -3715,13 +3608,12 @@ my_free_value_cb (struct t_hashtable *hashtable, const void *key, void *value) } weechat_hashtable_set_pointer (hashtable, "callback_free_value", &my_free_value_cb); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_add_to_infolist -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_add_to_infolist _WeeChat ≥ 0.3.3._ @@ -3730,11 +3622,11 @@ Aggiunge elementi della tabella hash ad un elemento della lista info. Prototipo: [source,C] ----------------------------------------- +---- int weechat_hashtable_add_to_infolist (struct t_hashtable *hashtable, struct t_infolist_item *infolist_item, const char *prefix); ----------------------------------------- +---- Argomenti: @@ -3749,7 +3641,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_hashtable_add_to_infolist (hashtable, infolist_item, "testhash"); /* se la tabella hash contiene: @@ -3761,13 +3653,12 @@ weechat_hashtable_add_to_infolist (hashtable, infolist_item, "testhash"); "testhash_name_00001" = "key2" "testhash_value_00001" = "value 2" */ ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_remove -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_remove _WeeChat ≥ 0.3.3._ @@ -3776,9 +3667,9 @@ Rimuove un elemento in una tabella hash. Prototipo: [source,C] ----------------------------------------- +---- void weechat_hashtable_remove (struct t_hashtable *hashtable, const void *key); ----------------------------------------- +---- Argomenti: @@ -3788,15 +3679,14 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_hashtable_remove (hashtable, "my_key"); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_remove_all -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_remove_all _WeeChat ≥ 0.3.3._ @@ -3805,9 +3695,9 @@ Rimuove tutti gli elementi in una tabella hash. Prototipo: [source,C] ----------------------------------------- +---- void weechat_hashtable_remove_all (struct t_hashtable *hashtable); ----------------------------------------- +---- Argomenti: @@ -3816,15 +3706,14 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_hashtable_remove_all (hashtable); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hashtable_free -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hashtable_free _WeeChat ≥ 0.3.3._ @@ -3833,9 +3722,9 @@ Libera una tabella hash. Prototipo: [source,C] ----------------------------------------- +---- void weechat_hashtable_free (struct t_hashtable *hashtable); ----------------------------------------- +---- Argomenti: @@ -3844,33 +3733,31 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_hashtable_free (hashtable); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. [[configuration_files]] -File di configurazione -~~~~~~~~~~~~~~~~~~~~~~ +=== File di configurazione Funzioni per i file di configurazione. -weechat_config_new -^^^^^^^^^^^^^^^^^^ +==== 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: @@ -3901,7 +3788,7 @@ opzioni (con <<_weechat_config_new_option,weechat_config_new_option>>). Esempio in C: [source,C] ----------------------------------------- +---- int my_config_reload_cb (void *data, struct t_config_file *config_file) { @@ -3913,12 +3800,12 @@ my_config_reload_cb (void *data, struct t_config_file *config_file) struct t_config_file *config_file = weechat_config_new ("test", &my_config_reload_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo config_file = weechat.config_new(name, calback_reload, callback_reload_data) @@ -3928,17 +3815,16 @@ def my_config_reload_cb(data, config_file): return weechat.WEECHAT_RC_OK config_file = weechat.config_new("test", "my_config_reload_cb", "") ----------------------------------------- +---- -weechat_config_new_section -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_new_section 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, @@ -3969,7 +3855,7 @@ struct t_config_section *weechat_config_new_section ( struct t_config_section *section, struct t_config_option *option), void *callback_delete_option_data); ----------------------------------------- +---- Argomenti: @@ -4052,7 +3938,7 @@ Valore restituito: 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, @@ -4126,12 +4012,12 @@ struct t_config_section *new_section2 = &my_section_write_default_cb, NULL, &my_section_create_option_cb, NULL, &my_section_delete_option_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo section = weechat.config_new_section(config_file, name, user_can_add_options, user_can_delete_options, @@ -4170,21 +4056,20 @@ section = weechat.config_new_section(config_file, "section1", 1, 1, "my_section_write_default_cb", "", "my_section_create_option_cb", "", "my_section_delete_option_cb", "") ----------------------------------------- +---- -weechat_config_search_section -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_search_section 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: @@ -4198,31 +4083,30 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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, @@ -4245,7 +4129,7 @@ struct t_config_option *weechat_config_new_option ( void (*callback_delete)(void *data, struct t_config_option *option), void *callback_delete_data); ----------------------------------------- +---- Argomenti: @@ -4296,7 +4180,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- /* booleano */ struct t_config_option *option1 = weechat_config_new_option (config_file, section, "option1", "boolean", @@ -4361,12 +4245,12 @@ struct t_config_option *option5 = 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, @@ -4421,7 +4305,7 @@ option5 = weechat.config_new_option(config_file, section, "option5", "color", "", "", "", "", "", "") ----------------------------------------- +---- // TRANSLATION MISSING [NOTE] @@ -4429,20 +4313,19 @@ In Ruby, the 3 callbacks + data (6 strings) must be given in an array of 6 strings (due to a Ruby limitation of 15 arguments by function), see the 'WeeChat Scripting Guide' for more info _(fixed in version 0.4.1)_. -weechat_config_search_option -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -4457,37 +4340,36 @@ Valore restituito: 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_section_option -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_search_section_option Cerca una sezione ed un'opzione in un file di configurazione o sezione. Prototipo: [source,C] ----------------------------------------- +---- void weechat_config_search_section_option (struct t_config_file *config_file, struct t_config_section *section, const char *option_name, struct t_config_section **section_found, struct t_config_option **option_found); ----------------------------------------- +---- Argomenti: @@ -4502,7 +4384,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_section *ptr_section; struct t_config_option *ptr_option; @@ -4519,26 +4401,25 @@ else { /* opzione non trovata */ } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_config_search_with_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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, char **pos_option_name); ----------------------------------------- +---- Argomenti: @@ -4556,7 +4437,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_file *ptr_config_file; struct t_config_section *ptr_section; struct t_config_option *ptr_option; @@ -4575,22 +4456,21 @@ else { /* opzione non trovata */ } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_config_string_to_boolean -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -4604,7 +4484,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_config_string_to_boolean (option_value)) { /* il valore è "true" */ @@ -4613,32 +4493,31 @@ 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -4657,7 +4536,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- switch (weechat_config_option_reset (option, 1)) { case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED: @@ -4670,12 +4549,12 @@ switch (weechat_config_option_reset (option, 1)) /* .... */ break; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.config_option_reset(option, run_callback) @@ -4687,20 +4566,19 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR: # ... ----------------------------------------- +---- -weechat_config_option_set -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_set 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: @@ -4719,7 +4597,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- switch (weechat_config_option_set (option, "new_value", 1)) { case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED: @@ -4732,12 +4610,12 @@ switch (weechat_config_option_set (option, "new_value", 1)) /* .... */ break; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.config_option_set(option, value, run_callback) @@ -4749,20 +4627,19 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR: # ... ----------------------------------------- +---- -weechat_config_option_set_null -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_set_null 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: @@ -4784,7 +4661,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- switch (weechat_config_option_set_null (option, 1)) { case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED: @@ -4797,12 +4674,12 @@ switch (weechat_config_option_set_null (option, 1)) /* .... */ break; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.config_option_set_null(option, run_callback) @@ -4814,19 +4691,18 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR: # ... ----------------------------------------- +---- -weechat_config_option_unset -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_unset Rimuove/ripristina un'opzione. Prototipo: [source,C] ----------------------------------------- +---- int weechat_config_option_unset (struct t_config_option *option); ----------------------------------------- +---- Argomenti: @@ -4844,7 +4720,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- switch (weechat_config_option_unset (option)) { case WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET: @@ -4860,12 +4736,12 @@ switch (weechat_config_option_unset (option)) /* .... */ break; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.config_option_unset(option) @@ -4879,20 +4755,19 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_ERROR: # ... ----------------------------------------- +---- -weechat_config_option_rename -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_rename Rinomina un'opzione. Prototipo: [source,C] ----------------------------------------- +---- void weechat_config_option_rename (struct t_config_option *option, const char *new_name); ----------------------------------------- +---- Argomenti: @@ -4902,33 +4777,32 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -4954,24 +4828,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char *description = weechat_config_option_get_pointer (option, "description"); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_config_option_is_null -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -4985,7 +4858,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_config_option_is_null (option)) { /* il valore è "null" */ @@ -4994,31 +4867,30 @@ 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -5032,7 +4904,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_config_option_default_is_null (option)) { /* il valore predefinito è "null" */ @@ -5041,31 +4913,30 @@ 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 -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_boolean Restituisce il valore bool di un'opzione. Prototipo: [source,C] ----------------------------------------- +---- int weechat_config_boolean (struct t_config_option *option); ----------------------------------------- +---- Argomenti: @@ -5078,7 +4949,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); if (weechat_config_boolean (option)) { @@ -5088,12 +4959,12 @@ else { /* il valore è "false" */ } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.config_boolean(option) @@ -5101,19 +4972,18 @@ value = weechat.config_boolean(option) option = weechat.config_get("plugin.section.option") if weechat.config_boolean(option): # ... ----------------------------------------- +---- -weechat_config_boolean_default -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_boolean_default Restituisce il valore bool predefinito di un'opzione. Prototipo: [source,C] ----------------------------------------- +---- int weechat_config_boolean_default (struct t_config_option *option); ----------------------------------------- +---- Argomenti: @@ -5126,7 +4996,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); if (weechat_config_boolean_default (option)) { @@ -5136,12 +5006,12 @@ else { /* il valore è "false" */ } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.config_boolean_default(option) @@ -5149,19 +5019,18 @@ value = weechat.config_boolean_default(option) option = weechat.config_get("plugin.section.option") if weechat.config_boolean_default(option): # ... ----------------------------------------- +---- -weechat_config_integer -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_integer Restituisce il valore intero di un'opzione. Prototipo: [source,C] ----------------------------------------- +---- int weechat_config_integer (struct t_config_option *option); ----------------------------------------- +---- Argomenti: @@ -5174,34 +5043,33 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); int value = weechat_config_integer (option); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.config_integer(option) # esempio option = weechat.config_get("plugin.section.option") value = weechat.config_integer(option) ----------------------------------------- +---- -weechat_config_integer_default -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -5214,34 +5082,33 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); int value = weechat_config_integer_default (option); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.config_integer_default(option) # esempio option = weechat.config_get("plugin.section.option") value = weechat.config_integer_default(option) ----------------------------------------- +---- -weechat_config_string -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_string Restituisce il valore stringa di un'opzione. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_config_string (struct t_config_option *option); ----------------------------------------- +---- Argomenti: @@ -5254,34 +5121,33 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); const char *value = weechat_config_string (option); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.config_string(option) # esempio option = weechat.config_get("plugin.section.option") value = weechat.config_string(option) ----------------------------------------- +---- -weechat_config_string_default -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_string_default Restituisce il valore stringa predefinito di un'opzione. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_config_string_default (struct t_config_option *option); ----------------------------------------- +---- Argomenti: @@ -5294,34 +5160,33 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); const char *value = weechat_config_string_default (option); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.config_string_default(option) # esempio option = weechat.config_get("plugin.section.option") value = weechat.config_string_default(option) ----------------------------------------- +---- -weechat_config_color -^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_color Restituisce il valore colore di un'opzione. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_config_color (struct t_config_option *option); ----------------------------------------- +---- Argomenti: @@ -5334,34 +5199,33 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); const char *color = weechat_config_color (option); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.config_color(option) # esempio option = weechat.config_get("plugin.section.option") value = weechat.config_color(option) ----------------------------------------- +---- -weechat_config_color_default -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -5374,25 +5238,24 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_config_option *option = weechat_config_get ("plugin.section.option"); const char *color = weechat_config_color_default (option); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.config_color_default(option) # esempio option = weechat.config_get("plugin.section.option") value = weechat.config_color_default(option) ----------------------------------------- +---- -weechat_config_write_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" @@ -5401,10 +5264,10 @@ 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: @@ -5414,7 +5277,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- int my_section_write_cb (void *data, struct t_config_file *config_file, const char *section_name) @@ -5425,12 +5288,12 @@ my_section_write_cb (void *data, struct t_config_file *config_file, return WEECHAT_RC_OK; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.config_write_option(config_file, option) @@ -5439,10 +5302,9 @@ 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 -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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 @@ -5451,11 +5313,11 @@ sezione). Prototipo: [source,C] ----------------------------------------- +---- void weechat_config_write_line (struct t_config_file *config_file, const char *option_name, const char *value, ...); ----------------------------------------- +---- Argomenti: @@ -5467,7 +5329,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- int my_section_write_cb (void *data, struct t_config_file *config_file, const char *section_name) @@ -5479,12 +5341,12 @@ my_section_write_cb (void *data, struct t_config_file *config_file, return WEECHAT_RC_OK; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.config_write_line(config_file, option_name, value) @@ -5493,19 +5355,18 @@ 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 -^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_write Scrive il file di configurazione su disco. Prototipo: [source,C] ----------------------------------------- +---- int weechat_config_write (struct t_config_file *config_file); ----------------------------------------- +---- Argomenti: @@ -5520,7 +5381,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- switch (weechat_config_write (config_file)) { case WEECHAT_CONFIG_WRITE_OK: @@ -5533,12 +5394,12 @@ switch (weechat_config_write (config_file)) /* ... */ break; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.config_write(config_file) @@ -5550,19 +5411,18 @@ elif rc == weechat.WEECHAT_CONFIG_WRITE_MEMORY_ERROR: # ... elif rc == weechat.WEECHAT_CONFIG_WRITE_ERROR: # ... ----------------------------------------- +---- -weechat_config_read -^^^^^^^^^^^^^^^^^^^ +==== weechat_config_read Legge il file di configurazione da disco. Prototipo: [source,C] ----------------------------------------- +---- int weechat_config_read (struct t_config_file *config_file); ----------------------------------------- +---- Argomenti: @@ -5577,7 +5437,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- switch (weechat_config_read (config_file)) { case WEECHAT_CONFIG_READ_OK: @@ -5590,12 +5450,12 @@ switch (weechat_config_read (config_file)) /* ... */ break; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.config_read(config_file) @@ -5607,19 +5467,18 @@ elif rc == weechat.WEECHAT_CONFIG_READ_MEMORY_ERROR: # ... elif rc == weechat.WEECHAT_CONFIG_READ_FILE_NOT_FOUND: # ... ----------------------------------------- +---- -weechat_config_reload -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_reload Ricarica il file di configurazione da disco. Prototipo: [source,C] ----------------------------------------- +---- int weechat_config_reload (struct t_config_file *config_file); ----------------------------------------- +---- Argomenti: @@ -5634,7 +5493,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- switch (weechat_config_reload (config_file)) { case WEECHAT_CONFIG_READ_OK: @@ -5647,12 +5506,12 @@ switch (weechat_config_reload (config_file)) /* ... */ break; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.config_reload(config_file) @@ -5664,19 +5523,18 @@ elif rc == weechat.WEECHAT_CONFIG_READ_MEMORY_ERROR: # ... elif rc == weechat.WEECHAT_CONFIG_READ_FILE_NOT_FOUND: # ... ----------------------------------------- +---- -weechat_config_option_free -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_option_free Libera un'opzione. Prototipo: [source,C] ----------------------------------------- +---- void weechat_config_option_free (struct t_config_option *option); ----------------------------------------- +---- Argomenti: @@ -5685,32 +5543,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -5719,32 +5576,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_section_free Libera una sezione. Prototipo: [source,C] ----------------------------------------- +---- void weechat_config_section_free (struct t_config_section *section); ----------------------------------------- +---- Argomenti: @@ -5753,32 +5609,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^ +==== weechat_config_free Libera un file di configurazione. Prototipo: [source,C] ----------------------------------------- +---- void weechat_config_free (struct t_config_file *config_file); ----------------------------------------- +---- Argomenti: @@ -5787,32 +5642,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^ +==== 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: @@ -5825,32 +5679,31 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -5864,25 +5717,24 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_is_set_plugin Verifica se un'opzione è impostata nel file di configurazione dei plugin (plugins.conf). @@ -5890,9 +5742,9 @@ plugin (plugins.conf). Prototipo: [source,C] ----------------------------------------- +---- int weechat_config_is_set_plugin (const char *option_name); ----------------------------------------- +---- Argomenti: @@ -5906,7 +5758,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_config_is_set_plugin ("option")) { /* l'opzione è impostata */ @@ -5915,12 +5767,12 @@ else { /* l'opzione non esiste */ } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.config_is_set_plugin(option_name) @@ -5931,19 +5783,18 @@ if weechat.config_is_set_plugin("option"): else: # l'opzione non esiste # ... ----------------------------------------- +---- -weechat_config_set_plugin -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -5961,7 +5812,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- switch (weechat_config_set_plugin ("option", "test_value")) { case WEECHAT_CONFIG_OPTION_SET_OK_CHANGED: @@ -5977,12 +5828,12 @@ switch (weechat_config_set_plugin ("option", "test_value")) /* ... */ break; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.config_set_plugin(option_name, value) @@ -5996,10 +5847,9 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_SET_ERROR: # ... ----------------------------------------- +---- -weechat_config_set_desc_plugin -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_config_set_desc_plugin _WeeChat ≥ 0.3.5._ @@ -6009,10 +5859,10 @@ Imposta la descrizione per l'opzione nel file di configurazione dei plugin Prototipo: [source,C] ----------------------------------------- +---- void weechat_config_set_desc_plugin (const char *option_name, const char *description); ----------------------------------------- +---- Argomenti: @@ -6027,14 +5877,14 @@ Una futura creazione dell'opzione con questo nome userà questa descrizione. Esempio in C: [source,C] ----------------------------------------- +---- weechat_config_set_desc_plugin ("option", "description of option"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.config_set_desc_plugin(option_name, description) @@ -6042,19 +5892,18 @@ weechat.config_set_desc_plugin(option_name, description) version = weechat.info_get("version_number", "") or 0 if int(version) >= 0x00030500: weechat.config_set_desc_plugin("option", "description of option") ----------------------------------------- +---- -weechat_config_unset_plugin -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -6073,7 +5922,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- switch (weechat_config_unset_plugin ("option")) { case WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET: @@ -6089,12 +5938,12 @@ switch (weechat_config_unset_plugin ("option")) /* ... */ break; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.config_unset_plugin(option_name) @@ -6108,16 +5957,14 @@ elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED: # ... elif rc == weechat.WEECHAT_CONFIG_OPTION_UNSET_ERROR: # ... ----------------------------------------- +---- [[key_bindings]] -Combinazione tasti -~~~~~~~~~~~~~~~~~~ +=== Combinazione tasti Funzioni per le combinazioni dei tasti. -weechat_key_bind -^^^^^^^^^^^^^^^^ +==== weechat_key_bind _WeeChat ≥ 0.3.6._ @@ -6131,9 +5978,9 @@ una combinazione tasti, usare <<_weechat_key_unbind,weechat_key_unbind>>. Prototipo: [source,C] ----------------------------------------- +---- int weechat_key_bind (const char *context, struct t_hashtable *keys); ----------------------------------------- +---- Argomenti: @@ -6151,7 +5998,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hashtable *keys = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, @@ -6165,12 +6012,12 @@ if (keys) weechat_key_bind ("mouse", keys); weechat_hashtable_free (keys); } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo num_keys = weechat.key_bind(context, keys) @@ -6179,10 +6026,9 @@ keys = { "@chat(python.test):button1": "hsignal:test_mouse", "@chat(python.test):wheelup": "/mycommand up", "@chat(python.test):wheeldown": "/mycommand down" } weechat.key_bind("mouse", keys) ----------------------------------------- +---- -weechat_key_unbind -^^^^^^^^^^^^^^^^^^ +==== weechat_key_unbind _WeeChat ≥ 0.3.6._ @@ -6195,9 +6041,9 @@ combinazione tasti definita dall'utente. Prototipo: [source,C] ----------------------------------------- +---- int weechat_key_unbind (const char *context, const char *key); ----------------------------------------- +---- Argomenti: @@ -6212,18 +6058,18 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- /* rimuove un singolo tasto */ weechat_key_unbind ("mouse", "@chat(plugin.buffer):button1"); /* rimuove tutti i tasti con la zona "chat(plugin.buffer)" */ weechat_key_unbind ("mouse", "area:chat(plugin.buffer)"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo num_keys = weechat.key_unbind(context, key) @@ -6234,39 +6080,37 @@ weechat.key_unbind("mouse", "@chat(plugin.buffer):button1") # rimuove tutti i tasti con la zona "chat(python.test)" weechat.key_unbind("mouse", "area:chat(python.test)") ----------------------------------------- +---- [[display]] -Visualizzazione -~~~~~~~~~~~~~~~ +=== Visualizzazione Funzioni per visualizzare il testo nei buffer. -weechat_prefix -^^^^^^^^^^^^^^ +==== weechat_prefix Restituisce un prefisso. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_prefix (const char *prefix); ----------------------------------------- +---- Argomenti: * 'prefix': nome del prefisso: [width="70%",cols="^2e,^1,^3,5",options="header"] -|======================================== +|=== | Prefisso | Valore | Colore | Descrizione | error | `=!=` | 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`. @@ -6279,32 +6123,31 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "%sQuesto è un errore...", weechat_prefix ("error")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.prefix(prefix) # esempio weechat.prnt("", "%sQuesto è un errore..." % weechat.prefix("error")) ----------------------------------------- +---- -weechat_color -^^^^^^^^^^^^^ +==== weechat_color Restituisce una codice colore stringa da visualizzare. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_color (const char *color_name); ----------------------------------------- +---- Argomenti: @@ -6357,36 +6200,35 @@ Valore restituito: 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 -^^^^^^^^^^^^^^ +==== weechat_printf Visualizza un messaggio su un buffer. Prototipo: [source,C] ----------------------------------------- +---- void weechat_printf (struct t_gui_buffer *buffer, const char *message, ...); ----------------------------------------- +---- Argomenti: @@ -6410,20 +6252,20 @@ Esempio in C: // TRANSLATION MISSING [source,C] ----------------------------------------- +---- weechat_printf (NULL, "Benvenuto sul buffer di WeeChat"); weechat_printf (buffer, "Benvenuto su questo buffer"); weechat_printf (buffer, "%sQuesto è un errore!", weechat_prefix ("error")); weechat_printf (buffer, " \tMessaggio senza prefisso ma con \t alcune \t tabulazioni"); weechat_printf (buffer, "\t\tMessage without time/alignment"); weechat_printf (buffer, "\t\t"); /* empty line (without time) */ ----------------------------------------- +---- Script (Python): // TRANSLATION MISSING [source,python] ----------------------------------------- +---- # prototipo weechat.prnt(buffer, message) @@ -6434,23 +6276,22 @@ weechat.prnt(buffer, "%sQuesto è un errore!" % weechat.prefix("error")) weechat.prnt(buffer, " \tMessaggio senza prefisso ma con \t alcune \t tabulazioni") weechat.prnt(buffer, "\t\tMessage without time/alignment") weechat.prnt(buffer, "\t\t") # empty line (without time) ----------------------------------------- +---- [NOTE] La funzione è chiamata "print" negli script ("prnt" in Python). -weechat_printf_date -^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -6462,25 +6303,24 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf_date (NULL, time (NULL) - 120, "Ciao, 2 minuti fa"); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_printf_tags -^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -6492,26 +6332,25 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf_tags (NULL, "notify_message", "Messaggio con tag 'notify_message'"); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_printf_date_tags -^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -6524,7 +6363,7 @@ Argomenti: Tag usati di frequente (elenco non esaustivo): [width="70%",cols="1m,4",options="header"] -|======================================== +|=== | Tag | Descrizione | no_filter | La riga non può essere filtrata | no_highlight | Evidenziazione non possibile sulla riga @@ -6544,20 +6383,20 @@ Tag usati di frequente (elenco non esaustivo): | irc_ctcp_reply | Risposta ad un messaggio CTCP | irc_smart_filter | Messaggio IRC filtrabile tramite lo "smart filter" (filtro intelligente) | away_info | Messagio con informazioni sull'assenza -|======================================== +|=== 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) @@ -6565,23 +6404,22 @@ weechat.prnt_date_tags(buffer, date, tags, message) 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 -^^^^^^^^^^^^^^^^ +==== 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: @@ -6592,35 +6430,34 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^ +==== 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: @@ -6629,32 +6466,30 @@ Argomenti: 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 -~~~~ +=== Hook [[hook_priority]] [float] -Priorità degli hook -^^^^^^^^^^^^^^^^^^^ +==== Priorità degli hook _WeeChat ≥ 0.3.4._ @@ -6673,24 +6508,23 @@ La priorità predefinita è 1000. Esempio in C: [source,C] ----------------------------------------- +---- /* hook per il modificatore con priorità = 2000 */ weechat_hook_modifier ("2000|input_text_display", &modifier_cb, NULL); ----------------------------------------- +---- I tipi di hook che seguono consentono la priorità: command, command_run, signal, hsignal, config, completion, modifier, info, info_hashtable, infolist, hdata, focus. -weechat_hook_command -^^^^^^^^^^^^^^^^^^^^ +==== 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, @@ -6702,7 +6536,7 @@ struct t_hook *weechat_hook_command (const char *command, char **argv, char **argv_eol), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -6744,7 +6578,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_command_cb (void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) @@ -6776,7 +6610,7 @@ struct t_hook *my_command_hook = &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: @@ -6797,7 +6631,7 @@ Per gli script, 'args' ha valore "abc def ghi". Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_command(command, description, args, args_description, completion, callback, callback_data) @@ -6819,23 +6653,22 @@ hook = weechat.hook_command("myfilter", "descrizione di myfilter", " || add %(filters_names) %(buffers_plugins_names)|*" " || del %(filters_names)|-all", "my_command_cb", "") ----------------------------------------- +---- -weechat_hook_command_run -^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -6864,7 +6697,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_command_run_cb (void *data, struct t_gui_buffer *buffer, const char *command) @@ -6877,12 +6710,12 @@ my_command_run_cb (void *data, struct t_gui_buffer *buffer, 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) @@ -6892,24 +6725,23 @@ def my_command_run_cb(data, buffer, command): return weechat.WEECHAT_RC_OK_EAT hook = weechat.hook_command_run("/input complete*", "my_command_run_cb", "") ----------------------------------------- +---- -weechat_hook_timer -^^^^^^^^^^^^^^^^^^ +==== weechat_hook_timer Hook sul timer. Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_timer (long interval, int align_second, int max_calls, int (*callback)(void *data, int remaining_calls), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -6937,7 +6769,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_timer_cb (void *data, int remaining_calls) { @@ -6948,12 +6780,12 @@ my_timer_cb (void *data, int remaining_calls) /* 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) @@ -6964,17 +6796,16 @@ def my_timer_cb(data, remaining_calls): # timer chiamato ogni 20 secondi hook = weechat.hook_timer(20 * 1000, 0, 0, "my_timer_cb", "") ----------------------------------------- +---- -weechat_hook_fd -^^^^^^^^^^^^^^^ +==== 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, @@ -6982,7 +6813,7 @@ struct t_hook *weechat_hook_fd (int fd, int (*callback)(void *data, int fd), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -7006,7 +6837,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_fd_cb (void *data, int fd) { @@ -7018,12 +6849,12 @@ int sock = socket (AF_INET, SOCK_STREAM, 0); /* imposta le opzioni del socket */ /* ... */ 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) @@ -7034,10 +6865,9 @@ def my_fd_cb(data, fd): sock = ... hook = weechat.hook_fd(sock, 1, 0, 0, "my_fd_cb", "") ----------------------------------------- +---- -weechat_hook_process -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_process Hook su un processo (lanciato con un fork), e cattura l'output. @@ -7053,7 +6883,7 @@ arguments in the hashtable 'options' _(WeeChat ≥ 0.4.0)_. Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_process (const char *command, int timeout, int (*callback)(void *data, @@ -7062,7 +6892,7 @@ struct t_hook *weechat_hook_process (const char *command, const char *out, const char *err), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -7125,7 +6955,7 @@ codice restituito è non-negativo. Esempio in C: [source,C] ----------------------------------------- +---- int my_process_cb (void *data, const char *command, int return_code, const char *out, const char *err) @@ -7156,12 +6986,12 @@ my_process_cb (void *data, const char *command, int return_code, struct t_hook *my_process_hook = weechat_hook_process ("ls", 5000, &my_process_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_process(command, timeout, callback, callback_data) @@ -7179,10 +7009,9 @@ def my_process_cb(data, command, return_code, out, err): return weechat.WEECHAT_RC_OK hook = weechat.hook_process("ls", 5000, "my_process_cb", "") ----------------------------------------- +---- -weechat_hook_process_hashtable -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_process_hashtable _WeeChat ≥ 0.3.7._ @@ -7192,7 +7021,7 @@ e cattura dell'output. Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_process_hashtable (const char *command, struct t_hashtable *options, int timeout, @@ -7202,7 +7031,7 @@ struct t_hook *weechat_hook_process_hashtable (const char *command, const char *out, const char *err), void *callback_data); ----------------------------------------- +---- Gli argomenti sono gli stessi della funzione <<_weechat_hook_process,weechat_hook_process>>, con un argomento aggiuntivo: @@ -7240,7 +7069,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_process_cb (void *data, const char *command, int return_code, const char *out, const char *err) @@ -7320,12 +7149,12 @@ if (options_cmd2) &my_process_cb, NULL); weechat_hashtable_free (options_cmd2); } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_process_hashtable(command, options, timeout, callback, callback_data) @@ -7360,17 +7189,16 @@ hook3 = weechat.hook_process_hashtable("sh", { "arg1": "-c", "arg2": "ls -l /tmp | grep something" }, 20000, "my_process_cb", "") ----------------------------------------- +---- -weechat_hook_connect -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_connect Hook su una connessione (connessione in secondo piano ad un host remoto). Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_connect (const char *proxy, const char *address, int port, @@ -7388,7 +7216,7 @@ struct t_hook *weechat_hook_connect (const char *proxy, const char *error, const char *ip_address), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -7447,7 +7275,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_connect_cb (void *data, int status, int gnutls_rc, int sock, const char *error, const char *ip_address) @@ -7497,12 +7325,12 @@ struct t_hook *my_connect_hook = weechat_hook_connect (NULL, NULL, NULL, 0, /* GnuTLS */ NULL, &my_connect_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_connect(proxy, address, port, ipv6, retry, local_hostname, callback, callback_data) @@ -7535,17 +7363,16 @@ def my_connect_cb(data, status, gnutls_rc, sock, error, ip_address): hook = weechat.hook_connect("", "my.server.org", 1234, 1, 0, "", "my_connect_cb", "") ----------------------------------------- +---- -weechat_hook_print -^^^^^^^^^^^^^^^^^^ +==== weechat_hook_print 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, @@ -7560,7 +7387,7 @@ struct t_hook *weechat_hook_print (struct t_gui_buffer *buffer, const char *prefix, const char *message), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -7595,7 +7422,7 @@ Valore restituito: 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, @@ -7609,12 +7436,12 @@ my_print_cb (void *data, struct t_gui_buffer *buffer, time_t date, /* 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) @@ -7625,24 +7452,23 @@ def my_print_cb(data, buffer, date, tags, displayed, highlight, prefix, message) # cattura tutti i messaggi, su tutti i buffer, senza colore hook = weechat.hook_print("", "", "", 1, "my_print_cb", "") ----------------------------------------- +---- -weechat_hook_signal -^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -7651,7 +7477,7 @@ Argomenti: <<hook_priority,priority>>): [width="100%",cols="^1,^3,^4,5",options="header"] -|======================================== +|=== | Plugin | Segnale | Argomenti | Descrizione // TRANSLATION MISSING @@ -8209,7 +8035,7 @@ Argomenti: _(WeeChat ≥ 0.3.2)_ | Puntatore: lista info con info per xfer | Xfer terminato -|======================================== +|=== [NOTE] ^(1)^ 'xxx' è il nome del server IRC, 'yyy' è il nome del comando IRC. @@ -8238,7 +8064,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_signal_cb (void *data, const char *signal, const char *type_data, void *signal_data) @@ -8250,12 +8076,12 @@ my_signal_cb (void *data, const char *signal, const char *type_data, /* cattura il segnale "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) @@ -8266,20 +8092,19 @@ def my_signal_cb(data, signal, signal_data): # cattura il segnale "quit" hook = weechat.hook_signal("quit", "my_signal_cb", "") ----------------------------------------- +---- -weechat_hook_signal_send -^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -8291,24 +8116,23 @@ Argomenti: 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) ----------------------------------------- +---- [[signal_logger_backlog]] -Signal logger_backlog -+++++++++++++++++++++ +===== Signal logger_backlog Il segnale "logger_backlog" può essere inviato per visualizzare il backlog (cronologia di chat) nel buffer (ad esempio se il proprio buffer viene aperto @@ -8319,20 +8143,19 @@ L'argomento è un puntatore al buffer. Esempio in C: [source,C] ----------------------------------------- +---- weechat_hook_signal_send ("logger_backlog", WEECHAT_HOOK_SIGNAL_POINTER, buffer); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- weechat.hook_signal_send("logger_backlog", weechat.WEECHAT_HOOK_SIGNAL_POINTER, buffer) ----------------------------------------- +---- [[signals_xxx_script_install]] -Signals xxx_script_install -++++++++++++++++++++++++++ +===== Signals xxx_script_install Cinque segnali che possono essere inviati per installare uno script, a seconda del linguaggio: @@ -8359,22 +8182,21 @@ L'argomento è una stringa con il percorso dello script da installare. Esempio in C: [source,C] ----------------------------------------- +---- weechat_hook_signal_send ("python_script_install", WEECHAT_HOOK_SIGNAL_STRING, "/home/xxx/.weechat/test.py"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- weechat.hook_signal_send("python_script_install", WEECHAT_HOOK_SIGNAL_STRING, "/home/xxx/.weechat/test.py") ----------------------------------------- +---- [[signals_xxx_script_remove]] -Signals xxx_script_remove -+++++++++++++++++++++++++ +===== Signals xxx_script_remove Cinque segnali che possono essere inviati per rimuovere un elenco di script, a seconda del linguaggio: @@ -8396,24 +8218,23 @@ rimuovere (script è il nome senza percorso, ad esempio 'script.py'). Esempio in C: [source,C] ----------------------------------------- +---- /* scarica e rimuove gli script test.py e script.py */ weechat_hook_signal_send ("python_script_remove", WEECHAT_HOOK_SIGNAL_STRING, "test.py,script.py"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # scarica e rimuove gli script test.py e script.py weechat.hook_signal_send("python_script_remove", WEECHAT_HOOK_SIGNAL_STRING, "test.py,script.py") ----------------------------------------- +---- [[signal_irc_input_send]] -Signal irc_input_send -+++++++++++++++++++++ +===== Signal irc_input_send _WeeChat ≥ 0.3.4._ @@ -8439,7 +8260,7 @@ L'argomento è una stringa con il seguente formato: Esempi in C: [source,C] ----------------------------------------- +---- /* dice "Hello!" sul server freenode, canale #weechat */ weechat_hook_signal_send ("irc_input_send", WEECHAT_HOOK_SIGNAL_STRING, "freenode;#weechat;1;;Hello!"); @@ -8447,12 +8268,12 @@ weechat_hook_signal_send ("irc_input_send", WEECHAT_HOOK_SIGNAL_STRING, /* invia il comando "/whois FlashCode" sul server freenode, con priorità minore */ weechat_hook_signal_send ("irc_input_send", WEECHAT_HOOK_SIGNAL_STRING, "freenode;;2;;/whois FlashCode"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # dice "Hello!" sul server freenode server, canale #weechat weechat.hook_signal_send("irc_input_send", weechat.WEECHAT_HOOK_SIGNAL_STRING, "freenode;#weechat;1;;Hello!") @@ -8460,10 +8281,9 @@ weechat.hook_signal_send("irc_input_send", weechat.WEECHAT_HOOK_SIGNAL_STRING, # invia il comando "/whois FlashCode" sul server freenode, con priorità minore weechat.hook_signal_send("irc_input_send", weechat.WEECHAT_HOOK_SIGNAL_STRING, "freenode;;2;;/whois FlashCode") ----------------------------------------- +---- -weechat_hook_hsignal -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_hsignal _WeeChat ≥ 0.3.4._ @@ -8472,13 +8292,13 @@ Hook su hsignal (segnale con tabella hash). Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_hsignal (const char *signal, int (*callback)(void *data, const char *signal, struct t_hashtable *hashtable), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -8486,7 +8306,7 @@ Argomenti: (priorità consentita, consultare la nota a proposito di <<hook_priority,priority>>): [width="100%",cols="^1,^3,5,5",options="header"] -|======================================== +|=== | Plugin | Segnale | Argomenti | Descrizione | irc | irc_redirection_xxx_yyy ^(1)^ + @@ -8541,7 +8361,7 @@ Argomenti: 'parent_group' ('struct t_gui_nick_group *'): parent group + 'nick' ('struct t_gui_nick *'): nick | Nick changed in nicklist -|======================================== +|=== [NOTE] ^(1)^ 'xxx' è l'argomento del segnale usato nella redirezione, 'yyy' è lo schema @@ -8567,7 +8387,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_hsignal_cb (void *data, const char *signal, struct t_hashtable *hashtable) { @@ -8577,12 +8397,12 @@ my_hsignal_cb (void *data, const char *signal, struct t_hashtable *hashtable) struct t_hook *my_hsignal_hook = weechat_hook_hsignal ("test", &my_hsignal_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_hsignal(signal, callback, callback_data) @@ -8592,10 +8412,9 @@ def my_hsignal_cb(data, signal, hashtable): return weechat.WEECHAT_RC_OK hook = weechat.hook_hsignal("test", "my_hsignal_cb", "") ----------------------------------------- +---- -weechat_hook_hsignal_send -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_hsignal_send _WeeChat ≥ 0.3.4._ @@ -8604,9 +8423,9 @@ Invia un hsignal (segnale con tabella hash). Prototipo: [source,C] ----------------------------------------- +---- void weechat_hook_hsignal_send (const char *signal, struct t_hashtable *hashtable); ----------------------------------------- +---- Argomenti: @@ -8616,7 +8435,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hashtable *hashtable = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, @@ -8628,22 +8447,21 @@ if (hashtable) weechat_hook_hsignal_send ("my_hsignal", hashtable); weechat_hashtable_free (hashtable); } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.hook_hsignal_send(signal, hashtable) # esempio weechat.hook_hsignal_send("my_hsignal", { "key": "value" }) ----------------------------------------- +---- [[hsignal_irc_redirect_command]] -Hsignal irc_redirect_command -++++++++++++++++++++++++++++ +===== Hsignal irc_redirect_command _WeeChat ≥ 0.3.4._ @@ -8702,7 +8520,7 @@ sono stringhe): Esempio in C: [source,C] ----------------------------------------- +---- int test_whois_cb (void *data, const char *signal, struct t_hashtable *hashtable) { @@ -8728,12 +8546,12 @@ if (hashtable) "freenode;;2;;/whois FlashCode"); weechat_hashtable_free (hashtable); } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- def test_whois_cb(data, signal, hashtable): weechat.prnt("", "error = %s" % hashtable["error"]) weechat.prnt("", "output = %s" % hashtable["output"]) @@ -8745,11 +8563,10 @@ weechat.hook_hsignal_send("irc_redirect_command", "string": "FlashCode" }) weechat.hook_signal_send("irc_input_send", weechat.WEECHAT_HOOK_SIGNAL_STRING, "freenode;;2;;/whois FlashCode") ----------------------------------------- +---- [[hsignal_irc_redirect_pattern]] -Hsignal irc_redirect_pattern -++++++++++++++++++++++++++++ +===== Hsignal irc_redirect_pattern _WeeChat ≥ 0.3.4._ @@ -8769,9 +8586,9 @@ Per ogni comando in 'cmd_start', 'cmd_stop' e 'cmd_extra', è possibile fornire un intero con la posizione di "string" che va trovato nel messaggio ricevuto, ad esempio: ----------------------------------------- +---- 352:1,354,401:1 ----------------------------------------- +---- Per i comandi 352 e 401, "string" deve essere trovata nel messaggio ricevuto, come primo argomento. @@ -8784,7 +8601,7 @@ di ogni redirezione. Esempio in C: [source,C] ----------------------------------------- +---- struct t_hashtable *hashtable = weechat_hashtable_new (8, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, @@ -8805,12 +8622,12 @@ if (hashtable) /* ... */ weechat_hashtable_free (hashtable); } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- weechat.hook_hsignal_send("irc_redirect_pattern", { "pattern": "my_whois", "timeout": "30", "cmd_start": "311:1", @@ -8819,23 +8636,22 @@ weechat.hook_hsignal_send("irc_redirect_pattern", # now redirect irc whois command with hsignal irc_redirect_command # using pattern "my_whois" # ... ----------------------------------------- +---- -weechat_hook_config -^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -8860,7 +8676,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_config_cb (void *data, const char *option, const char *value) { @@ -8871,12 +8687,12 @@ my_config_cb (void *data, const char *option, const char *value) /* 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) @@ -8887,17 +8703,16 @@ def my_config_cb(data, option, value): # 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 -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_completion Hook su un completamento. Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_completion (const char *completion_item, const char *description, int (*callback)(void *data, @@ -8905,7 +8720,7 @@ struct t_hook *weechat_hook_completion (const char *completion_item, struct t_gui_buffer *buffer, struct t_gui_completion *completion), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -8939,7 +8754,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_completion_cb (void *data, const char *completion_item, struct t_gui_buffer *buffer, @@ -8955,12 +8770,12 @@ my_completion_cb (void *data, const char *completion_item, struct t_hook *my_completion_hook = weechat_hook_completion ("plugin_item", "my custom completion!", &my_completion_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_completion(completion_item, description, callback, callback_data) @@ -8972,10 +8787,9 @@ def my_completion_cb(data, completion_item, buffer, completion): hook = weechat.hook_completion("plugin_item", "my custom completion!", "my_completion_cb", "") ----------------------------------------- +---- -weechat_hook_completion_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_completion_get_string _Novità nella versioe 0.3.4._ @@ -8984,10 +8798,10 @@ Ottiene il completamento di una proprietà come stringa. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_hook_completion_get_string (struct t_gui_completion *completion, const char *property); ----------------------------------------- +---- Argomenti: @@ -9000,7 +8814,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- int my_completion_cb (void *data, const char *completion_item, struct t_gui_buffer *buffer, @@ -9014,12 +8828,12 @@ my_completion_cb (void *data, const char *completion_item, return WEECHAT_RC_OK; } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.hook_completion_get_string(completion, property) @@ -9030,22 +8844,21 @@ def my_completion_cb(data, completion_item, buffer, completion): # completamento che dipende dagli argomenti # ... return weechat.WEECHAT_RC_OK ----------------------------------------- +---- -weechat_hook_completion_list_add -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -9063,29 +8876,28 @@ Esempio in C: consultare <<_weechat_hook_completion,weechat_hook_completion>>. Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.hook_completion_list_add(completion, word, nick_completion, where) # esempio: consultare function hook_completion precedente ----------------------------------------- +---- -weechat_hook_modifier -^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -9095,7 +8907,7 @@ Argomenti: <<hook_priority,priority>>) [width="100%",cols="^2,3,4,4",options="header"] -|======================================== +|=== | Modificatore | Dati modificatore | Stringa | Output | charset_decode | @@ -9190,7 +9002,7 @@ Argomenti: plugin + ";" + buffer_name + ";" + tags | Messaggio stampato | Nuovo messaggio stampato -|======================================== +|=== [NOTE] ^(1)^ 'xxx' è il nome del comando IRC. + @@ -9212,7 +9024,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char * my_modifier_cb (void *data, const char *modifier, const char *modifier_data, @@ -9237,12 +9049,12 @@ my_modifier_cb (void *data, const char *modifier, struct t_hook *my_modifier_hook = weechat_hook_modifier ("weechat_print", &my_modifier_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_modifier(modifier, callback, callback_data) @@ -9251,21 +9063,20 @@ def my_modifier_cb(data, modifier, modifier_data, string): return "%s xxx" % string hook = weechat.hook_modifier("weechat_print", "my_modifier_cb", "") ----------------------------------------- +---- -weechat_hook_modifier_exec -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_modifier_exec Esegue modificatore(i). Prototipo: [source,C] ----------------------------------------- +---- char *weechat_hook_modifier_exec (const char *modifier, const char *modifier_data, const char *string); ----------------------------------------- +---- Argomenti: @@ -9280,31 +9091,30 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^ +==== weechat_hook_info Hook su una informazione (la callback prende e restituisce una stringa). Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_info (const char *info_name, const char *description, const char *args_description, @@ -9312,7 +9122,7 @@ struct t_hook *weechat_hook_info (const char *info_name, const char *info_name, const char *arguments), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -9336,7 +9146,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- const char * my_info_cb (void *data, const char *info_name, const char *arguments) { @@ -9349,12 +9159,12 @@ struct t_hook *my_info_hook = weechat_hook_info ("my_info", "Some info", "Info about arguments", &my_info_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_info(info_name, description, args_description, callback, callback_data) @@ -9364,10 +9174,9 @@ def my_info_cb(data, info_name, arguments): hook = weechat.hook_info("my_info", "Some info", "Info about arguments", "my_info_cb", "") ----------------------------------------- +---- -weechat_hook_info_hashtable -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_info_hashtable _WeeChat ≥ 0.3.4._ @@ -9376,7 +9185,7 @@ Hook su una informazione (la callback prende e restituisce una tabella hash). Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_info_hashtable (const char *info_name, const char *description, const char *args_description, @@ -9385,7 +9194,7 @@ struct t_hook *weechat_hook_info_hashtable (const char *info_name, const char *info_name, struct t_hashtable *hashtable), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -9412,7 +9221,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hashtable * my_info_hashtable_cb (void *data, const char *info_name, struct t_hashtable *hashtable) { @@ -9426,12 +9235,12 @@ struct t_hook *my_info_hook = weechat_hook_info_hashtable ("my_info_hashtable", "Info about input hashtable", "Info about output hashtable", &my_info_hashtable_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_info_hashtable(info_name, description, args_description, output_description, callback, callback_data) @@ -9444,10 +9253,9 @@ hook = weechat.hook_info_hashtable("my_info_hashtable", "Some info", "Info about input hashtable", "Info about output hashtable", "my_info_hashtable_cb", "") ----------------------------------------- +---- -weechat_hook_infolist -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hook_infolist Hook su una lista info: la callback restituisce il puntatore alla lista info richiesta. @@ -9455,7 +9263,7 @@ richiesta. Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_infolist (const char *infolist_name, const char *description, const char *pointer_description, @@ -9465,7 +9273,7 @@ struct t_hook *weechat_hook_infolist (const char *infolist_name, void *pointer, const char *arguments), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -9492,7 +9300,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_infolist * my_infolist_cb (void *data, const char *infolist_name, void *pointer, const char *arguments) @@ -9511,12 +9319,12 @@ struct t_hook *my_infolist = weechat_hook_infolist ("my_infolist", "Info about pointer", "Info about arguments", &my_infolist_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_infolist(infolist_name, description, pointer_description, args_description, callback, callback_data) @@ -9530,23 +9338,22 @@ def my_infolist_cb(data, infolist_name, pointer, arguments): hook = weechat.hook_infolist("my_infolist", "Infolist with some data", "Info about pointer", "Info about arguments", "my_infolist_cb", "") ----------------------------------------- +---- -weechat_hook_hdata -^^^^^^^^^^^^^^^^^^ +==== weechat_hook_hdata Hook di un hdata: la callback restituisce il puntatore all'hdata richiesto. Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_hdata (const char *hdata_name, const char *description, struct t_hdata *(*callback)(void *data, const char *hdata_name), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -9566,7 +9373,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata * my_hdata_cb (void *data, const char *hdata_name) { @@ -9582,13 +9389,12 @@ my_hdata_cb (void *data, const char *hdata_name) struct t_hook *my_hdata = weechat_hook_hdata ("my_hdata", "Hdata for my structure", &my_hdata_cb, NULL); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hook_focus -^^^^^^^^^^^^^^^^^^ +==== weechat_hook_focus Hook sul foucus: evento del mouse o tasto premuto nella modalità cursore (movimento libero del cursore). @@ -9596,12 +9402,12 @@ Hook sul foucus: evento del mouse o tasto premuto nella modalità cursore Prototipo: [source,C] ----------------------------------------- +---- struct t_hook *weechat_hook_focus (const char *area, struct t_hashtable *(*callback)(void *data, struct t_hashtable *info), void *callback_data); ----------------------------------------- +---- Argomenti: @@ -9629,7 +9435,7 @@ Contenuto della tabella hash inviata alla callback (tasti e valori sono di tipo "string"): [width="100%",cols="5m,5,8,3",options="header"] -|======================================== +|=== | Key ^(1)^ | Descrizione | Valori di esempio | Valore se N/D | _x | Colonna sullo schermo 2+| "0" ... "n" | _y | Riga sullo schermo 2+| "0" ... "n" @@ -9660,7 +9466,7 @@ Contenuto della tabella hash inviata alla callback (tasti e valori sono di tipo | _bar_item_name | Nome dell'elemento barra | "buffer_nicklist", "hotlist", ... | "" | _bar_item_line | Riga nell'elemento barra | "0" ... "n" | "-1" | _bar_item_col | Colonna nell'elemento barra | "0" ... "n" | "-1" -|======================================== +|=== [NOTE] ^(1)^ Ci sono alcune chiavi con il suffisso "2" (es: "_x2", "_y2", "_window2", @@ -9674,13 +9480,13 @@ per sapere dove il pulsante del mouse è stato rilasciato). + Informazioni aggiuntive per l'elemento barra "buffer_nicklist": [width="70%",cols="3m,3,8",options="header"] -|======================================== +|=== | Chiave | Plugin | Descrizione | nick | core | Nick | prefix | core | Prefisso per il nick | group | core | Nome gruppo | irc_host | irc | Host per il nick (se conosciuto) -|======================================== +|=== [NOTE] ^(1)^ Il nome del plugin che definisce un hook_focus per restituire @@ -9694,7 +9500,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hashtable * my_focus_nicklist_cb (void *data, struct t_hashtable *info) { @@ -9707,12 +9513,12 @@ my_focus_nicklist_cb (void *data, struct t_hashtable *info) /* add focus on nicklist */ struct t_hook *my_focus = weechat_hook_focus ("buffer_nicklist", &my_focus_nicklist_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hook = weechat.hook_focus(area, callback, callback_data) @@ -9723,10 +9529,9 @@ def my_focus_nicklist_cb(data, info): return my_dict hook = weechat.hook_focus("buffer_nicklist", "my_focus_nicklist_cb", "") ----------------------------------------- +---- -weechat_hook_set -^^^^^^^^^^^^^^^^ +==== weechat_hook_set _WeeChat ≥ 0.3.9._ @@ -9736,10 +9541,10 @@ Set string value of a hook property. Prototipo: [source,C] ----------------------------------------- +---- void weechat_hook_set (struct t_hook *hook, const char *property, const char *value); ----------------------------------------- +---- Argomenti: @@ -9747,40 +9552,39 @@ Argomenti: * 'property' e 'value': nome della proprietà, con il proprio valore: [width="100%",cols="^2,4,8",options="header"] -|======================================== +|=== | Nome | Valore | Descrizione | subplugin | qualsiasi stringa | // TRANSLATION MISSING Name of sub plugin (commonly script name, which is displayed in `/help command` for a hook of type 'command') -|======================================== +|=== Esempio in C: [source,C] ----------------------------------------- +---- struct t_hook *my_command_hook = weechat_hook_command ("abcd", "description", "args", "description args", "", &my_command_cb, NULL); weechat_hook_set (my_command_hook, "subplugin", "test"); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_unhook -^^^^^^^^^^^^^^ +==== weechat_unhook Rimuove un hook. Prototipo: [source,C] ----------------------------------------- +---- void weechat_unhook (struct t_hook *hook); ----------------------------------------- +---- Argomenti: @@ -9789,25 +9593,24 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^ +==== weechat_unhook_all Rimuove l'hook in qualsiasi punto in cui è stato attivato dal plugin corrente. @@ -9815,43 +9618,41 @@ 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]] -Buffer -~~~~~~ +=== Buffer Funzioni per creare/richiedere/chiudere buffer. -weechat_buffer_new -^^^^^^^^^^^^^^^^^^ +==== 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, @@ -9860,7 +9661,7 @@ struct t_gui_buffer *weechat_buffer_new (const char *name, int (*close_callback)(void *data, struct t_gui_buffer *buffer), void *close_callback_data); ----------------------------------------- +---- Argomenti: @@ -9890,7 +9691,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_input_cb (void *data, struct t_gui_buffer *buffer, const char *input_data) { @@ -9909,12 +9710,12 @@ my_close_cb (void *data, struct t_gui_buffer *buffer) 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) @@ -9929,10 +9730,9 @@ def my_close_cb(data, buffer): return weechat.WEECHAT_RC_OK buffer = weechat.buffer_new("my_buffer", "my_input_cb", "", "my_close_cb", "") ----------------------------------------- +---- -weechat_current_buffer -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_current_buffer Restituisce il puntatore al buffer corrente (buffer visualizzato nella finestra corrente). @@ -9940,9 +9740,9 @@ finestra corrente). Prototipo: [source,C] ----------------------------------------- +---- struct t_gui_buffer *weechat_current_buffer (); ----------------------------------------- +---- Valore restituito: @@ -9951,33 +9751,32 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -9992,24 +9791,23 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_search_main Cerca nel buffer principale di WeeChat (per primo nel buffer 'core', il primo visualizzato all'avvio di WeeChat). @@ -10017,9 +9815,9 @@ visualizzato all'avvio di WeeChat). Prototipo: [source,C] ----------------------------------------- +---- struct t_gui_buffer *weechat_buffer_search_main (); ----------------------------------------- +---- Valore restituito: @@ -10028,32 +9826,31 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_clear Pulisce il contenuto del buffer. Prototipo: [source,C] ----------------------------------------- +---- void weechat_buffer_clear (struct t_gui_buffer *buffer); ----------------------------------------- +---- Argomenti: @@ -10062,19 +9859,19 @@ Argomenti: 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) @@ -10082,19 +9879,18 @@ weechat.buffer_clear(buffer) buffer = weechat.buffer_search("my_plugin", "my_buffer") if buffer != "": weechat.buffer_clear(buffer) ----------------------------------------- +---- -weechat_buffer_close -^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_close Chiude un buffer. Prototipo: [source,C] ----------------------------------------- +---- void weechat_buffer_close (struct t_gui_buffer *buffer); ----------------------------------------- +---- Argomenti: @@ -10103,18 +9899,18 @@ Argomenti: 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) @@ -10122,10 +9918,9 @@ weechat.buffer_close(buffer) buffer = weechat.buffer_new("my_buffer", "my_input_cb", "", "my_close_cb", "") # ... weechat.buffer_close(buffer) ----------------------------------------- +---- -weechat_buffer_merge -^^^^^^^^^^^^^^^^^^^^ +==== 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 @@ -10134,10 +9929,10 @@ buffer (righe mischiate). Prototipo: [source,C] ----------------------------------------- +---- void weechat_buffer_merge (struct t_gui_buffer *buffer, struct t_gui_buffer *target_buffer); ----------------------------------------- +---- Argomenti: @@ -10147,36 +9942,35 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -10188,23 +9982,22 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_get_integer Restituisce il valore intero della proprietà di un buffer. @@ -10212,10 +10005,10 @@ un buffer. Prototipo: [source,C] ----------------------------------------- +---- int weechat_buffer_get_integer (struct t_gui_buffer *buffer, const char *property); ----------------------------------------- +---- Argomenti: @@ -10270,34 +10063,33 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -10327,16 +10119,16 @@ Valore restituito: 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) @@ -10344,20 +10136,19 @@ value = weechat.buffer_get_string(buffer, property) 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_get_pointer Restituisce il valore puntatore della proprietà di un buffer. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_buffer_pointer (struct t_gui_buffer *buffer, const char *property); ----------------------------------------- +---- Argomenti: @@ -10374,34 +10165,33 @@ Valore restituito: 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: %s" % weechat.buffer_get_pointer(my_buffer, "plugin")) ----------------------------------------- +---- -weechat_buffer_set -^^^^^^^^^^^^^^^^^^ +==== 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: @@ -10409,7 +10199,7 @@ Argomenti: * 'property' e 'value': nome della proprietà, con il proprio valore: [width="100%",cols="^2,4,8",options="header"] -|======================================== +|=== | Nome | Valore | Descrizione | hotlist | "+", "-", WEECHAT_HOTLIST_LOW, WEECHAT_HOTLIST_MESSAGE, @@ -10531,12 +10321,12 @@ Argomenti: | localvar_del_xxx | - | Rimuove la variabile locale 'xxx' -|======================================== +|=== Esempio in C: [source,C] ----------------------------------------- +---- /* disabilita hotlist (per tutti i buffer) */ weechat_buffer_set (NULL, "hotlist", "-"); @@ -10551,12 +10341,12 @@ 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) @@ -10576,20 +10366,19 @@ weechat.buffer_set(my_buffer, "localvar_set_tizio", "abc") # rimuove la variabile locale "tizio" weechat.buffer_set(my_buffer, "localvar_del_tizio", "") ----------------------------------------- +---- -weechat_buffer_set_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -10610,18 +10399,18 @@ Argomenti: Prototypes for callbacks: [source,C] ----------------------------------------- +---- int close_callback (void *data, struct t_gui_buffer *buffer); int input_callback (void *data, struct t_gui_buffer *buffer, const char *input_data); int nickcmp_callback (void *data, struct t_gui_buffer *buffer, const char *nick1, const char *nick2); ----------------------------------------- +---- Esempio in C: [source,C] ----------------------------------------- +---- int my_close_cb (void *data, struct t_gui_buffer *buffer) { @@ -10630,13 +10419,12 @@ my_close_cb (void *data, struct t_gui_buffer *buffer) } weechat_buffer_set_pointer (my_buffer, "close_callback", &my_close_cb); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_buffer_string_replace_local_var -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_string_replace_local_var Sostituisce le variabili globali in una stringa con i loro valori, utilizzando le variabili del buffer locale. @@ -10644,10 +10432,10 @@ le variabili del buffer locale. Prototipo: [source,C] ----------------------------------------- +---- char *weechat_buffer_string_replace_local_var (struct t_gui_buffer *buffer, const char *string); ----------------------------------------- +---- Argomenti: @@ -10661,18 +10449,18 @@ Valore restituito: 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 contiene "test with abc" */ ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.buffer_string_replace_local_var(buffer, string) @@ -10680,10 +10468,9 @@ value = weechat.buffer_string_replace_local_var(buffer, string) weechat.buffer_set(my_buffer, "localvar_set_toto", "abc") str = weechat.buffer_string_replace_local_var(my_buffer, "test with $toto") # str contains "test with abc" ----------------------------------------- +---- -weechat_buffer_match_list -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_buffer_match_list _WeeChat ≥ 0.3.5._ @@ -10692,9 +10479,9 @@ Verifica se il buffer corrisponde ad una lista di buffer. Prototipo: [source,C] ----------------------------------------- +---- int weechat_buffer_match_list (struct t_gui_buffer *buffer, const char *string); ----------------------------------------- +---- Argomenti: @@ -10711,7 +10498,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_gui_buffer *buffer = weechat_buffer_search ("irc", "freenode.#weechat"); if (buffer) { @@ -10720,12 +10507,12 @@ if (buffer) weechat_printf (NULL, "%d", weechat_buffer_match_list (buffer, "irc.freenode.*")); /* 1 */ weechat_printf (NULL, "%d", weechat_buffer_match_list (buffer, "irc.oftc.*,python.*")); /* 0 */ } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo match = weechat.buffer_match_list(buffer, string) @@ -10736,25 +10523,23 @@ if buffer: weechat.prnt("", "%d" % weechat.buffer_match_list(buffer, "*,!*#weechat*")) # 0 weechat.prnt("", "%d" % weechat.buffer_match_list(buffer, "irc.freenode.*")) # 1 weechat.prnt("", "%d" % weechat.buffer_match_list(buffer, "irc.oftc.*,python.*")) # 0 ----------------------------------------- +---- [[windows]] -Finestre -~~~~~~~~ +=== Finestre Funzioni per richiedere finestre. -weechat_current_window -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_current_window Restituisce il puntatore alla finestra corrente Prototipo: [source,C] ----------------------------------------- +---- struct t_gui_window *weechat_current_window (); ----------------------------------------- +---- Valore restituito: @@ -10763,23 +10548,22 @@ Valore restituito: 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_search_with_buffer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_window_search_with_buffer _WeeChat ≥ 0.3.5._ @@ -10788,9 +10572,9 @@ Restituisce il puntatore alla finestra che mostra il buffer. Prototipo: [source,C] ----------------------------------------- +---- struct t_gui_window *weechat_window_search_with_buffer (struct t_gui_buffer *buffer); ----------------------------------------- +---- Argomenti: @@ -10804,36 +10588,35 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "window displaying core buffer: %lx", weechat_window_search_with_buffer (weechat_buffer_search_main ())); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo window = weechat.window_search_with_buffer(buffer) # esempio weechat.prnt("", "window displaying core buffer: %s" % weechat.window_search_with_buffer(weechat.buffer_search_main())) ----------------------------------------- +---- -weechat_window_get_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_window_get_integer Restituisce 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: @@ -10868,16 +10651,16 @@ Valore restituito: 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) @@ -10885,10 +10668,9 @@ value = weechat.window_get_integer(window, property) 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 -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_window_get_string Restituisce il valore stringa della proprietà di una finestra. @@ -10898,10 +10680,10 @@ 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: @@ -10912,18 +10694,17 @@ Valore restituito: * valore stringa della proprietà -weechat_window_get_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -10939,35 +10720,34 @@ Valore restituito: 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: %s" % weechat.window_get_pointer(weechat.current_window(), "buffer")) ----------------------------------------- +---- -weechat_window_set_title -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_window_set_title Imposta il titolo per il terminale. Prototipo: [source,C] ----------------------------------------- +---- void weechat_window_set_title (const char *title); ----------------------------------------- +---- Argomenti: @@ -10976,42 +10756,40 @@ Argomenti: 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]] -Lista nick -~~~~~~~~~~ +=== Lista nick Funzioni per il buffer nicklist. -weechat_nicklist_add_group -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_add_group Aggiunge un gruppo in una lista nick. 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: @@ -11043,40 +10821,39 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -11092,31 +10869,30 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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, @@ -11124,7 +10900,7 @@ struct t_gui_nick_group *weechat_nicklist_add_nick (struct t_gui_buffer *buffer, const char *prefix, const char *prefix_color, int visible); ----------------------------------------- +---- Argomenti: @@ -11157,19 +10933,19 @@ Valore restituito: 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) @@ -11179,21 +10955,20 @@ if nick_away: else: color = "bar_fg" nick = weechat.nicklist_add_nick(my_buffer, my_group, "test_nick", color, "@", "lightgreen", 1) ----------------------------------------- +---- -weechat_nicklist_search_nick -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_search_nick 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: @@ -11209,34 +10984,33 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -11247,33 +11021,32 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -11283,32 +11056,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -11317,23 +11089,22 @@ Argomenti: 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) ----------------------------------------- +---- -weechat_nicklist_get_next_item -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_get_next_item _WeeChat ≥ 0.3.7._ @@ -11343,11 +11114,11 @@ per mostrare la lista nick). Prototipo: [source,C] ----------------------------------------- +---- void weechat_nicklist_get_next_item (struct t_gui_buffer *buffer, struct t_gui_nick_group **group, struct t_gui_nick **nick); ----------------------------------------- +---- Argomenti: @@ -11358,7 +11129,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- struct t_gui_nick_group *ptr_group; struct t_gui_nick *ptr_nick; @@ -11379,13 +11150,12 @@ while (ptr_group || ptr_nick) } weechat_nicklist_get_next_item (buffer, &ptr_group, &ptr_nick); } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_nicklist_group_get_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_group_get_integer _WeeChat ≥ 0.3.4._ @@ -11394,11 +11164,11 @@ Restituisce un valore intero della proprietà di un gruppo. Prototipo: [source,C] ----------------------------------------- +---- int weechat_nicklist_group_get_integer (struct t_gui_buffer *buffer, struct t_gui_nick_group *group, const char *property); ----------------------------------------- +---- Argomenti: @@ -11415,23 +11185,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int visible = weechat_nicklist_group_get_integer (buffer, group, "visible"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.nicklist_group_get_integer(buffer, group, property) # esempio visible = weechat.nicklist_group_get_integer(buffer, group, "visible") ----------------------------------------- +---- -weechat_nicklist_group_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_group_get_string _WeeChat ≥ 0.3.4._ @@ -11440,11 +11209,11 @@ Restituisce il valore stringa della proprietà di un gruppo. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_nicklist_group_get_string (struct t_gui_buffer *buffer, struct t_gui_nick_group *group, const char *property); ----------------------------------------- +---- Argomenti: @@ -11461,23 +11230,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- const char *color = weechat_nicklist_group_get_string (buffer, group, "color"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.nicklist_group_get_string(buffer, group, property) # esempio color = weechat.nicklist_group_get_string(buffer, group, "color") ----------------------------------------- +---- -weechat_nicklist_group_get_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_group_get_pointer _WeeChat ≥ 0.3.4._ @@ -11486,11 +11254,11 @@ Restituisce il valore puntatore della proprietà di un gruppo. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_nicklist_group_get_pointer (struct t_gui_buffer *buffer, struct t_gui_nick_group *group, const char *property); ----------------------------------------- +---- Argomenti: @@ -11506,23 +11274,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_gui_nick_group *parent = weechat_nicklist_group_get_pointer (buffer, group, "parent"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.nicklist_group_get_pointer(buffer, group, property) # esempio parent = weechat.nicklist_group_get_pointer(buffer, group, "parent") ----------------------------------------- +---- -weechat_nicklist_group_set -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_group_set _WeeChat ≥ 0.3.4._ @@ -11531,12 +11298,12 @@ Imposta il valore stringa della proprietà di un gruppo. Prototipo: [source,C] ----------------------------------------- +---- void weechat_nicklist_group_set (struct t_gui_buffer *buffer, struct t_gui_nick_group *group, const char *property, const char *value); ----------------------------------------- +---- Argomenti: @@ -11545,7 +11312,7 @@ Argomenti: * 'property' e 'value': nome della proprietà, con il suo valore: [width="100%",cols="^2,4,8",options="header"] -|======================================== +|=== | Nome | Valore | Descrizione | color | nome per l'opzione del colore per WeeChat | @@ -11554,12 +11321,12 @@ Argomenti: | visible | "0", "1" | "0" = gruppo nascosto, "1" = gruppo visibile -|======================================== +|=== Esempio in C: [source,C] ----------------------------------------- +---- /* cambia colore del gruppo a "bar_fg" */ weechat_nicklist_group_set (buffer, group, "color", "bar_fg"); @@ -11568,12 +11335,12 @@ weechat_nicklist_group_set (buffer, group, "color", "yellow"); /* nasconde gruppo nella lista nick */ weechat_nicklist_group_set (buffer, group, "visible", "0"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.nicklist_group_set(buffer, group, property, value) @@ -11587,10 +11354,9 @@ weechat.nicklist_group_set(buffer, group, "color", "yellow") # nasconde gruppo nella lista nick weechat.nicklist_group_set(buffer, group, "visible", "0") ----------------------------------------- +---- -weechat_nicklist_nick_get_integer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_nick_get_integer _WeeChat ≥ 0.3.4._ @@ -11599,11 +11365,11 @@ Restituisce il valore intero della proprietà di un nick. Prototipo: [source,C] ----------------------------------------- +---- int weechat_nicklist_nick_get_integer (struct t_gui_buffer *buffer, struct t_gui_nick *nick, const char *property); ----------------------------------------- +---- Argomenti: @@ -11619,23 +11385,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int visible = weechat_nicklist_nick_get_integer (buffer, nick, "visible"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.nicklist_nick_get_integer(buffer, nick, property) # esempio visible = weechat.nicklist_nick_get_integer(buffer, nick, "visible") ----------------------------------------- +---- -weechat_nicklist_nick_get_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_nick_get_string _WeeChat ≥ 0.3.4._ @@ -11644,11 +11409,11 @@ Restituisce il valore stringa della proprietà di un nick. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_nicklist_nick_get_string (struct t_gui_buffer *buffer, struct t_gui_nick *nick, const char *property); ----------------------------------------- +---- Argomenti: @@ -11667,23 +11432,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- const char *color = weechat_nicklist_nick_get_string (buffer, nick, "color"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.nicklist_nick_get_string(buffer, nick, property) # esempio color = weechat.nicklist_nick_get_string(buffer, nick, "color") ----------------------------------------- +---- -weechat_nicklist_nick_get_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_nick_get_pointer _WeeChat ≥ 0.3.4._ @@ -11692,11 +11456,11 @@ Restituisce il valore puntatore della proprietà di un nick. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_nicklist_nick_get_pointer (struct t_gui_buffer *buffer, struct t_gui_nick *nick, const char *property); ----------------------------------------- +---- Argomenti: @@ -11712,23 +11476,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_gui_nick_group *group = weechat_nicklist_nick_get_pointer (buffer, nick, "group"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.nicklist_nick_get_pointer(buffer, nick, property) # esempio group = weechat.nicklist_nick_get_pointer(buffer, nick, "group") ----------------------------------------- +---- -weechat_nicklist_nick_set -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_nicklist_nick_set _WeeChat ≥ 0.3.4._ @@ -11737,12 +11500,12 @@ Imposta il valore stringa della proprietà di un nick. Prototipo: [source,C] ----------------------------------------- +---- void weechat_nicklist_nick_set (struct t_gui_buffer *buffer, struct t_gui_nick *nick, const char *property, const char *value); ----------------------------------------- +---- Argomenti: @@ -11751,7 +11514,7 @@ Argomenti: * 'property' and 'value': nome della proprietà, con il suo valore: [width="100%",cols="^2,4,8",options="header"] -|======================================== +|=== | Nome | Valore | Descrizione | color | nome per l'opzione del colore di WeeChat | @@ -11767,12 +11530,12 @@ Argomenti: | visible | "0", "1" | "0" = nick nascosto, "1" = nick visibile -|======================================== +|=== Esempi in C: [source,C] ----------------------------------------- +---- /* cambia colore del nick in azzurro */ weechat_nicklist_nick_set (buffer, nick, "color", "cyan"); @@ -11784,12 +11547,12 @@ weechat_nicklist_nick_set (buffer, nick, "prefix_color", "yellow"); /* nascondi nick nella lista nick */ weechat_nicklist_nick_set (buffer, nick, "visible", "0"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.nicklist_nick_set(buffer, nick, property, value) @@ -11806,25 +11569,23 @@ weechat.nicklist_nick_set(buffer, nick, "prefix_color", "yellow") # nascondi nick nella lista nick weechat.nicklist_nick_set(buffer, nick, "visible", "0") ----------------------------------------- +---- [[bars]] -Barre -~~~~~ +=== Barre Funzioni per le barre. -weechat_bar_item_search -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_bar_item_search Cerca un elemento barra. Prototipo: [source,C] ----------------------------------------- +---- struct t_gui_bar_item *weechat_bar_item_search (const char *name); ----------------------------------------- +---- Argomenti: @@ -11837,23 +11598,22 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^ +==== weechat_bar_item_new // TRANSLATION MISSING _Updated in version 0.4.2._ @@ -11863,7 +11623,7 @@ 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, @@ -11871,7 +11631,7 @@ struct t_gui_bar_item *weechat_bar_item_new (const char *name, struct t_gui_buffer *buffer, struct t_hashtable *extra_info), void *build_callback_data); ----------------------------------------- +---- Argomenti: @@ -11901,7 +11661,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char * my_build_callback (void *data, struct t_gui_bar_item *item, @@ -11915,7 +11675,7 @@ my_build_callback (void *data, struct t_gui_bar_item *my_item = weechat_bar_item_new ("myitem", &my_build_callback, NULL); ----------------------------------------- +---- Script (Python): @@ -11928,7 +11688,7 @@ see example below (supported only in WeeChat ≥ 0.4.2). // TRANSLATION MISSING [source,python] ----------------------------------------- +---- # prototipo bar_item = weechat.bar_item_new(name, build_callback, build_callback_data) @@ -11943,10 +11703,9 @@ def my_build_callback2(data, item, window, buffer, extra_info): return "my content" bar_item2 = weechat.bar_item_new("(extra)myitem2", "my_build_callback2", "") # WeeChat ≥ 0.4.2 ----------------------------------------- +---- -weechat_bar_item_update -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_bar_item_update Aggiorna il contenuto dell'elemento barra, chiamando la callback che lo ha compilato. @@ -11954,9 +11713,9 @@ che lo ha compilato. Prototipo: [source,C] ----------------------------------------- +---- void weechat_bar_item_update (const char *name); ----------------------------------------- +---- Argomenti: @@ -11965,32 +11724,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_bar_item_remove Rimuove un elemento barra. Prototipo: [source,C] ----------------------------------------- +---- void weechat_bar_item_remove (struct t_gui_bar_item *item); ----------------------------------------- +---- Argomenti: @@ -11999,32 +11757,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^ +==== weechat_bar_search Cerca una barra. Prototipo: [source,C] ----------------------------------------- +---- struct t_gui_bar *weechat_bar_search (const char *name); ----------------------------------------- +---- Argomenti: @@ -12037,30 +11794,29 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^ +==== 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, @@ -12076,7 +11832,7 @@ struct t_gui_bar *weechat_bar_new (const char *name, const char *color_bg, const char *separator, const char *items); ----------------------------------------- +---- Argomenti: @@ -12131,7 +11887,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_gui_bar *my_bar = weechat_bar_new ("mybar", "off", "100", @@ -12147,12 +11903,12 @@ struct t_gui_bar *my_bar = weechat_bar_new ("mybar", "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, @@ -12161,20 +11917,19 @@ bar = weechat.bar_new(name, hidden, priority, type, condition, position, # 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 -^^^^^^^^^^^^^^^ +==== 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: @@ -12191,32 +11946,31 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^ +==== weechat_bar_update Aggiorna il contenuto di una barra su schermo. Prototipo: [source,C] ----------------------------------------- +---- void weechat_bar_update (const char *name); ----------------------------------------- +---- Argomenti: @@ -12225,32 +11979,31 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^ +==== weechat_bar_remove Rimuove una barra. Prototipo: [source,C] ----------------------------------------- +---- void weechat_bar_remove (struct t_gui_bar *bar); ----------------------------------------- +---- Argomenti: @@ -12259,38 +12012,36 @@ Argomenti: 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 -~~~~~~~ +=== Comandi Funzioni per eseguire comandi di WeeChat. -weechat_command -^^^^^^^^^^^^^^^ +==== weechat_command Esegue un comando. Prototipo: [source,C] ----------------------------------------- +---- void weechat_command (struct t_gui_buffer *buffer, const char *command); ----------------------------------------- +---- Argomenti: @@ -12302,30 +12053,28 @@ Argomenti: 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 -~~~~~~~ +=== Network Funzioni di rete. -weechat_network_pass_proxy -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_network_pass_proxy Stabilisce una connessione/autenticazione con un proxy. @@ -12337,12 +12086,12 @@ process only, to not block WeeChat. Prototipo: [source,C] ----------------------------------------- +---- int weechat_network_pass_proxy (const char *proxy, int sock, const char *address, int port); ----------------------------------------- +---- Argomenti: @@ -12359,7 +12108,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_network_pass_proxy ("my_proxy", sock, "irc.freenode.net", 6667)) { /* OK */ @@ -12368,13 +12117,12 @@ else { /* errore */ } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_network_connect_to -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_network_connect_to Stabilisce una connessione con un host remoto. @@ -12386,12 +12134,12 @@ process only, to not block WeeChat. Prototipo: [source,C] ----------------------------------------- +---- int weechat_network_connect_to (const char *proxy, int sock, unsigned long address, int port); ----------------------------------------- +---- Argomenti: @@ -12408,7 +12156,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct sockaddr_in addr; socklen_t length; unsigned long address; @@ -12427,28 +12175,26 @@ else { /* errore */ } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. [[infos]] -Info -~~~~ +=== Info Funzioni per ottenere info. -weechat_info_get -^^^^^^^^^^^^^^^^ +==== weechat_info_get Restituisce la info, come stringa, da WeeChat o da un plugin. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_info_get (const char *info_name, const char *arguments); ----------------------------------------- +---- Argomenti: @@ -12464,18 +12210,18 @@ Valore restituito: 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", NULL)); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.info_get(info_name, arguments) @@ -12483,10 +12229,9 @@ value = weechat.info_get(info_name, arguments) 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")) ----------------------------------------- +---- -weechat_info_get_hashtable -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_info_get_hashtable _WeeChat ≥ 0.3.4._ @@ -12495,10 +12240,10 @@ Restituisce una info, come tabella hash, da WeeChat o da un plugin. Prototipo: [source,C] ----------------------------------------- +---- struct t_hashtable *weechat_info_get_hashtable (const char *info_name, struct t_hashtable *hashtable); ----------------------------------------- +---- Argomenti: @@ -12514,7 +12259,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hashtable *hashtable_in, *hashtable_out; hashtable_in = weechat_hashtable_new (8, @@ -12539,12 +12284,12 @@ if (hashtable_in) weechat_hashtable_free (hashtable_in); weechat_hashtable_free (hashtable_out); } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo dict = weechat.info_get_hashtable(info_name, dict_in) @@ -12552,11 +12297,10 @@ dict = weechat.info_get_hashtable(info_name, dict_in) dict_in = { "message": ":nick!user@host PRIVMSG #weechat :message here" } weechat.prnt("", "message parsed: %s" % weechat.info_get_hashtable("irc_message_parse", dict_in)) ----------------------------------------- +---- [[infolists]] -Liste info -~~~~~~~~~~ +=== Liste info Una lista info è una lista di "elementi". Ciascun elemento contiene delle variabili. @@ -12573,17 +12317,16 @@ Ogni variabile ha un tipo e un valore. I tipi possibili sono: * 'buffer': buffer di lunghezza fissa, contenente qualunque dato * 'time': valore tempo -weechat_infolist_new -^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new Crea una nuova lista info. Prototipo: [source,C] ----------------------------------------- +---- struct t_infolist *weechat_infolist_new (); ----------------------------------------- +---- Valore restituito: @@ -12592,32 +12335,31 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -12630,23 +12372,22 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new_var_integer Aggiunge una variabile intera ad un elemento della lista info. @@ -12654,11 +12395,11 @@ 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: @@ -12673,25 +12414,24 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new_var_string Aggiunge una variabile stringa ad un elemento della lista info. @@ -12699,11 +12439,11 @@ 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: @@ -12718,25 +12458,24 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_new_var_pointer Aggiunge una variabile puntatore ad un elemento della lista info. @@ -12744,11 +12483,11 @@ 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: @@ -12763,37 +12502,36 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -12809,31 +12547,30 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- char buffer[256]; /* ... */ struct t_infolist_var *var = weechat_infolist_new_var_buffer (item, "my_buffer", &buffer, sizeof (buffer)); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_infolist_new_var_time -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -12848,25 +12585,24 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_infolist_var *var = weechat_infolist_new_var_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 -^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_get Restituisce una lista info da WeeChat o da un plugin. @@ -12881,11 +12617,11 @@ info potrebbero avere più info di hdata, che sono dati raw), consultare <<hdata Prototipo: [source,C] ----------------------------------------- +---- struct t_infolist *weechat_infolist_get (const char *infolist_name, void *pointer, const char *arguments); ----------------------------------------- +---- Argomenti: @@ -12903,23 +12639,22 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^ +==== 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 @@ -12928,9 +12663,9 @@ nella lista info. Prototipo: [source,C] ----------------------------------------- +---- int weechat_infolist_next (struct t_infolist *infolist); ----------------------------------------- +---- Argomenti: @@ -12944,7 +12679,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_infolist_next (infolist)) { /* legge variabili nell'elemento... */ @@ -12953,12 +12688,12 @@ else { /* nessun altro elemento disponibile */ } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.infolist_next(infolist) @@ -12968,10 +12703,9 @@ if rc: # legge variabili nell'elemento... else: # nessun altro elemento disponibile ----------------------------------------- +---- -weechat_infolist_prev -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_prev Sposta "cursor" all'elemento precedente nella lista info. La prima chiamata a questa funzione per una lista info sposta il cursore @@ -12980,9 +12714,9 @@ all'ultimo elemento. Prototipo: [source,C] ----------------------------------------- +---- int weechat_infolist_prev (struct t_infolist *infolist); ----------------------------------------- +---- Argomenti: @@ -12996,7 +12730,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_infolist_prev (infolist)) { /* legge variabili nell'elemento... */ @@ -13005,12 +12739,12 @@ else { /* nessun altro elemento disponibile */ } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.infolist_prev(infolist) @@ -13020,19 +12754,18 @@ if rc: # read variables in item... else: # no more item available ----------------------------------------- +---- -weechat_infolist_reset_item_cursor -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -13041,23 +12774,22 @@ Argomenti: 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 -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_fields Restituisce una lista di campi per l'elemento della lista info corrente. @@ -13065,9 +12797,9 @@ lista info corrente. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_infolist_fields (struct t_infolist *infolist); ----------------------------------------- +---- Argomenti: @@ -13083,16 +12815,16 @@ Valore restituito: 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) @@ -13100,10 +12832,9 @@ fields = weechat.infolist_fields(infolist) 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 -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_integer Restituisce il valore della variabile intera nell'elemento corrente della lista info. @@ -13111,9 +12842,9 @@ corrente della lista info. Prototipo: [source,C] ----------------------------------------- +---- int weechat_infolist_integer (struct t_infolist *infolist, const char *var); ----------------------------------------- +---- Argomenti: @@ -13127,24 +12858,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "integer = %d", weechat_infolist_integer (infolist, "my_integer")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.infolist_integer(infolist, var) # esempio weechat.prnt("", "integer = %d" % weechat.infolist_integer(infolist, "my_integer")) ----------------------------------------- +---- -weechat_infolist_string -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_string Restituisce il valore della variabile stringa nell'elemento della lista info corrente. @@ -13152,9 +12882,9 @@ della lista info corrente. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_infolist_string (struct t_infolist *infolist, const char *var); ----------------------------------------- +---- Argomenti: @@ -13168,24 +12898,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "string = %s", weechat_infolist_string (infolist, "my_string")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.infolist_string(infolist, var) # esempio weechat.prnt("", "string = %s" % weechat.infolist_string(infolist, "my_string")) ----------------------------------------- +---- -weechat_infolist_pointer -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_pointer Restituisce il valore della variabile puntatore nell'elemento della lista info corrente. @@ -13193,9 +12922,9 @@ della lista info corrente. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_infolist_pointer (struct t_infolist *infolist, const char *var); ----------------------------------------- +---- Argomenti: @@ -13209,24 +12938,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "pointer = 0x%lx", weechat_infolist_pointer (infolist, "my_pointer")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.infolist_pointer(infolist, var) # esempio weechat.prnt("", "pointer = 0x%s" % weechat.infolist_pointer(infolist, "my_pointer")) ----------------------------------------- +---- -weechat_infolist_buffer -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_buffer Restituisce il valore della variabile buffer nell'elemento corrente della lista info. @@ -13234,10 +12962,10 @@ della lista info. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_infolist_buffer (struct t_infolist *infolist, const char *var, int *size); ----------------------------------------- +---- Argomenti: @@ -13253,18 +12981,17 @@ Valore restituito: 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); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_infolist_time -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_time Restituisce il valore della variabile data/ora nell'elemento attivo della lista info. @@ -13272,9 +12999,9 @@ attivo della lista info. Prototipo: [source,C] ----------------------------------------- +---- time_t weechat_infolist_time (struct t_infolist *infolist, const char *var); ----------------------------------------- +---- Argomenti: @@ -13288,33 +13015,32 @@ Valore restituito: 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 -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_infolist_free Libera una lista info. Prototipo: [source,C] ----------------------------------------- +---- void weechat_infolist_free (struct t_infolist *infolist); ----------------------------------------- +---- Argomenti: @@ -13323,24 +13049,23 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- weechat_infolist_free (infolist); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo weechat.infolist_free(infolist) # esempio weechat.infolist_free(infolist) ----------------------------------------- +---- [[hdata]] -Hdata -~~~~~ +=== Hdata Funzioni per hdata (accesso raw a WeeChat o ai dati dei plugin). @@ -13348,8 +13073,7 @@ Funzioni per hdata (accesso raw a WeeChat o ai dati dei plugin). Hdata fornisce un accesso in sola lettura ai dati. È *SEVERAMENTE VIETATO* scrivere qualcosa in memoria puntato dalle variabili in hdata. -weechat_hdata_new -^^^^^^^^^^^^^^^^^ +==== weechat_hdata_new // TRANSLATION MISSING _WeeChat ≥ 0.3.6, updated in 0.3.9 and 0.4.0._ @@ -13358,7 +13082,7 @@ Crea un nuovo hdata. [NOTE] .hdata vs infolist -======================================== +==== Hdata è un metodo veloce per leggere i dati di WeeChat o dei plugin. È simile alle liste info, ma ci sono alcune differenze: @@ -13366,12 +13090,12 @@ alle liste info, ma ci sono alcune differenze: * può contenere informazioni differenti rispetto alle liste info: esso contiene solo dati raw in strutture (le liste info possono aggiungere alcuni dati extra per convenienza) -======================================== +==== Prototipo: [source,C] ----------------------------------------- +---- struct t_hdata *weechat_hdata_new (const char *hdata_name, const char *var_prev, const char *var_next, int create_allowed, int delete_allowed, int (*callback_update)(void *data, @@ -13379,7 +13103,7 @@ struct t_hdata *weechat_hdata_new (const char *hdata_name, const char *var_prev, void *pointer, struct t_hashtable *hashtable), void *callback_update_data); ----------------------------------------- +---- Argomenti: @@ -13412,15 +13136,14 @@ Valore restituito: Esempio in C: source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_new ("myplugin_list", "prev", "next", 0, 0, &callback_update, NULL); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hdata_new_var -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_new_var // TRANSLATION MISSING _WeeChat ≥ 0.3.6, updated in 0.3.9_ @@ -13430,10 +13153,10 @@ Crea una nuova variabile in hdata. Prototipo: [source,C] ----------------------------------------- +---- void weechat_hdata_new_var (struct t_hdata *hdata, const char *name, int offset, int type, int update_allowed, const char *array_size, const char *hdata_name); ----------------------------------------- +---- Argomenti: @@ -13465,7 +13188,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- struct t_myplugin_list { char *name; @@ -13487,12 +13210,12 @@ weechat_hdata_new_var (hdata, "tags_array", offsetof (struct t_myplugin_list, ta weechat_hdata_new_var (hdata, "string_split", offsetof (struct t_myplugin_list, string_split), WEECHAT_HDATA_STRING, 0, "*", NULL); weechat_hdata_new_var (hdata, "prev", offsetof (struct t_myplugin_list, prev), WEECHAT_HDATA_POINTER, 0, NULL, "myplugin_list"); weechat_hdata_new_var (hdata, "next", offsetof (struct t_myplugin_list, next), WEECHAT_HDATA_POINTER, 0, NULL, "myplugin_list"); ----------------------------------------- +---- La macro "WEECHAT_HDATA_VAR" può essere usata per accorciare il codice: [source,C] ----------------------------------------- +---- WEECHAT_HDATA_VAR(struct t_myplugin_list, name, STRING, 0, NULL, NULL); WEECHAT_HDATA_VAR(struct t_myplugin_list, buffer, POINTER, 0, NULL, NULL); WEECHAT_HDATA_VAR(struct t_myplugin_list, tags_count, INTEGER, 0, NULL, NULL); @@ -13500,13 +13223,12 @@ WEECHAT_HDATA_VAR(struct t_myplugin_list, tags_array, STRING, 0, "tags_count", N WEECHAT_HDATA_VAR(struct t_myplugin_list, string_split, STRING, 0, "*", NULL); WEECHAT_HDATA_VAR(struct t_myplugin_list, prev, POINTER, 0, NULL, "myplugin_list"); WEECHAT_HDATA_VAR(struct t_myplugin_list, next, POINTER, 0, NULL, "myplugin_list"); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hdata_new_list -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_new_list _WeeChat ≥ 0.3.6._ @@ -13515,9 +13237,9 @@ Crea una nuovo puntatore alla lista in hdata. Prototipo: [source,C] ----------------------------------------- +---- void weechat_hdata_new_list (struct t_hdata *hdata, const char *name, void *pointer); ----------------------------------------- +---- Argomenti: @@ -13528,7 +13250,7 @@ Argomenti: Esempio in C: [source,C] ----------------------------------------- +---- struct t_myplugin_list { char *name; @@ -13553,21 +13275,20 @@ weechat_hdata_new_var (hdata, "next", offsetof (struct t_myplugin_list, next), W weechat_hdata_new_list (hdata, "buffers", &buffers); weechat_hdata_new_list (hdata, "last_buffer", &last_buffer); ----------------------------------------- +---- La macro "WEECHAT_HDATA_LIST" può essere usata per accorciare il codice: [source,C] ----------------------------------------- +---- WEECHAT_HDATA_LIST(buffers); WEECHAT_HDATA_LIST(last_buffer); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hdata_get -^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get _WeeChat ≥ 0.3.6._ @@ -13581,9 +13302,9 @@ un oggetto di WeeChat/plugin per leggere dei dati. Prototipo: [source,C] ----------------------------------------- +---- struct t_hdata *weechat_hdata_get (const char *hdata_name); ----------------------------------------- +---- Argomenti: @@ -13601,23 +13322,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("irc_server"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hdata = weechat.hdata_get(hdata_name) # esempio hdata = weechat.hdata_get("irc_server") ----------------------------------------- +---- -weechat_hdata_get_var_offset -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_offset _WeeChat ≥ 0.3.6._ @@ -13626,9 +13346,9 @@ Restituisce l'offset della variabile in hdata. Prototipo: [source,C] ----------------------------------------- +---- int weechat_hdata_get_var_offset (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Argomenti: @@ -13642,23 +13362,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int offset = weechat_hdata_get_var_offset (hdata, "name"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo offset = weechat.hdata_get_var_offset(hdata, name) # esempio offset = weechat.hdata_get_var_offset(hdata, "name") ----------------------------------------- +---- -weechat_hdata_get_var_type -^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_type _WeeChat ≥ 0.3.6._ @@ -13667,9 +13386,9 @@ Restituisce il tipo di variabile in hdata (come intero). Prototipo: [source,C] ----------------------------------------- +---- int weechat_hdata_get_var_type (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Argomenti: @@ -13683,7 +13402,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int type = weechat_hdata_get_var_type (hdata, "name"); switch (type) { @@ -13715,13 +13434,12 @@ switch (type) /* variable not found */ break; } ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hdata_get_var_type_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_type_string _WeeChat ≥ 0.3.6._ @@ -13730,9 +13448,9 @@ Restituisce il tipo di variabile in hdata (come stringa). Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_hdata_get_var_type_string (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Argomenti: @@ -13746,24 +13464,23 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "type = %s", weechat_hdata_get_var_type_string (hdata, "name")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo type = weechat.hdata_get_var_type_string(hdata, name) # esempio weechat.prnt("", "type = %s" % weechat.hdata_get_var_type_string(hdata, "name")) ----------------------------------------- +---- -weechat_hdata_get_var_array_size -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_array_size _WeeChat ≥ 0.3.9._ @@ -13773,9 +13490,9 @@ Return array size for variable in hdata. Prototipo: [source,C] ----------------------------------------- +---- int weechat_hdata_get_var_array_size (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -13791,23 +13508,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int array_size = weechat_hdata_get_var_array_size (hdata, pointer, "name"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo array_size = weechat.hdata_get_var_array_size(hdata, pointer, name) # esempio array_size = weechat.hdata_get_var_array_size(hdata, pointer, "name") ----------------------------------------- +---- -weechat_hdata_get_var_array_size_string -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_array_size_string _WeeChat ≥ 0.3.9._ @@ -13817,10 +13533,10 @@ Return array size for variable in hdata (as string). Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_hdata_get_var_array_size_string (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -13837,23 +13553,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- const char *array_size = weechat_hdata_get_var_array_size_string (hdata, pointer, "name"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo array_size = weechat.hdata_get_var_array_size_string(hdata, pointer, name) # esempio array_size = weechat.hdata_get_var_array_size_string(hdata, pointer, "name") ----------------------------------------- +---- -weechat_hdata_get_var_hdata -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_hdata _WeeChat ≥ 0.3.6._ @@ -13862,9 +13577,9 @@ Restituisce hdata per la variabile in hdata. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_hdata_get_var_hdata (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Argomenti: @@ -13878,23 +13593,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "hdata = %s", weechat_hdata_get_var_hdata (hdata, "name")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hdata_name = weechat.hdata_get_var_hdata(hdata, name) # esempio weechat.prnt("", "hdata = %s" % weechat.hdata_get_var_hdata(hdata, "name")) ----------------------------------------- +---- -weechat_hdata_get_var -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var _WeeChat ≥ 0.3.6._ @@ -13903,9 +13617,9 @@ Restituisce il puntatore al contenuto della variabile in hdata. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_hdata_get_var (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -13920,17 +13634,16 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); void *pointer = weechat_hdata_get_var (hdata, buffer, "name"); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hdata_get_var_at_offset -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_var_at_offset _WeeChat ≥ 0.3.6._ @@ -13939,9 +13652,9 @@ Restituisce il puntatore al contenuto della variabile in hdata, usando un offset Prototipo: [source,C] ----------------------------------------- +---- void *weechat_hdata_get_var_at_offset (struct t_hdata *hdata, void *pointer, int offset); ----------------------------------------- +---- Argomenti: @@ -13956,18 +13669,17 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); int offset = weechat_hdata_get_var_offset (hdata, "name"); void *pointer = weechat_hdata_get_var_at_offset (hdata, buffer, offset); ----------------------------------------- +---- [NOTE] Questa funzione non è disponibile nelle API per lo scripting. -weechat_hdata_get_list -^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_list _WeeChat ≥ 0.3.6._ @@ -13976,9 +13688,9 @@ Restituisce il puntatore alla lista da hdata. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_hdata_get_list (struct t_hdata *hdata, const char *name); ----------------------------------------- +---- Argomenti: @@ -13992,25 +13704,24 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffers = weechat_hdata_get_list (hdata, "gui_buffers"); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo list = weechat.hdata_get_list(hdata, name) # esempio hdata = weechat.hdata_get("buffer") buffers = weechat.hdata_get_list(hdata, "gui_buffers") ----------------------------------------- +---- -weechat_hdata_check_pointer -^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_check_pointer _WeeChat ≥ 0.3.7._ @@ -14019,9 +13730,9 @@ Verifica se un puntatore è valido per un hdata e un puntatore della lista. Prototipo: [source,C] ----------------------------------------- +---- int weechat_hdata_check_pointer (struct t_hdata *hdata, void *list, void *pointer); ----------------------------------------- +---- Argomenti: @@ -14036,7 +13747,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- /* check if a buffer pointer is valid */ struct t_hdata *hdata = weechat_hdata_get ("buffer"); if (weechat_hdata_check_pointer (hdata, @@ -14049,12 +13760,12 @@ else { /* invalid pointer */ } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.hdata_check_pointer(hdata, list, pointer) @@ -14066,10 +13777,9 @@ if weechat.hdata_check_pointer(hdata, weechat.hdata_get_list(hdata, "gui_buffers else: # invalid pointer # ... ----------------------------------------- +---- -weechat_hdata_move -^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_move _WeeChat ≥ 0.3.6._ @@ -14078,9 +13788,9 @@ Sposta il puntatore ad un altro elemento nella lista. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_hdata_move (struct t_hdata *hdata, void *pointer, int count); ----------------------------------------- +---- Argomenti: @@ -14096,7 +13806,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); @@ -14106,12 +13816,12 @@ buffer = weechat_hdata_move (hdata, buffer, 2); /* passa al buffer precedente */ if (buffer) buffer = weechat_hdata_move (hdata, buffer, -1); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo pointer = weechat.hdata_move(hdata, pointer, count) @@ -14125,10 +13835,9 @@ buffer = weechat.hdata_move(hdata, buffer, 2) # passa al buffer precedente if buffer: buffer = weechat.hdata_move(hdata, buffer, -1) ----------------------------------------- +---- -weechat_hdata_search -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_search _WeeChat ≥ 0.4.1._ @@ -14139,9 +13848,9 @@ in list, until element is found (or end of list). Prototipo: [source,C] ----------------------------------------- +---- void *weechat_hdata_search (struct t_hdata *hdata, void *pointer, const char *search, int move); ----------------------------------------- +---- Argomenti: @@ -14163,7 +13872,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("irc_server"); void *servers = weechat_hdata_get (hdata, "irc_servers"); @@ -14173,13 +13882,13 @@ if (server) { /* ... */ } ----------------------------------------- +---- Script (Python): // TRANSLATION MISSING [source,python] ----------------------------------------- +---- # prototipo pointer = weechat.hdata_search(hdata, pointer, search, count) @@ -14191,10 +13900,9 @@ servers = weechat.hdata_get_list(hdata, "irc_servers") server = weechat.hdata_search(hdata, servers, "${irc_server.name} == freenode", 1) if server: # ... ----------------------------------------- +---- -weechat_hdata_char -^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_char _WeeChat ≥ 0.3.7._ @@ -14203,9 +13911,9 @@ Restituisce il valore di una variabile char in una struttura dati usando hdata. Prototipo: [source,C] ----------------------------------------- +---- char weechat_hdata_char (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -14223,23 +13931,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "letter = %c", weechat_hdata_char (hdata, pointer, "letter")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.hdata_char(hdata, pointer, name) # esempio weechat.prnt("", "letter = %c" % weechat.hdata_char(hdata, pointer, "letter")) ----------------------------------------- +---- -weechat_hdata_integer -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_integer _WeeChat ≥ 0.3.6._ @@ -14248,9 +13955,9 @@ Restituisce il valore di una variabile integer in una struttura dati usando hdat Prototipo: [source,C] ----------------------------------------- +---- int weechat_hdata_integer (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -14268,16 +13975,16 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); weechat_printf (NULL, "number = %d", weechat_hdata_integer (hdata, buffer, "number")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.hdata_integer(hdata, pointer, name) @@ -14285,10 +13992,9 @@ value = weechat.hdata_integer(hdata, pointer, name) hdata = weechat.hdata_get("buffer") buffer = weechat.buffer_search_main() weechat.prnt("", "number = %d" % weechat.hdata_integer(hdata, buffer, "number")) ----------------------------------------- +---- -weechat_hdata_long -^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_long _WeeChat ≥ 0.3.6._ @@ -14297,9 +14003,9 @@ Restituisce il valore della variabile long della struttura usando hdata. Prototipo: [source,C] ----------------------------------------- +---- long weechat_hdata_long (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -14317,23 +14023,22 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "longvar = %ld", weechat_hdata_long (hdata, pointer, "longvar")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.hdata_long(hdata, pointer, name) # esempio weechat.prnt("", "longvar = %ld" % weechat.hdata_long(hdata, pointer, "longvar")) ----------------------------------------- +---- -weechat_hdata_string -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_string _WeeChat ≥ 0.3.6._ @@ -14342,9 +14047,9 @@ Restituisce il valore della variabile string nella struttura usando hdata. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_hdata_string (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -14362,16 +14067,16 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); weechat_printf (NULL, "name = %s", weechat_hdata_string (hdata, buffer, "name")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.hdata_string(hdata, pointer, name) @@ -14379,10 +14084,9 @@ value = weechat.hdata_string(hdata, pointer, name) hdata = weechat.hdata_get("buffer") buffer = weechat.buffer_search_main() weechat.prnt("", "name = %s" % weechat.hdata_string(hdata, buffer, "name")) ----------------------------------------- +---- -weechat_hdata_pointer -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_pointer _WeeChat ≥ 0.3.6._ @@ -14391,9 +14095,9 @@ Restituisce il valore della variabile puntatore nella struttura usando hdata. Prototipo: [source,C] ----------------------------------------- +---- void *weechat_hdata_pointer (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -14411,16 +14115,16 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); weechat_printf (NULL, "lines = %lx", weechat_hdata_pointer (hdata, buffer, "lines")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.hdata_pointer(hdata, pointer, name) @@ -14428,10 +14132,9 @@ value = weechat.hdata_pointer(hdata, pointer, name) hdata = weechat.hdata_get("buffer") buffer = weechat.buffer_search_main() weechat.prnt("", "lines = %lx" % weechat.hdata_pointer(hdata, buffer, "lines")) ----------------------------------------- +---- -weechat_hdata_time -^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_time _WeeChat ≥ 0.3.6._ @@ -14440,9 +14143,9 @@ Restituisce il valore della variabile time nella struttura usando hdata. Prototipo: [source,C] ----------------------------------------- +---- time_t weechat_hdata_time (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -14460,7 +14163,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *ptr = weechat_buffer_search_main (); ptr = weechat_hdata_pointer (hdata, ptr, "lines"); @@ -14480,12 +14183,12 @@ if (ptr) } } } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.hdata_time(hdata, pointer, name) @@ -14499,10 +14202,9 @@ if ptr: if ptr: date = weechat.hdata_time(weechat.hdata_get("line_data"), ptr, "date") weechat.prnt("", "time of first line displayed = %s" % time.strftime("%F %T", time.localtime(int(date)))) ----------------------------------------- +---- -weechat_hdata_hashtable -^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_hashtable _WeeChat ≥ 0.3.7._ @@ -14512,9 +14214,9 @@ hdata. Prototipo: [source,C] ----------------------------------------- +---- struct t_hashtable *weechat_hdata_hashtable (struct t_hdata *hdata, void *pointer, const char *name); ----------------------------------------- +---- Argomenti: @@ -14532,18 +14234,18 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_hdata *hdata = weechat_hdata_get ("buffer"); struct t_gui_buffer *buffer = weechat_buffer_search_main (); struct t_hashtable *hashtable = weechat_hdata_hashtable (hdata, buffer, "local_variables"); weechat_printf (NULL, "%d local variables in core buffer", weechat_hashtable_get_integer (hashtable, "items_count")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo hashtable = weechat.hdata_hashtable(hdata, pointer, name) @@ -14554,11 +14256,10 @@ hash = weechat.hdata_hashtable(hdata, buffer, "local_variables") weechat.prnt("", "local variables in core buffer:") for key in hash: weechat.prnt("", " %s == %s" % (key, hash[key])) ----------------------------------------- +---- // TRANSLATION MISSING -weechat_hdata_set -^^^^^^^^^^^^^^^^^ +==== weechat_hdata_set _WeeChat ≥ 0.3.9._ @@ -14572,9 +14273,9 @@ This function can be called only in an update callback Prototipo: [source,C] ----------------------------------------- +---- int weechat_hdata_set (struct t_hdata *hdata, void *pointer, const char *name, const char *value); ----------------------------------------- +---- Argomenti: @@ -14591,16 +14292,15 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_hdata_set (hdata, pointer, "message", "test"); ----------------------------------------- +---- [NOTE] This function is not available in scripting API. // TRANSLATION MISSING -weechat_hdata_update -^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_update _WeeChat ≥ 0.3.9._ @@ -14609,9 +14309,9 @@ Update data in a hdata. Prototipo: [source,C] ----------------------------------------- +---- int weechat_hdata_update (struct t_hdata *hdata, void *pointer, struct t_hashtable *hashtable); ----------------------------------------- +---- Argomenti: @@ -14636,7 +14336,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- /* subtract one hour on last message displayed in current buffer */ struct t_gui_lines *own_lines; @@ -14668,12 +14368,12 @@ if (own_lines) } } } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo count = weechat.hdata_update(hdata, pointer, hashtable) @@ -14685,10 +14385,9 @@ if own_lines: line_data = weechat.hdata_pointer(weechat.hdata_get('line'), line, 'data') hdata = weechat.hdata_get('line_data') weechat.hdata_update(hdata, line_data, { 'date': str(weechat.hdata_time(hdata, line_data, 'date') - 3600) }) ----------------------------------------- +---- -weechat_hdata_get_string -^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_hdata_get_string _WeeChat ≥ 0.3.6._ @@ -14697,9 +14396,9 @@ Restituisce il valore stringa di una proprietà di hdata. Prototipo: [source,C] ----------------------------------------- +---- const char *weechat_hdata_get_string (struct t_hdata *hdata, const char *property); ----------------------------------------- +---- Argomenti: @@ -14729,40 +14428,38 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- weechat_printf (NULL, "variables in hdata: %s", weechat_hdata_get_string (hdata, "var_keys")); weechat_printf (NULL, "lists in hdata: %s", weechat_hdata_get_string (hdata, "list_keys")); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo value = weechat.hdata_get_string(hdata, property) # esempio weechat.prnt("", "variables in hdata: %s" % weechat.hdata_get_string(hdata, "var_keys")) weechat.prnt("", "lists in hdata: %s" % weechat.hdata_get_string(hdata, "list_keys")) ----------------------------------------- +---- [[upgrade]] -Aggiornamento -~~~~~~~~~~~~~ +=== Aggiornamento Funzioni per l'aggiornamento di WeeChat (comando "/upgrade"). -weechat_upgrade_new -^^^^^^^^^^^^^^^^^^^ +==== 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: @@ -14779,34 +14476,33 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- struct t_upgrade_file *upgrade_file = weechat_upgrade_new ("my_file", 1); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo upgrade_file = weechat.upgrade_new(filename, write) # esempio upgrade_file = weechat.upgrade_new("my_file", 1) ----------------------------------------- +---- -weechat_upgrade_write_object -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +==== weechat_upgrade_write_object Scrive un oggetto nel file di aggiornamento. Prototipo: [source,C] ----------------------------------------- +---- int weechat_upgrade_write_object (struct t_upgrade_file *upgrade_file, int object_id, struct t_infolist *infolist); ----------------------------------------- +---- Argomenti: @@ -14821,7 +14517,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- if (weechat_upgrade_write_object (upgrade_file, 1, &infolist)) { /* ok */ @@ -14830,35 +14526,34 @@ else { /* errore */ } ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.upgrade_write_object(upgrade_file, object_id, infolist) # esempio weechat.upgrade_write_object(upgrade_file, 1, infolist) ----------------------------------------- +---- -weechat_upgrade_read -^^^^^^^^^^^^^^^^^^^^ +==== weechat_upgrade_read Legge un file di aggiornamento. Prototipo: [source,C] ----------------------------------------- +---- int weechat_upgrade_read (struct t_upgrade_file *upgrade_file, int (*callback_read)(void *data, struct t_upgrade_file *upgrade_file, int object_id, struct t_infolist *infolist), void *callback_read_data); ----------------------------------------- +---- Argomenti: @@ -14882,7 +14577,7 @@ Valore restituito: Esempio in C: [source,C] ----------------------------------------- +---- int my_upgrade_read_cb (struct t_upgrade_file *upgrade_file, int object_id, @@ -14893,12 +14588,12 @@ my_upgrade_read_cb (struct t_upgrade_file *upgrade_file, } weechat_upgrade_read (upgrade_file, &my_upgrade_read_cb, NULL); ----------------------------------------- +---- Script (Python): [source,python] ----------------------------------------- +---- # prototipo rc = weechat.upgrade_read(upgrade_file, callback_read, callback_read_data) @@ -14908,19 +14603,18 @@ def my_upgrade_read_cb(upgrade_file, object_id, infolist): return weechat.WEECHAT_RC_OK weechat.upgrade_read(upgrade_file, "my_upgrade_read_cb", "")) ----------------------------------------- +---- -weechat_upgrade_close -^^^^^^^^^^^^^^^^^^^^^ +==== weechat_upgrade_close Chiude un file di aggiornamento. Prototipo: [source,C] ----------------------------------------- +---- void weechat_upgrade_close (struct t_upgrade_file *upgrade_file); ----------------------------------------- +---- Argomenti: @@ -14929,17 +14623,17 @@ Argomenti: 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) ----------------------------------------- +---- |