TEST(String, SplitShell)
{
char **argv;
int argc;
POINTERS_EQUAL(NULL, string_split_shell (NULL, NULL));
/* test with an empty string */
argc = -1;
argv = string_split_shell ("", &argc);
LONGS_EQUAL(0, argc);
CHECK(argv);
POINTERS_EQUAL(NULL, argv[0]);
string_free_split (argv);
/* test with a real string (command + arguments) */
argv = string_split_shell ("/path/to/bin arg1 \"arg2 here\" 'arg3 here'",
&argc);
LONGS_EQUAL(4, argc);
CHECK(argv);
STRCMP_EQUAL("/path/to/bin", argv[0]);
STRCMP_EQUAL("arg1", argv[1]);
STRCMP_EQUAL("arg2 here", argv[2]);
STRCMP_EQUAL("arg3 here", argv[3]);
POINTERS_EQUAL(NULL, argv[4]);
string_free_split (argv);
/* free split with NULL */
string_free_split_shared (NULL);
}
void
gui_filter_free (struct t_gui_filter *filter)
{
int i;
(void) hook_signal_send ("filter_removing",
WEECHAT_HOOK_SIGNAL_POINTER, filter);
/* free data */
if (filter->name)
free (filter->name);
if (filter->buffer_name)
free (filter->buffer_name);
if (filter->buffers)
string_free_split (filter->buffers);
if (filter->tags)
free (filter->tags);
if (filter->tags_array)
{
for (i = 0; i < filter->tags_count; i++)
{
string_free_split (filter->tags_array[i]);
}
free (filter->tags_array);
}
if (filter->regex)
free (filter->regex);
if (filter->regex_prefix)
{
regfree (filter->regex_prefix);
free (filter->regex_prefix);
}
if (filter->regex_message)
{
regfree (filter->regex_message);
free (filter->regex_message);
}
/* remove filter from filters list */
if (filter->prev_filter)
(filter->prev_filter)->next_filter = filter->next_filter;
if (filter->next_filter)
(filter->next_filter)->prev_filter = filter->prev_filter;
if (gui_filters == filter)
gui_filters = filter->next_filter;
if (last_gui_filter == filter)
last_gui_filter = filter->prev_filter;
free (filter);
(void) hook_signal_send ("filter_removed", WEECHAT_HOOK_SIGNAL_STRING, NULL);
}
long
weeurl_get_mask_value (struct t_url_constant *constants,
const char *string_mask)
{
char **items, *item;
int num_items, i, index;
long mask;
mask = 0;
items = string_split (string_mask, "+", 0, 0, &num_items);
if (items)
{
for (i = 0; i < num_items; i++)
{
item = string_remove_quotes(items[i], "'\"");
if (item)
{
index = weeurl_search_constant (constants, item);
if (index >= 0)
mask |= constants[index].value;
free (item);
}
}
string_free_split (items);
}
return mask;
}
void
gui_chat_print_lines_waiting_buffer ()
{
char **lines;
int num_lines, i;
if (gui_chat_lines_waiting_buffer)
{
lines = string_split (gui_chat_lines_waiting_buffer, "\n", 0, 0,
&num_lines);
if (lines)
{
for (i = 0; i < num_lines; i++)
{
gui_chat_printf (NULL, "%s", lines[i]);
}
string_free_split (lines);
}
/*
* gui_chat_lines_waiting_buffer may be NULL after call to
* gui_chat_printf (if not enough memory)
*/
}
if (gui_chat_lines_waiting_buffer)
{
free (gui_chat_lines_waiting_buffer);
gui_chat_lines_waiting_buffer = NULL;
}
}
void
gui_chat_print_lines_waiting_buffer (FILE *f)
{
char **lines;
int num_lines, i;
if (gui_chat_lines_waiting_buffer)
{
lines = string_split (gui_chat_lines_waiting_buffer, "\n", 0, 0,
&num_lines);
if (lines)
{
for (i = 0; i < num_lines; i++)
{
if (!f && gui_init_ok)
gui_chat_printf (NULL, "%s", lines[i]);
else
string_fprintf ((f) ? f : stdout, "%s\n", lines[i]);
}
string_free_split (lines);
}
/*
* gui_chat_lines_waiting_buffer may be NULL after call to
* gui_chat_printf (if not enough memory)
*/
}
if (gui_chat_lines_waiting_buffer)
{
free (gui_chat_lines_waiting_buffer);
gui_chat_lines_waiting_buffer = NULL;
}
}
int
main (int argc, char *argv[])
{
int rc, length, weechat_argc;
char *weechat_tests_args, *args, **weechat_argv;
/* setup environment: default language, no specific timezone */
setenv ("LC_ALL", "C", 1);
setenv ("TZ", "", 1);
/* build arguments for WeeChat */
weechat_tests_args = getenv ("WEECHAT_TESTS_ARGS");
length = strlen (argv[0]) +
64 + /* --dir ... */
((weechat_tests_args) ? 1 + strlen (weechat_tests_args) : 0) +
1;
args = (char *)malloc (length);
if (!args)
{
fprintf (stderr, "Memory error\n");
return 1;
}
snprintf (args, length,
"%s --dir ./tmp_weechat_test%s%s",
argv[0],
(weechat_tests_args) ? " " : "",
(weechat_tests_args) ? weechat_tests_args : "");
weechat_argv = string_split_shell (args, &weechat_argc);
printf ("WeeChat arguments: \"%s\"\n", args);
/* init WeeChat */
printf ("------------------------------------------------------------\n");
weechat_init (weechat_argc, weechat_argv, &test_gui_init);
if (weechat_argv)
string_free_split (weechat_argv);
free (args);
/* display WeeChat version */
input_data (gui_buffer_search_main (), "/command core version");
/* run all tests */
printf ("\n");
printf (">>>>>>>>>> TESTS >>>>>>>>>>\n");
rc = CommandLineTestRunner::RunAllTests (argc, argv);
printf ("<<<<<<<<<< TESTS <<<<<<<<<<\n");
printf ("\n");
/* end WeeChat */
weechat_end (&gui_main_end);
printf ("------------------------------------------------------------\n");
/* display status */
printf ("\n");
printf ("\33[%d;1m*** %s ***\33[0m\n",
(rc == 0) ? 32 : 31, /* 32 = green (OK), 31 = red (error) */
(rc == 0) ? "OK" : "ERROR");
return rc;
}
int
secure_decrypt_data_not_decrypted (const char *passphrase)
{
char **keys, *buffer, *decrypted;
const char *value;
int num_ok, num_keys, i, length_buffer, length_decrypted, rc;
/* we need a passphrase to decrypt data! */
if (!passphrase || !passphrase[0])
return 0;
num_ok = 0;
keys = string_split (hashtable_get_string (secure_hashtable_data_encrypted,
"keys"),
",", 0, 0, &num_keys);
if (keys)
{
for (i = 0; i < num_keys; i++)
{
value = hashtable_get (secure_hashtable_data_encrypted, keys[i]);
if (value && value[0])
{
buffer = malloc (strlen (value) + 1);
if (buffer)
{
length_buffer = string_decode_base16 (value, buffer);
decrypted = NULL;
length_decrypted = 0;
rc = secure_decrypt_data (buffer,
length_buffer,
secure_hash_algo[CONFIG_INTEGER(secure_config_crypt_hash_algo)],
secure_cipher[CONFIG_INTEGER(secure_config_crypt_cipher)],
passphrase,
&decrypted,
&length_decrypted);
if ((rc == 0) && decrypted)
{
hashtable_set (secure_hashtable_data, keys[i],
decrypted);
hashtable_remove (secure_hashtable_data_encrypted,
keys[i]);
num_ok++;
}
if (decrypted)
free (decrypted);
free (buffer);
}
}
}
string_free_split (keys);
}
return num_ok;
}
int
util_version_number (const char *version)
{
char **items, buf[64], *error;
const char *ptr_item;
int num_items, i, version_int[4], index_buf;
long number;
items = string_split (version, ".", 0, 4, &num_items);
for (i = 0; i < 4; i++)
{
version_int[i] = 0;
if (items && (i < num_items))
{
ptr_item = items[i];
index_buf = 0;
while (ptr_item && ptr_item[0] && (index_buf < (int)sizeof (buf) - 1))
{
if (ptr_item[0] == '-')
break;
if (isdigit ((unsigned char)ptr_item[0]))
{
buf[index_buf] = ptr_item[0];
index_buf++;
}
ptr_item = utf8_next_char (ptr_item);
}
buf[index_buf] = '\0';
if (buf[0])
{
error = NULL;
number = strtol (buf, &error, 10);
if (error && !error[0])
{
if (number < 0)
number = 0;
else if (number > 0xFF)
number = 0xFF;
version_int[i] = number;
}
}
}
}
if (items)
string_free_split (items);
return (version_int[0] << 24) | (version_int[1] << 16)
| (version_int[2] << 8) | version_int[3];
}
void
hook_line_free_data (struct t_hook *hook)
{
if (!hook || !hook->hook_data)
return;
if (HOOK_LINE(hook, buffers))
{
string_free_split (HOOK_LINE(hook, buffers));
HOOK_LINE(hook, buffers) = NULL;
}
if (HOOK_LINE(hook, tags_array))
{
string_free_split_tags (HOOK_LINE(hook, tags_array));
HOOK_LINE(hook, tags_array) = NULL;
}
free (hook->hook_data);
hook->hook_data = NULL;
}
void
util_setrlimit ()
{
#ifdef HAVE_SYS_RESOURCE_H
char **items, *pos, *error;
int num_items, i;
long number;
items = string_split (CONFIG_STRING(config_startup_sys_rlimit), ",", 0, 0,
&num_items);
if (items)
{
for (i = 0; i < num_items; i++)
{
pos = strchr (items[i], ':');
if (pos)
{
pos[0] = '\0';
error = NULL;
number = strtol (pos + 1, &error, 10);
if (error && !error[0])
{
util_setrlimit_resource (items[i], number);
}
else
{
gui_chat_printf (NULL,
_("%sError: invalid limit for resource "
"\"%s\": %s (must be >= -1)"),
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
items[i], pos + 1);
}
}
}
string_free_split (items);
}
#endif /* HAVE_SYS_RESOURCE_H */
}
TEST(String, SplitBuildWithSplitString)
{
char **argv, *str;
int argc;
str = string_build_with_split_string (NULL, NULL);
POINTERS_EQUAL(NULL, str);
argv = string_split (" abc de fghi ", " ", 0, 0, &argc);
str = string_build_with_split_string ((const char **)argv, NULL);
STRCMP_EQUAL("abcdefghi", str);
free (str);
str = string_build_with_split_string ((const char **)argv, "");
STRCMP_EQUAL("abcdefghi", str);
free (str);
str = string_build_with_split_string ((const char **)argv, ";;");
STRCMP_EQUAL("abc;;de;;fghi", str);
free (str);
string_free_split (argv);
}
char *
gui_bar_window_content_get_with_filling (struct t_gui_bar_window *bar_window,
struct t_gui_window *window)
{
enum t_gui_bar_filling filling;
char *ptr_content, *content, reinit_color[32], reinit_color_space[32];
char *item_value, *item_value2, ****split_items, **linear_items;
int index_content, content_length, i, first_sub_item, sub, j, k, index;
int length_reinit_color, length_reinit_color_space;
int length, max_length, max_length_screen, total_items, columns, lines;
if (!bar_window->items_subcount || !bar_window->items_content
|| !bar_window->items_refresh_needed)
return NULL;
snprintf (reinit_color, sizeof (reinit_color),
"%c%c%02d,%02d",
GUI_COLOR_COLOR_CHAR,
GUI_COLOR_FG_BG_CHAR,
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_FG]),
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_BG]));
length_reinit_color = strlen (reinit_color);
snprintf (reinit_color_space, sizeof (reinit_color_space),
"%c%c%02d,%02d ",
GUI_COLOR_COLOR_CHAR,
GUI_COLOR_FG_BG_CHAR,
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_FG]),
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_BG]));
length_reinit_color_space = strlen (reinit_color_space);
content = NULL;
content_length = 1;
filling = gui_bar_get_filling (bar_window->bar);
switch (filling)
{
case GUI_BAR_FILLING_HORIZONTAL: /* items separated by space */
case GUI_BAR_FILLING_VERTICAL: /* items separated by \n */
for (i = 0; i < bar_window->items_count; i++)
{
first_sub_item = 1;
for (sub = 0; sub < bar_window->items_subcount[i]; sub++)
{
ptr_content = gui_bar_window_content_get (bar_window, window,
i, sub);
if (ptr_content && ptr_content[0])
{
if (gui_bar_get_filling (bar_window->bar) == GUI_BAR_FILLING_HORIZONTAL)
{
item_value = string_replace (ptr_content, "\n",
reinit_color_space);
if (item_value)
{
item_value2 = string_replace (item_value,
"\r", "\n");
if (item_value2)
{
free (item_value);
item_value = item_value2;
}
}
}
else
item_value = NULL;
if (!content)
{
content_length += strlen ((item_value) ?
item_value : ptr_content);
content = strdup ((item_value) ? item_value : ptr_content);
first_sub_item = 0;
}
else
{
content_length += length_reinit_color_space +
strlen ((item_value) ? item_value : ptr_content);
content = realloc (content, content_length);
if (first_sub_item)
{
/* first sub item: insert space after last item */
if (gui_bar_get_filling (bar_window->bar) == GUI_BAR_FILLING_HORIZONTAL)
strcat (content, reinit_color_space);
else
strcat (content, "\n");
}
else
{
strcat (content, reinit_color);
}
strcat (content,
(item_value) ? item_value : ptr_content);
first_sub_item = 0;
}
if (item_value)
free (item_value);
}
}
}
break;
case GUI_BAR_FILLING_COLUMNS_HORIZONTAL: /* items in columns, with horizontal filling */
case GUI_BAR_FILLING_COLUMNS_VERTICAL: /* items in columns, with vertical filling */
content = NULL;
total_items = 0;
max_length = 1;
max_length_screen = 1;
split_items = malloc(bar_window->items_count * sizeof(*split_items));
for (i = 0; i < bar_window->items_count; i++)
{
if (bar_window->items_subcount[i] > 0)
{
split_items[i] = malloc (bar_window->items_subcount[i] * sizeof (**split_items));
for (sub = 0; sub < bar_window->items_subcount[i]; sub++)
{
ptr_content = gui_bar_window_content_get (bar_window, window,
i, sub);
if (ptr_content && ptr_content[0])
{
split_items[i][sub] = string_split (ptr_content,
"\n", 0, 0, NULL);
for (j = 0; split_items[i][sub][j]; j++)
{
total_items++;
length = strlen (split_items[i][sub][j]);
if (length > max_length)
max_length = length;
length = gui_chat_strlen_screen (split_items[i][sub][j]);
if (length > max_length_screen)
max_length_screen = length;
}
}
else
split_items[i] = NULL;
}
}
else
split_items[i] = NULL;
}
if ((CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_POSITION]) == GUI_BAR_POSITION_BOTTOM)
|| (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_POSITION]) == GUI_BAR_POSITION_TOP))
{
columns = bar_window->width / (max_length_screen + 1);
if (columns == 0)
columns = 1;
lines = total_items / columns;
if (total_items % columns != 0)
lines++;
}
else
{
columns = total_items / bar_window->height;
if (total_items % bar_window->height != 0)
columns++;
lines = bar_window->height;
}
/* build array with pointers to split items */
linear_items = malloc (total_items * sizeof (*linear_items));
if (linear_items)
{
index = 0;
for (i = 0; i < bar_window->items_count; i++)
{
if (split_items[i])
{
for (sub = 0; sub < bar_window->items_subcount[i]; sub++)
{
if (split_items[i][sub])
{
for (j = 0; split_items[i][sub][j]; j++)
{
linear_items[index++] = split_items[i][sub][j];
}
}
}
}
}
/* build content with lines and columns */
content = malloc (1 + (lines *
((columns *
(max_length + max_length_screen + length_reinit_color_space)) + 1)));
if (content)
{
content[0] = '\0';
index_content = 0;
for (i = 0; i < lines; i++)
{
for (j = 0; j < columns; j++)
{
if (filling == GUI_BAR_FILLING_COLUMNS_HORIZONTAL)
index = (i * columns) + j;
else
index = (j * lines) + i;
if (index >= total_items)
{
for (k = 0; k < max_length_screen; k++)
{
content[index_content++] = ' ';
}
}
else
{
strcpy (content + index_content, linear_items[index]);
index_content += strlen (linear_items[index]);
length = max_length_screen -
gui_chat_strlen_screen (linear_items[index]);
for (k = 0; k < length; k++)
{
content[index_content++] = ' ';
}
}
if (j < columns - 1)
{
strcpy (content + index_content, reinit_color_space);
index_content += length_reinit_color_space;
}
}
content[index_content++] = '\n';
}
content[index_content] = '\0';
}
free (linear_items);
}
for (i = 0; i < bar_window->items_count; i++)
{
if (split_items[i])
{
for (sub = 0; sub < bar_window->items_subcount[i]; sub++)
{
if (split_items[i][sub])
string_free_split (split_items[i][sub]);
}
free (split_items[i]);
}
}
free (split_items);
break;
case GUI_BAR_NUM_FILLING:
break;
}
return content;
}
TEST(String, Split)
{
char **argv;
int argc;
POINTERS_EQUAL(NULL, string_split (NULL, NULL, 0, 0, NULL));
POINTERS_EQUAL(NULL, string_split (NULL, "", 0, 0, NULL));
POINTERS_EQUAL(NULL, string_split ("", NULL, 0, 0, NULL));
POINTERS_EQUAL(NULL, string_split ("", "", 0, 0, NULL));
argc = -1;
POINTERS_EQUAL(NULL, string_split (NULL, NULL, 0, 0, &argc));
LONGS_EQUAL(0, argc);
argc = -1;
POINTERS_EQUAL(NULL, string_split (NULL, "", 0, 0, &argc));
LONGS_EQUAL(0, argc);
argc = -1;
POINTERS_EQUAL(NULL, string_split ("", NULL, 0, 0, &argc));
LONGS_EQUAL(0, argc);
argc = -1;
POINTERS_EQUAL(NULL, string_split ("", "", 0, 0, &argc));
LONGS_EQUAL(0, argc);
/* free split with NULL */
string_free_split (NULL);
/* standard split */
argv = string_split (" abc de fghi ", " ", 0, 0, &argc);
LONGS_EQUAL(3, argc);
CHECK(argv);
STRCMP_EQUAL("abc", argv[0]);
STRCMP_EQUAL("de", argv[1]);
STRCMP_EQUAL("fghi", argv[2]);
POINTERS_EQUAL(NULL, argv[3]);
string_free_split (argv);
/* max 2 items */
argv = string_split (" abc de fghi ", " ", 0, 2, &argc);
LONGS_EQUAL(2, argc);
CHECK(argv);
STRCMP_EQUAL("abc", argv[0]);
STRCMP_EQUAL("de", argv[1]);
POINTERS_EQUAL(NULL, argv[2]);
string_free_split (argv);
/* keep eol == 1 */
argv = string_split (" abc de fghi ", " ", 1, 0, &argc);
LONGS_EQUAL(3, argc);
CHECK(argv);
STRCMP_EQUAL("abc de fghi", argv[0]);
STRCMP_EQUAL("de fghi", argv[1]);
STRCMP_EQUAL("fghi", argv[2]);
POINTERS_EQUAL(NULL, argv[3]);
string_free_split (argv);
/* keep eol == 1 and max 2 items */
argv = string_split (" abc de fghi ", " ", 1, 2, &argc);
LONGS_EQUAL(2, argc);
CHECK(argv);
STRCMP_EQUAL("abc de fghi", argv[0]);
STRCMP_EQUAL("de fghi", argv[1]);
POINTERS_EQUAL(NULL, argv[2]);
string_free_split (argv);
/* keep eol == 2 */
argv = string_split (" abc de fghi ", " ", 2, 0, &argc);
LONGS_EQUAL(3, argc);
CHECK(argv);
STRCMP_EQUAL("abc de fghi ", argv[0]);
STRCMP_EQUAL("de fghi ", argv[1]);
STRCMP_EQUAL("fghi ", argv[2]);
POINTERS_EQUAL(NULL, argv[3]);
string_free_split (argv);
/* keep eol == 2 and max 2 items */
argv = string_split (" abc de fghi ", " ", 2, 2, &argc);
LONGS_EQUAL(2, argc);
CHECK(argv);
STRCMP_EQUAL("abc de fghi ", argv[0]);
STRCMP_EQUAL("de fghi ", argv[1]);
POINTERS_EQUAL(NULL, argv[2]);
string_free_split (argv);
}
struct t_gui_filter *
gui_filter_new (int enabled, const char *name, const char *buffer_name,
const char *tags, const char *regex)
{
struct t_gui_filter *new_filter;
regex_t *regex1, *regex2;
char *pos_tab, *regex_prefix, **tags_array, buf[512], str_error[512];
const char *ptr_start_regex, *pos_regex_message;
int i, rc;
if (!name || !buffer_name || !tags || !regex)
{
gui_filter_new_error (name, _("not enough arguments"));
return NULL;
}
if (gui_filter_search_by_name (name))
{
gui_filter_new_error (name,
_("a filter with same name already exists"));
return NULL;
}
ptr_start_regex = regex;
if ((ptr_start_regex[0] == '!')
|| ((ptr_start_regex[0] == '\\') && (ptr_start_regex[1] == '!')))
{
ptr_start_regex++;
}
regex1 = NULL;
regex2 = NULL;
if (strcmp (ptr_start_regex, "*") != 0)
{
pos_tab = strstr (ptr_start_regex, "\\t");
if (pos_tab)
{
regex_prefix = string_strndup (ptr_start_regex,
pos_tab - ptr_start_regex);
pos_regex_message = pos_tab + 2;
}
else
{
regex_prefix = NULL;
pos_regex_message = ptr_start_regex;
}
if (regex_prefix && regex_prefix[0])
{
regex1 = malloc (sizeof (*regex1));
if (regex1)
{
rc = string_regcomp (regex1, regex_prefix,
REG_EXTENDED | REG_ICASE | REG_NOSUB);
if (rc != 0)
{
regerror (rc, regex1, buf, sizeof (buf));
snprintf (str_error, sizeof (str_error),
/* TRANSLATORS: %s is the error returned by regerror */
_("invalid regular expression (%s)"),
buf);
gui_filter_new_error (name, str_error);
free (regex_prefix);
free (regex1);
return NULL;
}
}
}
if (pos_regex_message && pos_regex_message[0])
{
regex2 = malloc (sizeof (*regex2));
if (regex2)
{
rc = string_regcomp (regex2, pos_regex_message,
REG_EXTENDED | REG_ICASE | REG_NOSUB);
if (rc != 0)
{
regerror (rc, regex2, buf, sizeof (buf));
snprintf (str_error, sizeof (str_error),
/* TRANSLATORS: %s is the error returned by regerror */
_("invalid regular expression (%s)"),
buf);
gui_filter_new_error (name, str_error);
if (regex_prefix)
free (regex_prefix);
if (regex1)
{
regfree (regex1);
free (regex1);
}
free (regex2);
return NULL;
}
}
}
if (regex_prefix)
free (regex_prefix);
}
/* create new filter */
new_filter = malloc (sizeof (*new_filter));
if (new_filter)
{
/* init filter */
new_filter->enabled = enabled;
new_filter->name = strdup (name);
new_filter->buffer_name = strdup ((buffer_name) ? buffer_name : "*");
new_filter->buffers = string_split (new_filter->buffer_name,
",", 0, 0,
&new_filter->num_buffers);
new_filter->tags = (tags) ? strdup (tags) : NULL;
new_filter->tags_count = 0;
new_filter->tags_array = NULL;
if (new_filter->tags)
{
tags_array = string_split (new_filter->tags, ",", 0, 0,
&new_filter->tags_count);
if (tags_array)
{
new_filter->tags_array = malloc (new_filter->tags_count *
sizeof (*new_filter->tags_array));
if (new_filter->tags_array)
{
for (i = 0; i < new_filter->tags_count; i++)
{
new_filter->tags_array[i] = string_split (tags_array[i],
"+", 0, 0,
NULL);
}
}
string_free_split (tags_array);
}
}
new_filter->regex = strdup (regex);
new_filter->regex_prefix = regex1;
new_filter->regex_message = regex2;
/* add filter to filters list */
new_filter->prev_filter = last_gui_filter;
if (gui_filters)
last_gui_filter->next_filter = new_filter;
else
gui_filters = new_filter;
last_gui_filter = new_filter;
new_filter->next_filter = NULL;
(void) hook_signal_send ("filter_added",
WEECHAT_HOOK_SIGNAL_POINTER, new_filter);
}
else
{
gui_filter_new_error (name, _("not enough memory"));
}
return new_filter;
}
TEST(String, Split)
{
char **argv, *str;
int argc;
POINTERS_EQUAL(NULL, string_split (NULL, NULL, 0, 0, NULL));
POINTERS_EQUAL(NULL, string_split (NULL, "", 0, 0, NULL));
POINTERS_EQUAL(NULL, string_split ("", NULL, 0, 0, NULL));
POINTERS_EQUAL(NULL, string_split ("", "", 0, 0, NULL));
argc = 1;
POINTERS_EQUAL(NULL, string_split (NULL, NULL, 0, 0, &argc));
LONGS_EQUAL(0, argc);
argc = 1;
POINTERS_EQUAL(NULL, string_split (NULL, "", 0, 0, &argc));
LONGS_EQUAL(0, argc);
argc = 1;
POINTERS_EQUAL(NULL, string_split ("", NULL, 0, 0, &argc));
LONGS_EQUAL(0, argc);
argc = 1;
POINTERS_EQUAL(NULL, string_split ("", "", 0, 0, &argc));
LONGS_EQUAL(0, argc);
/* free split with NULL */
string_free_split (NULL);
string_free_split_shared (NULL);
string_free_split_command (NULL);
/* standard split */
argv = string_split (" abc de fghi ", " ", 0, 0, &argc);
LONGS_EQUAL(3, argc);
STRCMP_EQUAL("abc", argv[0]);
STRCMP_EQUAL("de", argv[1]);
STRCMP_EQUAL("fghi", argv[2]);
POINTERS_EQUAL(NULL, argv[3]);
string_free_split (argv);
/* max 2 items */
argv = string_split (" abc de fghi ", " ", 0, 2, &argc);
LONGS_EQUAL(2, argc);
STRCMP_EQUAL("abc", argv[0]);
STRCMP_EQUAL("de", argv[1]);
POINTERS_EQUAL(NULL, argv[2]);
string_free_split (argv);
/* keep eol */
argv = string_split (" abc de fghi ", " ", 1, 0, &argc);
LONGS_EQUAL(3, argc);
STRCMP_EQUAL("abc de fghi", argv[0]);
STRCMP_EQUAL("de fghi", argv[1]);
STRCMP_EQUAL("fghi", argv[2]);
POINTERS_EQUAL(NULL, argv[3]);
string_free_split (argv);
/* keep eol and max 2 items */
argv = string_split (" abc de fghi ", " ", 1, 2, &argc);
LONGS_EQUAL(2, argc);
STRCMP_EQUAL("abc de fghi", argv[0]);
STRCMP_EQUAL("de fghi", argv[1]);
POINTERS_EQUAL(NULL, argv[2]);
string_free_split (argv);
/* split with shared strings */
argv = string_split_shared (" abc de abc ", " ", 0, 0, &argc);
LONGS_EQUAL(3, argc);
STRCMP_EQUAL("abc", argv[0]);
STRCMP_EQUAL("de", argv[1]);
STRCMP_EQUAL("abc", argv[2]);
POINTERS_EQUAL(NULL, argv[3]);
/* same content == same pointer for shared strings */
POINTERS_EQUAL(argv[0], argv[2]);
string_free_split_shared (argv);
/* build string with split string */
str = string_build_with_split_string (NULL, NULL);
POINTERS_EQUAL(NULL, str);
argv = string_split (" abc de fghi ", " ", 0, 0, &argc);
str = string_build_with_split_string ((const char **)argv, NULL);
STRCMP_EQUAL("abcdefghi", str);
free (str);
str = string_build_with_split_string ((const char **)argv, "");
STRCMP_EQUAL("abcdefghi", str);
free (str);
str = string_build_with_split_string ((const char **)argv, ";;");
STRCMP_EQUAL("abc;;de;;fghi", str);
free (str);
string_free_split (argv);
/* split command */
POINTERS_EQUAL(NULL, string_split_command (NULL, ';'));
POINTERS_EQUAL(NULL, string_split_command ("", ';'));
argv = string_split_command ("abc;de;fghi", ';');
LONGS_EQUAL(3, argc);
STRCMP_EQUAL("abc", argv[0]);
STRCMP_EQUAL("de", argv[1]);
STRCMP_EQUAL("fghi", argv[2]);
POINTERS_EQUAL(NULL, argv[3]);
string_free_split_command (argv);
}
void
gui_bar_window_draw (struct t_gui_bar_window *bar_window,
struct t_gui_window *window)
{
int x, y, items_count, num_lines, line;
enum t_gui_bar_filling filling;
char *content, **items;
static char str_start_input[16] = { '\0' };
static char str_start_input_hidden[16] = { '\0' };
static char str_cursor[16] = { '\0' };
char *pos_start_input, *pos_after_start_input, *pos_cursor, *buf;
char *new_start_input, *ptr_string;
static int length_start_input, length_start_input_hidden;
int length_on_screen;
int chars_available, index, size;
int length_screen_before_cursor, length_screen_after_cursor;
int diff, max_length, optimal_number_of_lines;
int some_data_not_displayed;
int index_item, index_subitem, index_line;
if (!gui_init_ok)
return;
if (gui_window_bare_display)
return;
if ((bar_window->x < 0) || (bar_window->y < 0))
return;
if (!str_start_input[0])
{
snprintf (str_start_input, sizeof (str_start_input), "%c%c%c",
GUI_COLOR_COLOR_CHAR,
GUI_COLOR_BAR_CHAR,
GUI_COLOR_BAR_START_INPUT_CHAR);
length_start_input = strlen (str_start_input);
snprintf (str_start_input_hidden, sizeof (str_start_input_hidden), "%c%c%c",
GUI_COLOR_COLOR_CHAR,
GUI_COLOR_BAR_CHAR,
GUI_COLOR_BAR_START_INPUT_HIDDEN_CHAR);
length_start_input_hidden = strlen (str_start_input_hidden);
snprintf (str_cursor, sizeof (str_cursor), "%c%c%c",
GUI_COLOR_COLOR_CHAR,
GUI_COLOR_BAR_CHAR,
GUI_COLOR_BAR_MOVE_CURSOR_CHAR);
}
/*
* these values will be overwritten later (by gui_bar_window_print_string)
* if cursor has to move somewhere in bar window
*/
bar_window->cursor_x = -1;
bar_window->cursor_y = -1;
/* remove coords */
gui_bar_window_coords_free (bar_window);
index_item = -1;
index_subitem = -1;
index_line = 0;
gui_window_current_emphasis = 0;
filling = gui_bar_get_filling (bar_window->bar);
content = gui_bar_window_content_get_with_filling (bar_window, window);
if (content)
{
if ((filling == GUI_BAR_FILLING_HORIZONTAL)
&& (bar_window->scroll_x > 0))
{
length_on_screen = gui_chat_strlen_screen (content);
if (bar_window->scroll_x > length_on_screen - bar_window->width)
{
bar_window->scroll_x = length_on_screen - bar_window->width;
if (bar_window->scroll_x < 0)
bar_window->scroll_x = 0;
}
}
items = string_split (content, "\n", 0, 0, &items_count);
if (items_count == 0)
{
if (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_SIZE]) == 0)
gui_bar_window_set_current_size (bar_window, window, 1);
gui_window_clear (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_FG]),
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_BG]));
}
else
{
/* bar with auto size ? then compute new size, according to content */
if (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_SIZE]) == 0)
{
/* search longer line and optimal number of lines */
max_length = 0;
optimal_number_of_lines = 0;
for (line = 0; line < items_count; line++)
{
length_on_screen = gui_chat_strlen_screen (items[line]);
pos_cursor = strstr (items[line], str_cursor);
if (pos_cursor && (gui_chat_strlen_screen (pos_cursor) == 0))
length_on_screen++;
if (length_on_screen > max_length)
max_length = length_on_screen;
if (length_on_screen % bar_window->width == 0)
num_lines = length_on_screen / bar_window->width;
else
num_lines = (length_on_screen / bar_window->width) + 1;
if (num_lines == 0)
num_lines = 1;
optimal_number_of_lines += num_lines;
}
if (max_length == 0)
max_length = 1;
switch (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_POSITION]))
{
case GUI_BAR_POSITION_BOTTOM:
case GUI_BAR_POSITION_TOP:
if (filling == GUI_BAR_FILLING_HORIZONTAL)
num_lines = optimal_number_of_lines;
else
num_lines = items_count;
gui_bar_window_set_current_size (bar_window, window,
num_lines);
break;
case GUI_BAR_POSITION_LEFT:
case GUI_BAR_POSITION_RIGHT:
gui_bar_window_set_current_size (bar_window, window,
max_length);
break;
case GUI_BAR_NUM_POSITIONS:
break;
}
}
gui_window_clear (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_FG]),
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_BG]));
x = 0;
y = 0;
some_data_not_displayed = 0;
if ((bar_window->scroll_y > 0)
&& (bar_window->scroll_y > items_count - bar_window->height))
{
bar_window->scroll_y = items_count - bar_window->height;
if (bar_window->scroll_y < 0)
bar_window->scroll_y = 0;
}
for (line = 0;
(line < items_count) && (y < bar_window->height);
line++)
{
pos_start_input = strstr (items[line], str_start_input);
if (pos_start_input)
{
pos_after_start_input = pos_start_input + strlen (str_start_input);
pos_cursor = strstr (pos_after_start_input, str_cursor);
if (pos_cursor)
{
chars_available =
((bar_window->height - y - 1) * bar_window->width) + /* next lines */
(bar_window->width - x - 1); /* chars on current line */
length_screen_before_cursor = -1;
length_screen_after_cursor = -1;
buf = string_strndup (items[line], pos_cursor - items[line]);
if (buf)
{
length_screen_before_cursor = gui_chat_strlen_screen (buf);
length_screen_after_cursor = gui_chat_strlen_screen (pos_cursor);
free (buf);
}
if ((length_screen_before_cursor < 0) || (length_screen_after_cursor < 0))
length_screen_before_cursor = gui_chat_strlen_screen (items[line]);
diff = length_screen_before_cursor - chars_available;
if (diff > 0)
{
if (CONFIG_INTEGER(config_look_input_cursor_scroll) > 0)
{
diff += (CONFIG_INTEGER(config_look_input_cursor_scroll)
- 1
- (diff % CONFIG_INTEGER(config_look_input_cursor_scroll)));
}
/* compute new start for displaying input */
new_start_input = pos_after_start_input +
gui_chat_string_real_pos (pos_after_start_input,
diff, 1);
if (new_start_input > pos_cursor)
new_start_input = pos_cursor;
buf = malloc (strlen (items[line]) + length_start_input_hidden + 1);
if (buf)
{
/* add string before start of input */
index = 0;
if (pos_start_input > items[line])
{
size = pos_start_input - items[line];
memmove (buf, items[line], size);
index += size;
}
/* add tag "start_input_hidden" */
memmove (buf + index, str_start_input_hidden, length_start_input_hidden);
index += length_start_input_hidden;
/* add hidden part of input */
size = new_start_input - pos_after_start_input;
memmove (buf + index, pos_after_start_input, size);
index += size;
/* add tag "start_input" */
memmove (buf + index, str_start_input, length_start_input);
index += length_start_input;
/* add input (will be displayed) */
size = strlen (new_start_input) + 1;
memmove (buf + index, new_start_input, size);
free (items[line]);
items[line] = buf;
}
}
}
}
if ((bar_window->scroll_y == 0)
|| (line >= bar_window->scroll_y))
{
if (!gui_bar_window_print_string (bar_window, filling,
&x, &y,
items[line], 1, 1,
&index_item,
&index_subitem,
&index_line))
{
some_data_not_displayed = 1;
}
if (x < bar_window->width)
{
if (filling == GUI_BAR_FILLING_HORIZONTAL)
{
gui_window_set_custom_color_fg_bg (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_FG]),
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_BG]));
gui_window_remove_color_style (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
A_ALL_ATTR);
wclrtobot (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar);
}
else
{
gui_window_remove_color_style (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
A_ALL_ATTR);
}
while (x < bar_window->width)
{
gui_bar_window_print_string (bar_window, filling,
&x, &y, " ", 0, 0,
&index_item,
&index_subitem,
&index_line);
}
}
x = 0;
y++;
}
}
if ((bar_window->cursor_x < 0) && (bar_window->cursor_y < 0)
&& ((bar_window->scroll_x > 0) || (bar_window->scroll_y > 0)))
{
if (filling == GUI_BAR_FILLING_HORIZONTAL)
{
ptr_string = CONFIG_STRING(config_look_bar_more_left);
x = 0;
}
else
{
ptr_string = CONFIG_STRING(config_look_bar_more_up);
x = bar_window->width - utf8_strlen_screen (ptr_string);
if (x < 0)
x = 0;
}
y = 0;
if (ptr_string && ptr_string[0])
{
gui_window_set_custom_color_fg_bg (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
CONFIG_COLOR(config_color_bar_more),
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_BG]));
mvwaddstr (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
y, x, ptr_string);
}
}
if ((bar_window->cursor_x < 0) && (bar_window->cursor_y < 0)
&& (some_data_not_displayed || (line < items_count)))
{
ptr_string = (filling == GUI_BAR_FILLING_HORIZONTAL) ?
CONFIG_STRING(config_look_bar_more_right) :
CONFIG_STRING(config_look_bar_more_down);
x = bar_window->width - utf8_strlen_screen (ptr_string);
if (x < 0)
x = 0;
y = (bar_window->height > 1) ? bar_window->height - 1 : 0;
if (ptr_string && ptr_string[0])
{
gui_window_set_custom_color_fg_bg (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
CONFIG_COLOR(config_color_bar_more),
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_BG]));
mvwaddstr (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
y, x, ptr_string);
}
}
}
if (items)
string_free_split (items);
free (content);
}
else
{
if (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_SIZE]) == 0)
gui_bar_window_set_current_size (bar_window, window, 1);
gui_window_clear (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar,
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_FG]),
CONFIG_COLOR(bar_window->bar->options[GUI_BAR_OPTION_COLOR_BG]));
}
/*
* move cursor if it was asked in an item content (input_text does that
* to move cursor in user input text)
*/
if ((!window || (gui_current_window == window))
&& (bar_window->cursor_x >= 0) && (bar_window->cursor_y >= 0))
{
y = bar_window->cursor_y - bar_window->y;
x = bar_window->cursor_x - bar_window->x;
if (x > bar_window->width - 2)
x = bar_window->width - 2;
wmove (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar, y, x);
wrefresh (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar);
if (!gui_cursor_mode)
{
gui_window_cursor_x = bar_window->cursor_x;
gui_window_cursor_y = bar_window->cursor_y;
move (bar_window->cursor_y, bar_window->cursor_x);
}
}
else
wnoutrefresh (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar);
if (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_SEPARATOR]))
{
switch (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_POSITION]))
{
case GUI_BAR_POSITION_BOTTOM:
gui_window_set_weechat_color (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator,
GUI_COLOR_SEPARATOR);
gui_window_hline (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator,
0, 0, bar_window->width,
CONFIG_STRING(config_look_separator_horizontal));
break;
case GUI_BAR_POSITION_TOP:
gui_window_set_weechat_color (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator,
GUI_COLOR_SEPARATOR);
gui_window_hline (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator,
0, 0, bar_window->width,
CONFIG_STRING(config_look_separator_horizontal));
break;
case GUI_BAR_POSITION_LEFT:
gui_window_set_weechat_color (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator,
GUI_COLOR_SEPARATOR);
gui_window_vline (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator,
0, 0, bar_window->height,
CONFIG_STRING(config_look_separator_vertical));
break;
case GUI_BAR_POSITION_RIGHT:
gui_window_set_weechat_color (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator,
GUI_COLOR_SEPARATOR);
gui_window_vline (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator,
0, 0, bar_window->height,
CONFIG_STRING(config_look_separator_vertical));
break;
case GUI_BAR_NUM_POSITIONS:
break;
}
wnoutrefresh (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator);
}
refresh ();
}
int
upgrade_file_write_object (struct t_upgrade_file *upgrade_file, int object_id,
struct t_infolist *infolist)
{
int i, argc, length;
char **argv;
const char *fields;
void *buf;
/* write all infolist variables */
infolist_reset_item_cursor (infolist);
while (infolist_next (infolist))
{
/* write object start with id */
if (!upgrade_file_write_integer (upgrade_file, UPGRADE_TYPE_OBJECT_START))
{
UPGRADE_ERROR(_("write - object type"), "object start");
return 0;
}
if (!upgrade_file_write_integer (upgrade_file, object_id))
{
UPGRADE_ERROR(_("write - object id"), "");
return 0;
}
fields = infolist_fields (infolist);
if (fields)
{
argv = string_split (fields, ",", 0, 0, &argc);
if (argv && (argc > 0))
{
for (i = 0; i < argc; i++)
{
switch (argv[i][0])
{
case 'i': /* integer */
if (!upgrade_file_write_integer (upgrade_file, UPGRADE_TYPE_OBJECT_VAR))
{
UPGRADE_ERROR(_("write - object type"), "object var");
return 0;
}
if (!upgrade_file_write_string (upgrade_file, argv[i] + 2))
{
UPGRADE_ERROR(_("write - variable name"), "");
return 0;
}
if (!upgrade_file_write_integer (upgrade_file, INFOLIST_INTEGER))
{
UPGRADE_ERROR(_("write - infolist type"), "integer");
return 0;
}
if (!upgrade_file_write_integer (upgrade_file,
infolist_integer (infolist, argv[i] + 2)))
{
UPGRADE_ERROR(_("write - variable"), "integer");
return 0;
}
break;
case 's': /* string */
if (!upgrade_file_write_integer (upgrade_file, UPGRADE_TYPE_OBJECT_VAR))
{
UPGRADE_ERROR(_("write - object type"), "object var");
return 0;
}
if (!upgrade_file_write_string (upgrade_file, argv[i] + 2))
{
UPGRADE_ERROR(_("write - variable name"), "");
return 0;
}
if (!upgrade_file_write_integer (upgrade_file, INFOLIST_STRING))
{
UPGRADE_ERROR(_("write - infolist type"), "string");
return 0;
}
if (!upgrade_file_write_string (upgrade_file,
infolist_string (infolist, argv[i] + 2)))
{
UPGRADE_ERROR(_("write - variable"), "string");
return 0;
}
break;
case 'p': /* pointer */
/* pointer in not used in upgrade files, only buffer is */
break;
case 'b': /* buffer */
buf = infolist_buffer (infolist, argv[i] + 2, &length);
if (buf && (length > 0))
{
if (!upgrade_file_write_integer (upgrade_file, UPGRADE_TYPE_OBJECT_VAR))
{
UPGRADE_ERROR(_("write - object type"), "object var");
return 0;
}
if (!upgrade_file_write_string (upgrade_file, argv[i] + 2))
{
UPGRADE_ERROR(_("write - variable name"), "");
return 0;
}
if (!upgrade_file_write_integer (upgrade_file, INFOLIST_BUFFER))
{
UPGRADE_ERROR(_("write - infolist type"), "buffer");
return 0;
}
if (!upgrade_file_write_buffer (upgrade_file, buf, length))
{
UPGRADE_ERROR(_("write - variable"), "buffer");
return 0;
}
}
break;
case 't': /* time */
if (!upgrade_file_write_integer (upgrade_file, UPGRADE_TYPE_OBJECT_VAR))
{
UPGRADE_ERROR(_("write - object type"), "object var");
return 0;
}
if (!upgrade_file_write_string (upgrade_file, argv[i] + 2))
{
UPGRADE_ERROR(_("write - variable name"), "");
return 0;
}
if (!upgrade_file_write_integer (upgrade_file, INFOLIST_TIME))
{
UPGRADE_ERROR(_("write - infolist type"), "time");
return 0;
}
if (!upgrade_file_write_time (upgrade_file,
infolist_time (infolist, argv[i] + 2)))
{
UPGRADE_ERROR(_("write - variable"), "time");
return 0;
}
break;
}
}
}
if (argv)
string_free_split (argv);
}
/* write object end */
if (!upgrade_file_write_integer (upgrade_file, UPGRADE_TYPE_OBJECT_END))
return 0;
}
return 1;
}
struct t_gui_color_palette *
gui_color_palette_new (int number, const char *value)
{
struct t_gui_color_palette *new_color_palette;
char **items, *pos, *pos2, *error1, *error2, *error3;
char *str_alias, *str_rgb, str_number[64];
int num_items, i, r, g, b;
if (!value)
return NULL;
new_color_palette = malloc (sizeof (*new_color_palette));
if (new_color_palette)
{
new_color_palette->alias = NULL;
new_color_palette->r = -1;
new_color_palette->g = -1;
new_color_palette->b = -1;
str_alias = NULL;
str_rgb = NULL;
items = string_split (value, ";", 0, 0, &num_items);
if (items)
{
for (i = 0; i < num_items; i++)
{
pos = strchr (items[i], '/');
if (pos)
str_rgb = items[i];
else
{
pos = strchr (items[i], ',');
if (!pos)
str_alias = items[i];
}
}
if (str_alias)
{
new_color_palette->alias = strdup (str_alias);
}
if (str_rgb)
{
pos = strchr (str_rgb, '/');
if (pos)
{
pos[0] = '\0';
pos2 = strchr (pos + 1, '/');
if (pos2)
{
pos2[0] = '\0';
error1 = NULL;
r = (int)strtol (str_rgb, &error1, 10);
error2 = NULL;
g = (int)strtol (pos + 1, &error2, 10);
error3 = NULL;
b = (int)strtol (pos2 + 1, &error3, 10);
if (error1 && !error1[0] && error2 && !error2[0]
&& error3 && !error3[0]
&& (r >= 0) && (r <= 1000)
&& (g >= 0) && (g <= 1000)
&& (b >= 0) && (b <= 1000))
{
new_color_palette->r = r;
new_color_palette->g = g;
new_color_palette->b = b;
}
}
}
}
string_free_split (items);
}
if (!new_color_palette->alias)
{
snprintf (str_number, sizeof (str_number), "%d", number);
new_color_palette->alias = strdup (str_number);
}
}
return new_color_palette;
}
void
gui_color_buffer_display ()
{
int y, i, lines, line, col, color, max_color, num_items;
char str_line[1024], str_color[64], str_rgb[64], **items;
struct t_gui_color_palette *color_palette;
if (!gui_color_buffer)
return;
gui_buffer_clear (gui_color_buffer);
/* set title buffer */
gui_buffer_set_title (gui_color_buffer,
_("WeeChat colors | Actions: "
"[e] Display extra infos [r] Refresh "
"[z] Reset colors [q] Close buffer | "
"Keys: [alt-c] Temporarily switch to terminal "
"colors"));
/* display terminal/colors infos */
y = 0;
gui_color_info_term_colors (str_line, sizeof (str_line));
gui_chat_printf_y (gui_color_buffer, y++, "%s", str_line);
/* display palette of colors */
y++;
if (gui_color_use_term_colors)
{
gui_color_buffer_display_timer ();
y++;
}
else
{
gui_chat_printf_y (gui_color_buffer, y++,
_("WeeChat color pairs (in use: %d, left: %d):"),
gui_color_pairs_used,
gui_color_num_pairs - gui_color_pairs_used);
}
max_color = (gui_color_use_term_colors) ?
gui_color_term_colors - 1 : gui_color_num_pairs;
if (max_color > 255)
max_color = 255;
lines = (max_color <= 64) ? 8 : 16;
for (line = 0; line < lines; line++)
{
str_line[0] = '\0';
for (col = 0; col < 16; col++)
{
color = (col * lines) + line;
if (color <= max_color)
{
if (color == 0)
{
snprintf (str_color, sizeof (str_color),
" ");
}
else if (gui_color_use_term_colors
|| (color <= gui_color_pairs_used))
{
snprintf (str_color, sizeof (str_color),
"%c%c%05d%c%03d%c",
GUI_COLOR_COLOR_CHAR,
GUI_COLOR_EXTENDED_CHAR,
color,
(color == 0) ? '<' : ' ',
color,
(color == 0) ? '>' : ' ');
}
else
{
snprintf (str_color, sizeof (str_color),
"%s - ",
GUI_NO_COLOR);
}
strcat (str_line, str_color);
}
else
{
snprintf (str_color, sizeof (str_color),
"%s ",
GUI_COLOR(GUI_COLOR_CHAT));
strcat (str_line, str_color);
}
}
gui_chat_printf_y (gui_color_buffer, y++,
" %s",
str_line);
}
if (gui_color_buffer_extra_info)
{
/* display time of last auto reset of color pairs */
y++;
gui_chat_printf_y (gui_color_buffer, y++,
_("Last auto reset of pairs: %s"),
(gui_color_pairs_auto_reset_last == 0) ?
"-" : ctime (&gui_color_pairs_auto_reset_last));
/* display WeeChat basic colors */
y++;
gui_chat_printf_y (gui_color_buffer, y++,
_("WeeChat basic colors:"));
str_line[0] = '\0';
for (i = 0; i < GUI_CURSES_NUM_WEECHAT_COLORS; i++)
{
if (gui_color_use_term_colors)
{
snprintf (str_color, sizeof (str_color),
" %s",
gui_weechat_colors[i].string);
}
else
{
snprintf (str_color, sizeof (str_color),
"%c%c%02d %s",
GUI_COLOR_COLOR_CHAR,
GUI_COLOR_FG_CHAR,
i,
gui_weechat_colors[i].string);
}
if (gui_chat_strlen_screen (str_line) + gui_chat_strlen_screen (str_color) > 80)
{
gui_chat_printf_y (gui_color_buffer, y++,
" %s", str_line);
str_line[0] = '\0';
}
strcat (str_line, str_color);
}
if (str_line[0])
{
gui_chat_printf_y (gui_color_buffer, y++,
" %s", str_line);
}
/* display nick colors */
y++;
gui_chat_printf_y (gui_color_buffer, y++,
_("Nick colors:"));
items = string_split (CONFIG_STRING(config_color_chat_nick_colors),
",", 0, 0, &num_items);
if (items)
{
str_line[0] = '\0';
for (i = 0; i < num_items; i++)
{
if (gui_color_use_term_colors)
{
snprintf (str_color, sizeof (str_color),
" %s",
items[i]);
}
else
{
snprintf (str_color, sizeof (str_color),
"%s %s",
gui_color_get_custom (items[i]),
items[i]);
}
if (gui_chat_strlen_screen (str_line) + gui_chat_strlen_screen (str_color) > 80)
{
gui_chat_printf_y (gui_color_buffer, y++,
" %s", str_line);
str_line[0] = '\0';
}
strcat (str_line, str_color);
}
if (str_line[0])
{
gui_chat_printf_y (gui_color_buffer, y++,
" %s", str_line);
}
string_free_split (items);
}
/* display palette colors */
if (gui_color_hash_palette_color->items_count > 0)
{
y++;
gui_chat_printf_y (gui_color_buffer, y++,
_("Color aliases:"));
for (i = 1; i <= gui_color_num_pairs; i++)
{
color_palette = gui_color_palette_get (i);
if (color_palette)
{
str_color[0] = '\0';
if (!gui_color_use_term_colors)
{
snprintf (str_color, sizeof (str_color),
"%c%c%c%05d",
GUI_COLOR_COLOR_CHAR,
GUI_COLOR_FG_CHAR,
GUI_COLOR_EXTENDED_CHAR,
i);
}
str_rgb[0] = '\0';
if ((color_palette->r >= 0) && (color_palette->g >= 0)
&& (color_palette->b >= 0))
{
snprintf (str_rgb, sizeof (str_rgb),
" (%d/%d/%d)",
color_palette->r,
color_palette->g,
color_palette->b);
}
gui_chat_printf_y (gui_color_buffer, y++,
" %5d: %s%s%s",
i,
str_color,
(color_palette->alias) ? color_palette->alias : "",
str_rgb);
}
}
}
/* display content of colors */
if (gui_color_term_color_content)
{
y++;
gui_chat_printf_y (gui_color_buffer, y++,
_("Content of colors (r/g/b):"));
for (i = 0; i < gui_color_term_colors; i++)
{
gui_chat_printf_y (gui_color_buffer, y++,
" %3d: %4hd / %4hd / %4hd",
i,
gui_color_term_color_content[i * 3],
gui_color_term_color_content[(i* 3) + 1],
gui_color_term_color_content[(i* 3) + 2]);
}
}
}
}
int
gui_chat_hsignal_quote_line_cb (void *data, const char *signal,
struct t_hashtable *hashtable)
{
const char *time, *prefix, *message, *date, *nick, *tags;
unsigned int length_time, length_prefix, length_message, length;
char *str, *ptr_str_time, *custom_nick_prefix;
static char str_time[128];
struct tm local_time;
int tags_count, i, custom_nick_ok = 0;
char **tags_array;
/* make C compiler happy */
(void) data;
if (!gui_current_window->buffer->input)
return WEECHAT_RC_OK;
if (strstr(signal, "time"))
{
if (!CONFIG_STRING(config_look_quote_time_format) ||
!CONFIG_STRING(config_look_quote_time_format)[0])
time = hashtable_get (hashtable, "_chat_line_time");
else
{
date = hashtable_get (hashtable, "_chat_line_date");
if (date && date[0] && strptime (date, "%s", &local_time) && mktime(&local_time) != 0)
{
str_time[0] = '\0';
strftime (str_time, sizeof (str_time),
CONFIG_STRING(config_look_quote_time_format),
&local_time);
length_time = strlen(str_time);
ptr_str_time = malloc (length_time);
strncpy (ptr_str_time, str_time, length_time);
time = ptr_str_time;
}
else
time = NULL;
}
}
else
time = NULL;
prefix = (strstr (signal, "prefix")) ?
hashtable_get (hashtable, "_chat_line_prefix") : NULL;
message = hashtable_get (hashtable, "_chat_line_message");
if (!message)
return WEECHAT_RC_OK;
length_time = (time) ? strlen (time) : 0;
length_prefix = (prefix) ? strlen (prefix) : 0;
length_message = strlen (message);
nick = hashtable_get (hashtable, "_chat_line_nick");
tags = hashtable_get (hashtable, "_chat_line_tags");
if (prefix && nick && nick[0] &&
CONFIG_STRING(config_look_quote_nick_format) &&
CONFIG_STRING(config_look_quote_nick_format)[0])
{
tags_array = string_split (tags, ",", 0, 0, &tags_count);
if (tags_array)
{
for (i = 0; i < tags_count; i++)
{
if (!strcmp (tags_array[i], "irc_privmsg"))
custom_nick_ok = 1;
else if (!strcmp (tags_array[i], "irc_action"))
{
custom_nick_ok = 0;
break;
}
}
string_free_split(tags_array);
if (custom_nick_ok)
{
custom_nick_prefix = malloc (255);
length_prefix = snprintf (custom_nick_prefix, sizeof (custom_nick_prefix), CONFIG_STRING(config_look_quote_nick_format), nick);
if (length_prefix >= sizeof (custom_nick_prefix))
{
custom_nick_prefix = realloc (custom_nick_prefix, length_prefix + 1);
snprintf (custom_nick_prefix, length_prefix, CONFIG_STRING(config_look_quote_nick_format), nick);
}
}
}
}
length = length_time + 1 + length_prefix + 1 +
strlen (CONFIG_STRING(config_look_prefix_suffix)) + 1 +
length_message + 1 + 1;
str = malloc (length);
if (str)
{
if (custom_nick_ok)
{
snprintf (str, length, "%s%s%s%s%s ",
(time) ? time : "",
(time) ? " " : "",
(prefix) ? custom_nick_prefix : "",
(prefix) ? " " : "",
message);
}
else
{
snprintf (str, length, "%s%s%s%s%s%s%s ",
(time) ? time : "",
(time && !(prefix && prefix[0] == ' ')) ? " " : "",
(prefix) ? prefix : "",
(prefix && prefix[0]) ? " " : "",
((time || prefix) && CONFIG_BOOLEAN(config_look_quote_show_prefix_suffix)) ? CONFIG_STRING(config_look_prefix_suffix) : "",
((time || prefix) && CONFIG_BOOLEAN(config_look_quote_show_prefix_suffix) && CONFIG_STRING(config_look_prefix_suffix)
&& CONFIG_STRING(config_look_prefix_suffix)[0]) ? " " : "",
message);
}
gui_input_insert_string (gui_current_window->buffer, str, -1);
gui_input_text_changed_modifier_and_signal (gui_current_window->buffer,
1, /* save undo */
1); /* stop completion */
free (str);
}
return WEECHAT_RC_OK;
}
