void
script_buffer_get_window_info (struct t_gui_window *window,
int *start_line_y, int *chat_height)
{
struct t_hdata *hdata_window, *hdata_window_scroll, *hdata_line;
struct t_hdata *hdata_line_data;
void *window_scroll, *start_line, *line_data;
hdata_window = weechat_hdata_get ("window");
hdata_window_scroll = weechat_hdata_get ("window_scroll");
hdata_line = weechat_hdata_get ("line");
hdata_line_data = weechat_hdata_get ("line_data");
*start_line_y = 0;
window_scroll = weechat_hdata_pointer (hdata_window, window, "scroll");
if (window_scroll)
{
start_line = weechat_hdata_pointer (hdata_window_scroll, window_scroll,
"start_line");
if (start_line)
{
line_data = weechat_hdata_pointer (hdata_line, start_line, "data");
if (line_data)
{
*start_line_y = weechat_hdata_integer (hdata_line_data,
line_data, "y");
}
}
}
*chat_height = weechat_hdata_integer (hdata_window, window,
"win_chat_height");
}
void
relay_weechat_nicklist_add_item (struct t_relay_weechat_nicklist *nicklist,
char diff, struct t_gui_nick_group *group,
struct t_gui_nick *nick)
{
struct t_relay_weechat_nicklist_item *new_items, *ptr_item;
struct t_hdata *hdata;
const char *str;
int i;
/*
* check if the last "parent_group" (with diff = '^') of items is the same
* as this one: if yes, don't add this parent group
*/
if ((diff == RELAY_WEECHAT_NICKLIST_DIFF_PARENT)
&& (nicklist->items_count > 0))
{
for (i = nicklist->items_count - 1; i >= 0; i--)
{
if (nicklist->items[i].diff == RELAY_WEECHAT_NICKLIST_DIFF_PARENT)
{
if (nicklist->items[i].pointer == group)
return;
break;
}
}
}
new_items = realloc (nicklist->items,
(nicklist->items_count + 1) * sizeof (new_items[0]));
if (!new_items)
return;
nicklist->items = new_items;
ptr_item = &(nicklist->items[nicklist->items_count]);
if (group)
{
hdata = weechat_hdata_get ("nick_group");
ptr_item->pointer = group;
}
else
{
hdata = weechat_hdata_get ("nick");
ptr_item->pointer = nick;
}
ptr_item->diff = diff;
ptr_item->group = (group) ? 1 : 0;
ptr_item->visible = weechat_hdata_integer (hdata, ptr_item->pointer, "visible");
ptr_item->level = (group) ? weechat_hdata_integer (hdata, ptr_item->pointer, "level") : 0;
str = weechat_hdata_string (hdata, ptr_item->pointer, "name");
ptr_item->name = (str) ? strdup (str) : NULL;
str = weechat_hdata_string (hdata, ptr_item->pointer, "color");
ptr_item->color = (str) ? strdup (str) : NULL;
str = weechat_hdata_string (hdata, ptr_item->pointer, "prefix");
ptr_item->prefix = (str) ? strdup (str) : NULL;
str = weechat_hdata_string (hdata, ptr_item->pointer, "prefix_color");
ptr_item->prefix_color = (str) ? strdup (str) : NULL;
nicklist->items_count++;
}
struct t_gui_buffer *
relay_weechat_protocol_get_buffer (const char *arg)
{
struct t_gui_buffer *ptr_buffer;
long unsigned int value;
int rc;
struct t_hdata *ptr_hdata;
ptr_buffer = NULL;
if (strncmp (arg, "0x", 2) == 0)
{
rc = sscanf (arg, "%lx", &value);
if ((rc != EOF) && (rc != 0))
ptr_buffer = (struct t_gui_buffer *)value;
if (ptr_buffer)
{
ptr_hdata = weechat_hdata_get ("buffer");
if (!weechat_hdata_check_pointer (ptr_hdata,
weechat_hdata_get_list (ptr_hdata, "gui_buffers"),
ptr_buffer))
{
/* invalid pointer! */
ptr_buffer = NULL;
}
}
}
else
ptr_buffer = weechat_buffer_search ("==", arg);
return ptr_buffer;
}
struct t_trigger *
trigger_search_with_option (struct t_config_option *option)
{
const char *ptr_name;
char *pos_option;
struct t_trigger *ptr_trigger;
ptr_name = weechat_hdata_string (weechat_hdata_get ("config_option"),
option, "name");
if (!ptr_name)
return NULL;
pos_option = strchr (ptr_name, '.');
if (!pos_option)
return NULL;
for (ptr_trigger = triggers; ptr_trigger;
ptr_trigger = ptr_trigger->next_trigger)
{
if (weechat_strncasecmp (ptr_trigger->name, ptr_name, pos_option - ptr_name) == 0)
break;
}
return ptr_trigger;
}
void
relay_weechat_protocol_nicklist_map_cb (void *data,
struct t_hashtable *hashtable,
const void *key,
const void *value)
{
struct t_relay_client *ptr_client;
struct t_gui_buffer *ptr_buffer;
struct t_relay_weechat_nicklist *ptr_nicklist;
struct t_hdata *ptr_hdata;
struct t_relay_weechat_msg *msg;
/* make C compiler happy */
(void) hashtable;
ptr_client = (struct t_relay_client *)data;
ptr_buffer = (struct t_gui_buffer *)key;
ptr_nicklist = (struct t_relay_weechat_nicklist *)value;
ptr_hdata = weechat_hdata_get ("buffer");
if (ptr_hdata)
{
if (weechat_hdata_check_pointer (ptr_hdata,
weechat_hdata_get_list (ptr_hdata, "gui_buffers"),
ptr_buffer))
{
/*
* if no diff at all, or if diffs are bigger than nicklist:
* send whole nicklist
*/
if (ptr_nicklist
&& ((ptr_nicklist->items_count == 0)
|| (ptr_nicklist->items_count >= weechat_buffer_get_integer (ptr_buffer, "nicklist_count") + 1)))
{
ptr_nicklist = NULL;
}
/* send nicklist diffs or full nicklist */
msg = relay_weechat_msg_new ((ptr_nicklist) ? "_nicklist_diff" : "_nicklist");
if (msg)
{
relay_weechat_msg_add_nicklist (msg, ptr_buffer, ptr_nicklist);
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
}
void
relay_weechat_msg_add_nicklist (struct t_relay_weechat_msg *msg,
struct t_gui_buffer *buffer,
struct t_relay_weechat_nicklist *nicklist)
{
char str_vars[512];
struct t_hdata *ptr_hdata;
struct t_gui_buffer *ptr_buffer;
int pos_count, count;
uint32_t count32;
snprintf (str_vars, sizeof (str_vars),
"%sgroup:chr,visible:chr,level:int,"
"name:str,color:str,"
"prefix:str,prefix_color:str",
(nicklist) ? "_diff:chr," : "");
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_HDATA);
relay_weechat_msg_add_string (msg, "buffer/nicklist_item");
relay_weechat_msg_add_string (msg, str_vars);
/* "count" will be set later, with number of objects in hdata */
pos_count = msg->data_size;
count = 0;
relay_weechat_msg_add_int (msg, 0);
if (buffer)
{
count += relay_weechat_msg_add_nicklist_buffer (msg, buffer, nicklist);
}
else
{
ptr_hdata = weechat_hdata_get ("buffer");
ptr_buffer = weechat_hdata_get_list (ptr_hdata, "gui_buffers");
while (ptr_buffer)
{
count += relay_weechat_msg_add_nicklist_buffer (msg, ptr_buffer, NULL);
ptr_buffer = weechat_hdata_move (ptr_hdata, ptr_buffer, 1);
}
}
count32 = htonl ((uint32_t)count);
relay_weechat_msg_set_bytes (msg, pos_count, &count32, 4);
}
struct t_gui_buffer *
relay_weechat_protocol_get_buffer (const char *arg)
{
struct t_gui_buffer *ptr_buffer;
long unsigned int value;
int rc;
char *pos, *plugin;
struct t_hdata *ptr_hdata;
ptr_buffer = NULL;
if (strncmp (arg, "0x", 2) == 0)
{
rc = sscanf (arg, "%lx", &value);
if ((rc != EOF) && (rc != 0))
ptr_buffer = (struct t_gui_buffer *)value;
if (ptr_buffer)
{
ptr_hdata = weechat_hdata_get ("buffer");
if (!weechat_hdata_check_pointer (ptr_hdata,
weechat_hdata_get_list (ptr_hdata, "gui_buffers"),
ptr_buffer))
{
/* invalid pointer! */
ptr_buffer = NULL;
}
}
}
else
{
pos = strchr (arg, '.');
if (pos)
{
plugin = weechat_strndup (arg, pos - arg);
if (plugin)
{
ptr_buffer = weechat_buffer_search (plugin, pos + 1);
free (plugin);
}
}
}
return ptr_buffer;
}
int
relay_weechat_protocol_signal_buffer_cb (const void *pointer, void *data,
const char *signal,
const char *type_data,
void *signal_data)
{
struct t_relay_client *ptr_client;
struct t_gui_line *ptr_line;
struct t_hdata *ptr_hdata_line, *ptr_hdata_line_data;
struct t_gui_line_data *ptr_line_data;
struct t_gui_buffer *ptr_buffer;
struct t_relay_weechat_msg *msg;
char cmd_hdata[64], str_signal[128];
/* make C compiler happy */
(void) data;
(void) type_data;
ptr_client = (struct t_relay_client *)pointer;
if (!ptr_client || !relay_client_valid (ptr_client))
return WEECHAT_RC_OK;
snprintf (str_signal, sizeof (str_signal), "_%s", signal);
if (strcmp (signal, "buffer_opened") == 0)
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer)
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffers" or "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFERS |
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name,short_name,"
"nicklist,title,local_variables,"
"prev_buffer,next_buffer");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if (strcmp (signal, "buffer_type_changed") == 0)
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer)
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffers" or "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFERS |
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name,type");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if (strcmp (signal, "buffer_moved") == 0)
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer)
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffers" or "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFERS |
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name,"
"prev_buffer,next_buffer");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if ((strcmp (signal, "buffer_merged") == 0)
|| (strcmp (signal, "buffer_unmerged") == 0))
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer)
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffers" or "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFERS |
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name,"
"prev_buffer,next_buffer");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if ((strcmp (signal, "buffer_hidden") == 0)
|| (strcmp (signal, "buffer_unhidden") == 0))
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer)
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffers" or "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFERS |
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name,"
"prev_buffer,next_buffer");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if (strcmp (signal, "buffer_renamed") == 0)
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer)
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffers" or "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFERS |
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name,short_name,"
"local_variables");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if (strcmp (signal, "buffer_title_changed") == 0)
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer)
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffers" or "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFERS |
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name,title");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if (strncmp (signal, "buffer_localvar_", 16) == 0)
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer)
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffers" or "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFERS |
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name,local_variables");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if (strcmp (signal, "buffer_cleared") == 0)
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer || relay_weechat_is_relay_buffer (ptr_buffer))
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if (strcmp (signal, "buffer_line_added") == 0)
{
ptr_line = (struct t_gui_line *)signal_data;
if (!ptr_line)
return WEECHAT_RC_OK;
ptr_hdata_line = weechat_hdata_get ("line");
if (!ptr_hdata_line)
return WEECHAT_RC_OK;
ptr_hdata_line_data = weechat_hdata_get ("line_data");
if (!ptr_hdata_line_data)
return WEECHAT_RC_OK;
ptr_line_data = weechat_hdata_pointer (ptr_hdata_line, ptr_line, "data");
if (!ptr_line_data)
return WEECHAT_RC_OK;
ptr_buffer = weechat_hdata_pointer (ptr_hdata_line_data, ptr_line_data,
"buffer");
if (!ptr_buffer || relay_weechat_is_relay_buffer (ptr_buffer))
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"line_data:0x%lx",
(long unsigned int)ptr_line_data);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"buffer,date,date_printed,"
"displayed,highlight,tags_array,"
"prefix,message");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
}
else if (strcmp (signal, "buffer_closing") == 0)
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer)
return WEECHAT_RC_OK;
/* send signal only if sync with flag "buffers" or "buffer" */
if (relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFERS |
RELAY_WEECHAT_PROTOCOL_SYNC_BUFFER))
{
msg = relay_weechat_msg_new (str_signal);
if (msg)
{
snprintf (cmd_hdata, sizeof (cmd_hdata),
"buffer:0x%lx", (long unsigned int)ptr_buffer);
relay_weechat_msg_add_hdata (msg, cmd_hdata,
"number,full_name");
relay_weechat_msg_send (ptr_client, msg);
relay_weechat_msg_free (msg);
}
}
/* remove buffer from hashtables */
weechat_hashtable_remove (
RELAY_WEECHAT_DATA(ptr_client, buffers_sync),
weechat_buffer_get_string (ptr_buffer, "full_name"));
weechat_hashtable_remove (
RELAY_WEECHAT_DATA(ptr_client, buffers_nicklist),
ptr_buffer);
}
return WEECHAT_RC_OK;
}
struct t_weelist *
script_buffer_get_script_usage (struct t_script_repo *script)
{
struct t_weelist *list;
char hdata_name[128], str_option[256], str_info[1024];
int config_files;
const char *ptr_name_hdata_callback, *type;
struct t_hdata *ptr_hdata_script, *ptr_hdata_callback;
struct t_hdata *ptr_hdata_config_file, *ptr_hdata_bar_item;
void *ptr_script, *ptr_callback;
struct t_config_file *ptr_config_file;
struct t_hook *ptr_hook;
struct t_gui_bar_item *ptr_bar_item;
struct t_infolist *infolist;
config_files = 0;
snprintf (hdata_name, sizeof (hdata_name),
"%s_script", script_language[script->language]);
ptr_hdata_script = weechat_hdata_get (hdata_name);
if (!ptr_hdata_script)
return NULL;
ptr_script = script_buffer_get_script_pointer (script, ptr_hdata_script);
if (!ptr_script)
return NULL;
ptr_name_hdata_callback = weechat_hdata_get_var_hdata (ptr_hdata_script,
"callbacks");
if (!ptr_name_hdata_callback)
return NULL;
ptr_hdata_callback = weechat_hdata_get (ptr_name_hdata_callback);
if (!ptr_hdata_callback)
return NULL;
list = weechat_list_new ();
ptr_hdata_config_file = weechat_hdata_get ("config_file");
ptr_hdata_bar_item = weechat_hdata_get ("bar_item");
ptr_callback = weechat_hdata_pointer (ptr_hdata_script,
ptr_script,
"callbacks");
while (ptr_callback)
{
str_info[0] = '\0';
ptr_config_file = weechat_hdata_pointer (ptr_hdata_callback,
ptr_callback,
"config_file");
ptr_hook = weechat_hdata_pointer (ptr_hdata_callback,
ptr_callback,
"hook");
ptr_bar_item = weechat_hdata_pointer (ptr_hdata_callback,
ptr_callback,
"bar_item");
if (ptr_config_file)
{
snprintf (str_info, sizeof (str_info),
_("configuration file \"%s\" (options %s.*)"),
weechat_hdata_string (ptr_hdata_config_file,
ptr_config_file,
"filename"),
weechat_hdata_string (ptr_hdata_config_file,
ptr_config_file,
"name"));
config_files++;
}
else if (ptr_hook)
{
infolist = weechat_infolist_get ("hook", ptr_hook, NULL);
if (infolist)
{
if (weechat_infolist_next (infolist))
{
type = weechat_infolist_string (infolist, "type");
if (type)
{
if (strcmp (type, "command") == 0)
{
snprintf (str_info, sizeof (str_info),
_("command /%s"),
weechat_infolist_string (infolist,
"command"));
}
else if (strcmp (type, "completion") == 0)
{
snprintf (str_info, sizeof (str_info),
_("completion %%(%s)"),
weechat_infolist_string (infolist,
"completion_item"));
}
else if (strcmp (type, "info") == 0)
{
snprintf (str_info, sizeof (str_info),
"info \"%s\"",
weechat_infolist_string (infolist,
"info_name"));
}
else if (strcmp (type, "info_hashtable") == 0)
{
snprintf (str_info, sizeof (str_info),
"info_hashtable \"%s\"",
weechat_infolist_string (infolist,
"info_name"));
}
else if (strcmp (type, "infolist") == 0)
{
snprintf (str_info, sizeof (str_info),
"infolist \"%s\"",
weechat_infolist_string (infolist,
"infolist_name"));
}
}
}
weechat_infolist_free (infolist);
}
}
else if (ptr_bar_item)
{
snprintf (str_info, sizeof (str_info),
_("bar item \"%s\""),
weechat_hdata_string (ptr_hdata_bar_item,
ptr_bar_item,
"name"));
}
if (str_info[0])
{
weechat_list_add (list, str_info,
WEECHAT_LIST_POS_END, NULL);
}
ptr_callback = weechat_hdata_move (ptr_hdata_callback,
ptr_callback,
1);
}
snprintf (str_option, sizeof (str_option),
"plugins.var.%s.%s.*",
script_language[script->language],
weechat_hdata_string (ptr_hdata_script, ptr_script, "name"));
infolist = weechat_infolist_get ("option", NULL, str_option);
if (infolist)
{
if (weechat_infolist_next (infolist))
{
snprintf (str_info, sizeof (str_info),
_("options %s%s%s"),
str_option,
(config_files > 0) ? " " : "",
(config_files > 0) ? _("(old options?)") : "");
weechat_list_add (list, str_info,
WEECHAT_LIST_POS_END, NULL);
}
weechat_infolist_free (infolist);
}
return list;
}
int
relay_weechat_msg_add_nicklist_buffer (struct t_relay_weechat_msg *msg,
struct t_gui_buffer *buffer,
struct t_relay_weechat_nicklist *nicklist)
{
int count, i;
struct t_hdata *ptr_hdata_group, *ptr_hdata_nick;
struct t_gui_nick_group *ptr_group;
struct t_gui_nick *ptr_nick;
count = 0;
if (nicklist)
{
/* send nicklist diffs */
for (i = 0; i < nicklist->items_count; i++)
{
relay_weechat_msg_add_pointer (msg, buffer);
relay_weechat_msg_add_pointer (msg, nicklist->items[i].pointer);
relay_weechat_msg_add_char (msg, nicklist->items[i].diff);
relay_weechat_msg_add_char (msg, nicklist->items[i].group);
relay_weechat_msg_add_char (msg, nicklist->items[i].visible);
relay_weechat_msg_add_int (msg, nicklist->items[i].level);
relay_weechat_msg_add_string (msg, nicklist->items[i].name);
relay_weechat_msg_add_string (msg, nicklist->items[i].color);
relay_weechat_msg_add_string (msg, nicklist->items[i].prefix);
relay_weechat_msg_add_string (msg, nicklist->items[i].prefix_color);
count++;
}
}
else
{
/* send full nicklist */
ptr_hdata_group = weechat_hdata_get ("nick_group");
ptr_hdata_nick = weechat_hdata_get ("nick");
ptr_group = NULL;
ptr_nick = NULL;
weechat_nicklist_get_next_item (buffer, &ptr_group, &ptr_nick);
while (ptr_group || ptr_nick)
{
if (ptr_nick)
{
relay_weechat_msg_add_pointer (msg, buffer);
relay_weechat_msg_add_pointer (msg, ptr_nick);
relay_weechat_msg_add_char (msg, 0); /* group */
relay_weechat_msg_add_char (msg,
(char)weechat_hdata_integer(ptr_hdata_nick,
ptr_nick,
"visible"));
relay_weechat_msg_add_int (msg, 0); /* level */
relay_weechat_msg_add_string (msg,
weechat_hdata_string (ptr_hdata_nick,
ptr_nick,
"name"));
relay_weechat_msg_add_string (msg,
weechat_hdata_string (ptr_hdata_nick,
ptr_nick,
"color"));
relay_weechat_msg_add_string (msg,
weechat_hdata_string (ptr_hdata_nick,
ptr_nick,
"prefix"));
relay_weechat_msg_add_string (msg,
weechat_hdata_string (ptr_hdata_nick,
ptr_nick,
"prefix_color"));
count++;
}
else
{
relay_weechat_msg_add_pointer (msg, buffer);
relay_weechat_msg_add_pointer (msg, ptr_group);
relay_weechat_msg_add_char (msg, 1); /* group */
relay_weechat_msg_add_char (msg,
(char)weechat_hdata_integer(ptr_hdata_group,
ptr_group,
"visible"));
relay_weechat_msg_add_int (msg,
weechat_hdata_integer (ptr_hdata_group,
ptr_group,
"level"));
relay_weechat_msg_add_string (msg,
weechat_hdata_string (ptr_hdata_group,
ptr_group,
"name"));
relay_weechat_msg_add_string (msg,
weechat_hdata_string (ptr_hdata_group,
ptr_group,
"color"));
relay_weechat_msg_add_string (msg, NULL); /* prefix */
relay_weechat_msg_add_string (msg, NULL); /* prefix_color */
count++;
}
weechat_nicklist_get_next_item (buffer, &ptr_group, &ptr_nick);
}
}
return count;
}
void
relay_weechat_msg_add_hdata (struct t_relay_weechat_msg *msg,
const char *path, const char *keys)
{
struct t_hdata *ptr_hdata_head, *ptr_hdata;
char *hdata_head, *pos, **list_keys, *keys_types, **list_path;
char *path_returned;
const char *hdata_name, *array_size;
void *pointer, **path_pointers;
long unsigned int value;
int num_keys, num_path, i, type, pos_count, count, rc;
uint32_t count32;
hdata_head = NULL;
list_keys = NULL;
num_keys = 0;
keys_types = NULL;
list_path = NULL;
num_path = 0;
path_returned = NULL;
/* extract hdata name (head) from path */
pos = strchr (path, ':');
if (!pos)
goto end;
hdata_head = weechat_strndup (path, pos - path);
if (!hdata_head)
goto end;
ptr_hdata_head = weechat_hdata_get (hdata_head);
if (!ptr_hdata_head)
goto end;
/* split path */
list_path = weechat_string_split (pos + 1, "/", 0, 0, &num_path);
if (!list_path)
goto end;
/* extract pointer from first path (direct pointer or list name) */
pointer = NULL;
pos = strchr (list_path[0], '(');
if (pos)
pos[0] = '\0';
if (strncmp (list_path[0], "0x", 2) == 0)
{
rc = sscanf (list_path[0], "%lx", &value);
if ((rc != EOF) && (rc != 0))
pointer = (void *)value;
}
else
pointer = weechat_hdata_get_list (ptr_hdata_head, list_path[0]);
if (pos)
pos[0] = '(';
if (!pointer)
goto end;
/*
* build string with path where:
* - counters are removed
* - variable names are replaced by hdata name
*/
path_returned = malloc (strlen (path) * 2);
if (!path_returned)
goto end;
ptr_hdata = ptr_hdata_head;
strcpy (path_returned, hdata_head);
hdata_name = hdata_head;
for (i = 1; i < num_path; i++)
{
pos = strchr (list_path[i], '(');
if (pos)
pos[0] = '\0';
hdata_name = weechat_hdata_get_var_hdata (ptr_hdata, list_path[i]);
if (!hdata_name)
goto end;
ptr_hdata = weechat_hdata_get (hdata_name);
if (!ptr_hdata)
goto end;
strcat (path_returned, "/");
strcat (path_returned, hdata_name);
if (pos)
pos[0] = '(';
}
/* split keys */
if (!keys)
keys = weechat_hdata_get_string (ptr_hdata, "var_keys");
list_keys = weechat_string_split (keys, ",", 0, 0, &num_keys);
if (!list_keys)
goto end;
/* build string with list of keys with types: "key1:type1,key2:type2,..." */
keys_types = malloc (strlen (keys) + (num_keys * 8) + 1);
if (!keys_types)
goto end;
keys_types[0] = '\0';
for (i = 0; i < num_keys; i++)
{
type = weechat_hdata_get_var_type (ptr_hdata, list_keys[i]);
if ((type >= 0) && (type != WEECHAT_HDATA_OTHER))
{
if (keys_types[0])
strcat (keys_types, ",");
strcat (keys_types, list_keys[i]);
strcat (keys_types, ":");
array_size = weechat_hdata_get_var_array_size_string (ptr_hdata,
NULL,
list_keys[i]);
if (array_size)
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_ARRAY);
else
{
switch (type)
{
case WEECHAT_HDATA_CHAR:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_CHAR);
break;
case WEECHAT_HDATA_INTEGER:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_INT);
break;
case WEECHAT_HDATA_LONG:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_LONG);
break;
case WEECHAT_HDATA_STRING:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_STRING);
break;
case WEECHAT_HDATA_POINTER:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_POINTER);
break;
case WEECHAT_HDATA_TIME:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_TIME);
break;
case WEECHAT_HDATA_HASHTABLE:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_HASHTABLE);
break;
}
}
}
}
if (!keys_types[0])
goto end;
/* start hdata in message */
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_HDATA);
relay_weechat_msg_add_string (msg, path_returned);
relay_weechat_msg_add_string (msg, keys_types);
/* "count" will be set later, with number of objects in hdata */
pos_count = msg->data_size;
count = 0;
relay_weechat_msg_add_int (msg, 0);
path_pointers = malloc (sizeof (*path_pointers) * num_path);
if (path_pointers)
{
count = relay_weechat_msg_add_hdata_path (msg,
list_path,
0,
path_pointers,
ptr_hdata_head,
pointer,
list_keys);
free (path_pointers);
}
count32 = htonl ((uint32_t)count);
relay_weechat_msg_set_bytes (msg, pos_count, &count32, 4);
end:
if (list_keys)
weechat_string_free_split (list_keys);
if (keys_types)
free (keys_types);
if (list_path)
weechat_string_free_split (list_path);
if (path_returned)
free (path_returned);
if (hdata_head)
free (hdata_head);
}
int
relay_weechat_msg_add_hdata_path (struct t_relay_weechat_msg *msg,
char **list_path,
int index_path,
void **path_pointers,
struct t_hdata *hdata,
void *pointer,
char **list_keys)
{
int num_added, i, j, count, count_all, var_type, array_size, max_array_size;
int length;
char *pos, *pos2, *str_count, *error, *name;
void *sub_pointer;
struct t_hdata *sub_hdata;
const char *sub_hdata_name;
num_added = 0;
count_all = 0;
count = 0;
pos = strchr (list_path[index_path], '(');
if (pos)
{
pos2 = strchr (pos + 1, ')');
if (pos2 && (pos2 > pos + 1))
{
str_count = weechat_strndup (pos + 1, pos2 - (pos + 1));
if (str_count)
{
if (strcmp (str_count, "*") == 0)
count_all = 1;
else
{
error = NULL;
count = (int)strtol (str_count, &error, 10);
if (error && !error[0])
{
if (count > 0)
count--;
else if (count < 0)
count++;
}
else
count = 0;
}
free (str_count);
}
}
}
while (pointer)
{
path_pointers[index_path] = pointer;
if (list_path[index_path + 1])
{
/* recursive call with next path */
pos = strchr (list_path[index_path + 1], '(');
if (pos)
pos[0] = '\0';
sub_pointer = weechat_hdata_pointer (hdata, pointer, list_path[index_path + 1]);
sub_hdata_name = weechat_hdata_get_var_hdata (hdata, list_path[index_path + 1]);
if (pos)
pos[0] = '(';
if (sub_pointer && sub_hdata_name)
{
sub_hdata = weechat_hdata_get (sub_hdata_name);
if (sub_hdata)
{
num_added += relay_weechat_msg_add_hdata_path (msg,
list_path,
index_path + 1,
path_pointers,
sub_hdata,
sub_pointer,
list_keys);
}
}
}
else
{
/* last path? then get pointer + values and fill message with them */
for (i = 0; list_path[i]; i++)
{
relay_weechat_msg_add_pointer (msg, path_pointers[i]);
}
for (i = 0; list_keys[i]; i++)
{
var_type = weechat_hdata_get_var_type (hdata, list_keys[i]);
if ((var_type >= 0) && (var_type != WEECHAT_HDATA_OTHER))
{
max_array_size = 1;
array_size = weechat_hdata_get_var_array_size (hdata,
pointer,
list_keys[i]);
if (array_size >= 0)
{
switch (var_type)
{
case WEECHAT_HDATA_CHAR:
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_CHAR);
break;
case WEECHAT_HDATA_INTEGER:
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_INT);
break;
case WEECHAT_HDATA_LONG:
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_LONG);
break;
case WEECHAT_HDATA_STRING:
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_STRING);
break;
case WEECHAT_HDATA_POINTER:
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_POINTER);
break;
case WEECHAT_HDATA_TIME:
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_TIME);
break;
case WEECHAT_HDATA_HASHTABLE:
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_HASHTABLE);
break;
}
relay_weechat_msg_add_int (msg, array_size);
max_array_size = array_size;
}
length = 16 + strlen (list_keys[i]) + 1;
name = malloc (length);
if (name)
{
for (j = 0; j < max_array_size; j++)
{
snprintf (name, length, "%d|%s", j, list_keys[i]);
switch (var_type)
{
case WEECHAT_HDATA_CHAR:
relay_weechat_msg_add_char (msg,
weechat_hdata_char (hdata,
pointer,
name));
break;
case WEECHAT_HDATA_INTEGER:
relay_weechat_msg_add_int (msg,
weechat_hdata_integer (hdata,
pointer,
name));
break;
case WEECHAT_HDATA_LONG:
relay_weechat_msg_add_long (msg,
weechat_hdata_long (hdata,
pointer,
name));
break;
case WEECHAT_HDATA_STRING:
relay_weechat_msg_add_string (msg,
weechat_hdata_string (hdata,
pointer,
name));
break;
case WEECHAT_HDATA_POINTER:
relay_weechat_msg_add_pointer (msg,
weechat_hdata_pointer (hdata,
pointer,
name));
break;
case WEECHAT_HDATA_TIME:
relay_weechat_msg_add_time (msg,
weechat_hdata_time (hdata,
pointer,
name));
break;
case WEECHAT_HDATA_HASHTABLE:
relay_weechat_msg_add_hashtable (msg,
weechat_hdata_hashtable (hdata,
pointer,
name));
break;
}
}
free (name);
}
}
}
num_added++;
}
if (count_all)
{
pointer = weechat_hdata_move (hdata, pointer, 1);
}
else if (count == 0)
pointer = NULL;
else if (count > 0)
{
pointer = weechat_hdata_move (hdata, pointer, 1);
count--;
}
else
{
pointer = weechat_hdata_move (hdata, pointer, -1);
count++;
}
if (!pointer)
break;
}
return num_added;
}
struct t_weelist *
script_buffer_get_script_usage (struct t_script_repo *script)
{
struct t_weelist *list;
char hdata_name[128], str_option[256], str_info[1024];
int config_files;
struct t_hdata *hdata_script, *hdata_config, *hdata_bar_item;
void *ptr_script, *callback_pointer;
struct t_config_file *ptr_config;
struct t_gui_bar_item *ptr_bar_item;
struct t_infolist *infolist;
config_files = 0;
snprintf (hdata_name, sizeof (hdata_name),
"%s_script", script_language[script->language]);
hdata_script = weechat_hdata_get (hdata_name);
if (!hdata_script)
return NULL;
ptr_script = script_buffer_get_script_pointer (script, hdata_script);
if (!ptr_script)
return NULL;
list = weechat_list_new ();
/* get configuration files created by the script */
hdata_config = weechat_hdata_get ("config_file");
ptr_config = weechat_hdata_get_list (hdata_config, "config_files");
while (ptr_config)
{
callback_pointer = weechat_hdata_pointer (
hdata_config, ptr_config, "callback_reload_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
_("configuration file \"%s\" (options %s.*)"),
weechat_hdata_string (hdata_config, ptr_config,
"filename"),
weechat_hdata_string (hdata_config, ptr_config,
"name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
config_files++;
}
ptr_config = weechat_hdata_move (hdata_config, ptr_config, 1);
}
/* get the commands created by the script */
infolist = weechat_infolist_get ("hook", NULL, "command");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
_("command /%s"),
weechat_infolist_string (infolist,
"command"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the completions created by the script */
infolist = weechat_infolist_get ("hook", NULL, "completion");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
_("completion %%(%s)"),
weechat_infolist_string (infolist,
"completion_item"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the infos created by the script */
infolist = weechat_infolist_get ("hook", NULL, "info");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
"info \"%s\"",
weechat_infolist_string (infolist,
"info_name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the infos (hashtable) created by the script */
infolist = weechat_infolist_get ("hook", NULL, "info_hashtable");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
"info_hashtable \"%s\"",
weechat_infolist_string (infolist,
"info_name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the infolists created by the script */
infolist = weechat_infolist_get ("hook", NULL, "infolist");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
"infolist \"%s\"",
weechat_infolist_string (infolist,
"infolist_name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the bar items created by the script */
hdata_bar_item = weechat_hdata_get ("bar_item");
ptr_bar_item = weechat_hdata_get_list (hdata_bar_item, "gui_bar_items");
while (ptr_bar_item)
{
callback_pointer = weechat_hdata_pointer (hdata_bar_item, ptr_bar_item,
"build_callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
_("bar item \"%s\""),
weechat_hdata_string (hdata_bar_item,
ptr_bar_item,
"name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
ptr_bar_item = weechat_hdata_move (hdata_bar_item, ptr_bar_item, 1);
}
/* get the script options (in plugins.var) */
snprintf (str_option, sizeof (str_option),
"plugins.var.%s.%s.*",
script_language[script->language],
weechat_hdata_string (hdata_script, ptr_script, "name"));
infolist = weechat_infolist_get ("option", NULL, str_option);
if (infolist)
{
if (weechat_infolist_next (infolist))
{
snprintf (str_info, sizeof (str_info),
_("options %s%s%s"),
str_option,
(config_files > 0) ? " " : "",
(config_files > 0) ? _("(old options?)") : "");
weechat_list_add (list, str_info,
WEECHAT_LIST_POS_END, NULL);
}
weechat_infolist_free (infolist);
}
return list;
}
