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; }