int
proxy_add_to_infolist (struct t_infolist *infolist, struct t_proxy *proxy)
{
struct t_infolist_item *ptr_item;
if (!infolist || !proxy)
return 0;
ptr_item = infolist_new_item (infolist);
if (!ptr_item)
return 0;
if (!infolist_new_var_string (ptr_item, "name", proxy->name))
return 0;
if (!infolist_new_var_integer (ptr_item, "type", CONFIG_INTEGER(proxy->options[PROXY_OPTION_TYPE])))
return 0;
if (!infolist_new_var_string (ptr_item, "type_string", proxy_type_string[CONFIG_INTEGER(proxy->options[PROXY_OPTION_TYPE])]))
return 0;
if (!infolist_new_var_integer (ptr_item, "ipv6", CONFIG_INTEGER(proxy->options[PROXY_OPTION_IPV6])))
return 0;
if (!infolist_new_var_string (ptr_item, "address", CONFIG_STRING(proxy->options[PROXY_OPTION_ADDRESS])))
return 0;
if (!infolist_new_var_integer (ptr_item, "port", CONFIG_INTEGER(proxy->options[PROXY_OPTION_PORT])))
return 0;
if (!infolist_new_var_string (ptr_item, "username", CONFIG_STRING(proxy->options[PROXY_OPTION_USERNAME])))
return 0;
if (!infolist_new_var_string (ptr_item, "password", CONFIG_STRING(proxy->options[PROXY_OPTION_PASSWORD])))
return 0;
return 1;
}
void
weeurl_set_proxy (CURL *curl, struct t_proxy *proxy)
{
if (!proxy)
return;
/* set proxy type */
switch (CONFIG_INTEGER(proxy->options[PROXY_OPTION_TYPE]))
{
case PROXY_TYPE_HTTP:
curl_easy_setopt (curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
break;
case PROXY_TYPE_SOCKS4:
#if LIBCURL_VERSION_NUM < 0x070A00 /* 7.10.0 */
/* proxy socks4 not supported in Curl < 7.10 */
return;
#endif /* LIBCURL_VERSION_NUM < 0x070A00 */
curl_easy_setopt (curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
break;
case PROXY_TYPE_SOCKS5:
#if LIBCURL_VERSION_NUM < 0x070A00 /* 7.10.0 */
/* proxy socks5 not supported in Curl < 7.10 */
return;
#endif /* LIBCURL_VERSION_NUM < 0x070A00 */
#if LIBCURL_VERSION_NUM >= 0x071200 /* 7.18.0 */
curl_easy_setopt (curl, CURLOPT_PROXYTYPE,
CURLPROXY_SOCKS5_HOSTNAME);
#else
curl_easy_setopt (curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
#endif /* LIBCURL_VERSION_NUM >= 0x071200 */
break;
}
/* set proxy address */
curl_easy_setopt (curl, CURLOPT_PROXY,
CONFIG_STRING(proxy->options[PROXY_OPTION_ADDRESS]));
/* set proxy port */
curl_easy_setopt (curl, CURLOPT_PROXYPORT,
CONFIG_INTEGER(proxy->options[PROXY_OPTION_PORT]));
/* set username/password */
#if LIBCURL_VERSION_NUM >= 0x071301 /* 7.19.1 */
if (CONFIG_STRING(proxy->options[PROXY_OPTION_USERNAME])
&& CONFIG_STRING(proxy->options[PROXY_OPTION_USERNAME])[0])
{
curl_easy_setopt (curl, CURLOPT_PROXYUSERNAME,
CONFIG_STRING(proxy->options[PROXY_OPTION_USERNAME]));
}
if (CONFIG_STRING(proxy->options[PROXY_OPTION_PASSWORD])
&& CONFIG_STRING(proxy->options[PROXY_OPTION_PASSWORD])[0])
{
curl_easy_setopt (curl, CURLOPT_PROXYPASSWORD,
CONFIG_STRING(proxy->options[PROXY_OPTION_PASSWORD]));
}
#endif /* LIBCURL_VERSION_NUM >= 0x071301 */
}
void
secure_buffer_display ()
{
int line, count, count_encrypted;
if (!secure_buffer)
return;
gui_buffer_clear (secure_buffer);
/* set title buffer */
gui_buffer_set_title (secure_buffer,
_("WeeChat secured data (sec.conf) | "
"Keys: [alt-v] Toggle values"));
line = 0;
gui_chat_printf_y (secure_buffer, line++,
"Hash algo: %s Cipher: %s Salt: %s",
secure_hash_algo_string[CONFIG_INTEGER(secure_config_crypt_hash_algo)],
secure_cipher_string[CONFIG_INTEGER(secure_config_crypt_cipher)],
(CONFIG_BOOLEAN(secure_config_crypt_salt)) ? _("on") : _("off"));
/* display passphrase */
line++;
gui_chat_printf_y (secure_buffer, line++,
(secure_passphrase) ?
_("Passphrase is set") : _("Passphrase is not set"));
/* display secured data */
count = secure_hashtable_data->items_count;
count_encrypted = secure_hashtable_data_encrypted->items_count;
if (count > 0)
{
line++;
gui_chat_printf_y (secure_buffer, line++, _("Secured data:"));
line++;
hashtable_map (secure_hashtable_data,
&secure_buffer_display_data, &line);
}
/* display secured data not decrypted */
if (count_encrypted > 0)
{
line++;
gui_chat_printf_y (secure_buffer, line++,
_("Secured data STILL ENCRYPTED: (use /secure decrypt, "
"see /help secure)"));
line++;
hashtable_map (secure_hashtable_data_encrypted,
&secure_buffer_display_data, &line);
}
if ((count == 0) && (count_encrypted == 0))
{
line++;
gui_chat_printf_y (secure_buffer, line++, _("No secured data set"));
}
}
void
secure_data_write_map_cb (void *data,
struct t_hashtable *hashtable,
const void *key, const void *value)
{
struct t_config_file *config_file;
char *buffer, *buffer_base16;
int length_buffer, rc;
/* make C compiler happy */
(void) hashtable;
config_file = (struct t_config_file *)data;
buffer = NULL;
length_buffer = 0;
if (secure_passphrase)
{
/* encrypt password using passphrase */
rc = secure_encrypt_data (value, strlen (value) + 1,
secure_hash_algo[CONFIG_INTEGER(secure_config_crypt_hash_algo)],
secure_cipher[CONFIG_INTEGER(secure_config_crypt_cipher)],
secure_passphrase,
&buffer,
&length_buffer);
if (rc == 0)
{
if (buffer)
{
buffer_base16 = malloc ((length_buffer * 2) + 1);
if (buffer_base16)
{
string_encode_base16 (buffer, length_buffer, buffer_base16);
config_file_write_line (config_file, key,
"\"%s\"", buffer_base16);
free (buffer_base16);
}
free (buffer);
}
}
else
{
gui_chat_printf (NULL,
_("%sError encrypting data \"%s\" (%d)"),
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
key, rc);
}
}
else
{
/* store password as plain text */
config_file_write_line (config_file, key, "\"%s\"", value);
}
}
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;
}
void
gui_bar_window_create_win (struct t_gui_bar_window *bar_window)
{
if (CONFIG_BOOLEAN(bar_window->bar->options[GUI_BAR_OPTION_HIDDEN]))
return;
if (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar)
{
delwin (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar);
GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar = NULL;
}
if (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator)
{
delwin (GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator);
GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator = NULL;
}
if ((bar_window->x >= 0) && (bar_window->y >= 0))
{
GUI_BAR_WINDOW_OBJECTS(bar_window)->win_bar = newwin (bar_window->height,
bar_window->width,
bar_window->y,
bar_window->x);
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_BAR_WINDOW_OBJECTS(bar_window)->win_separator =
newwin (1, bar_window->width,
bar_window->y - 1, bar_window->x);
break;
case GUI_BAR_POSITION_TOP:
GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator =
newwin (1, bar_window->width,
bar_window->y + bar_window->height, bar_window->x);
break;
case GUI_BAR_POSITION_LEFT:
GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator =
newwin (bar_window->height, 1,
bar_window->y, bar_window->x + bar_window->width);
break;
case GUI_BAR_POSITION_RIGHT:
GUI_BAR_WINDOW_OBJECTS(bar_window)->win_separator =
newwin (bar_window->height, 1,
bar_window->y, bar_window->x - 1);
break;
case GUI_BAR_NUM_POSITIONS:
break;
}
}
}
}
int
gui_color_get_pair (int fg, int bg)
{
int index;
/* only one color when displaying terminal colors */
if (gui_color_use_term_colors)
return COLOR_WHITE;
/* if invalid color, use default fg/bg */
if (fg > gui_color_term_colors)
fg = -1;
if (bg > gui_color_term_colors)
bg = -1;
/* compute index for gui_color_pairs with foreground and background */
index = ((bg + 1) * (gui_color_term_colors + 2)) + (fg + 1);
/* pair not allocated for this fg/bg? */
if (gui_color_pairs[index] == 0)
{
if (gui_color_pairs_used >= gui_color_num_pairs)
{
/* oh no, no more pair available! */
if (!gui_color_warning_pairs_full
&& (CONFIG_INTEGER(config_look_color_pairs_auto_reset) < 0))
{
/* display warning if auto reset of pairs is disabled */
hook_timer (NULL, 1, 0, 1,
&gui_color_timer_warning_pairs_full, NULL);
gui_color_warning_pairs_full = 1;
}
return 1;
}
/* create a new pair if no pair exists for this fg/bg */
gui_color_pairs_used++;
gui_color_pairs[index] = gui_color_pairs_used;
init_pair (gui_color_pairs_used, fg, bg);
if ((gui_color_num_pairs > 1) && !gui_color_pairs_auto_reset_pending
&& (CONFIG_INTEGER(config_look_color_pairs_auto_reset) >= 0)
&& (gui_color_num_pairs - gui_color_pairs_used <= CONFIG_INTEGER(config_look_color_pairs_auto_reset)))
{
gui_color_pairs_auto_reset = 1;
}
gui_color_buffer_refresh_needed = 1;
}
return gui_color_pairs[index];
}
int
gui_bar_window_get_max_size_in_window (struct t_gui_bar_window *bar_window,
struct t_gui_window *window)
{
int max_size;
max_size = 1;
if (bar_window && window)
{
switch (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_POSITION]))
{
case GUI_BAR_POSITION_BOTTOM:
case GUI_BAR_POSITION_TOP:
max_size = (window->win_chat_height + bar_window->height) -
GUI_WINDOW_CHAT_MIN_HEIGHT;
break;
case GUI_BAR_POSITION_LEFT:
case GUI_BAR_POSITION_RIGHT:
max_size = (window->win_chat_width + bar_window->width) -
GUI_WINDOW_CHAT_MIN_HEIGHT;
break;
case GUI_BAR_NUM_POSITIONS:
break;
}
}
return max_size;
}
struct t_gui_bar_window *
gui_bar_window_find_pos (struct t_gui_bar *bar, struct t_gui_window *window)
{
struct t_gui_bar_window *ptr_bar_window;
for (ptr_bar_window = window->bar_windows; ptr_bar_window;
ptr_bar_window = ptr_bar_window->next_bar_window)
{
if (CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_PRIORITY]) >=
CONFIG_INTEGER(ptr_bar_window->bar->options[GUI_BAR_OPTION_PRIORITY]))
return ptr_bar_window;
}
/* position not found, best position is at the end */
return NULL;
}
void
gui_bar_window_calculate_pos_size (struct t_gui_bar_window *bar_window,
struct t_gui_window *window)
{
int x1, y1, x2, y2;
int add_bottom, add_top, add_left, add_right;
if (window)
{
x1 = window->win_x;
y1 = window->win_y;
x2 = x1 + window->win_width - 1;
y2 = y1 + window->win_height - 1;
add_bottom = gui_bar_window_get_size (bar_window->bar, window, GUI_BAR_POSITION_BOTTOM);
add_top = gui_bar_window_get_size (bar_window->bar, window, GUI_BAR_POSITION_TOP);
add_left = gui_bar_window_get_size (bar_window->bar, window, GUI_BAR_POSITION_LEFT);
add_right = gui_bar_window_get_size (bar_window->bar, window, GUI_BAR_POSITION_RIGHT);
}
else
{
x1 = 0;
y1 = 0;
x2 = gui_window_get_width () - 1;
y2 = gui_window_get_height () - 1;
add_bottom = gui_bar_root_get_size (bar_window->bar, GUI_BAR_POSITION_BOTTOM);
add_top = gui_bar_root_get_size (bar_window->bar, GUI_BAR_POSITION_TOP);
add_left = gui_bar_root_get_size (bar_window->bar, GUI_BAR_POSITION_LEFT);
add_right = gui_bar_root_get_size (bar_window->bar, GUI_BAR_POSITION_RIGHT);
}
switch (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_POSITION]))
{
case GUI_BAR_POSITION_BOTTOM:
bar_window->x = x1 + add_left;
bar_window->y = y2 - add_bottom - bar_window->current_size + 1;
bar_window->width = x2 - x1 + 1 - add_left - add_right;
bar_window->height = bar_window->current_size;
break;
case GUI_BAR_POSITION_TOP:
bar_window->x = x1 + add_left;
bar_window->y = y1 + add_top;
bar_window->width = x2 - x1 + 1 - add_left - add_right;
bar_window->height = bar_window->current_size;
break;
case GUI_BAR_POSITION_LEFT:
bar_window->x = x1 + add_left;
bar_window->y = y1 + add_top;
bar_window->width = bar_window->current_size;
bar_window->height = y2 - y1 + 1 - add_top - add_bottom;
break;
case GUI_BAR_POSITION_RIGHT:
bar_window->x = x2 - add_right - bar_window->current_size + 1;
bar_window->y = y1 + add_top;
bar_window->width = bar_window->current_size;
bar_window->height = y2 - y1 + 1 - add_top - add_bottom;
break;
case GUI_BAR_NUM_POSITIONS:
break;
}
}
void
gui_window_scroll_down (struct t_gui_window *window)
{
struct t_gui_line *ptr_line;
int line_pos;
if (!gui_ok)
return;
if (window->scroll->start_line)
{
gui_chat_calculate_line_diff (window, &window->scroll->start_line,
&window->scroll->start_line_pos,
CONFIG_INTEGER(config_look_scroll_amount));
/* check if we can display all */
ptr_line = window->scroll->start_line;
line_pos = window->scroll->start_line_pos;
gui_chat_calculate_line_diff (window, &ptr_line,
&line_pos,
window->win_chat_height - 1);
if (!ptr_line)
{
window->scroll->start_line = NULL;
window->scroll->start_line_pos = 0;
}
gui_chat_draw (window->buffer, 0);
}
}
int
network_pass_proxy (const char *proxy, int sock, const char *address, int port)
{
int rc;
struct t_proxy *ptr_proxy;
rc = 0;
ptr_proxy = proxy_search (proxy);
if (ptr_proxy)
{
switch (CONFIG_INTEGER(ptr_proxy->options[PROXY_OPTION_TYPE]))
{
case PROXY_TYPE_HTTP:
rc = network_pass_httpproxy (ptr_proxy, sock, address, port);
break;
case PROXY_TYPE_SOCKS4:
rc = network_pass_socks4proxy (ptr_proxy, sock, address, port);
break;
case PROXY_TYPE_SOCKS5:
rc = network_pass_socks5proxy (ptr_proxy, sock, address, port);
break;
}
}
return rc;
}
int
gui_bar_window_remove_unused_bars (struct t_gui_window *window)
{
int rc;
struct t_gui_bar_window *ptr_bar_win, *next_bar_win;
rc = 0;
ptr_bar_win = window->bar_windows;
while (ptr_bar_win)
{
next_bar_win = ptr_bar_win->next_bar_window;
if ((CONFIG_INTEGER(ptr_bar_win->bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_WINDOW)
&& (!gui_bar_check_conditions_for_window (ptr_bar_win->bar, window)))
{
gui_bar_window_free (ptr_bar_win, window);
rc = 1;
}
ptr_bar_win = next_bar_win;
}
return rc;
}
void
gui_window_scroll_up (struct t_gui_window *window)
{
if (!gui_ok)
return;
if (!window->scroll->first_line_displayed)
{
gui_chat_calculate_line_diff (window, &window->scroll->start_line,
&window->scroll->start_line_pos,
(window->scroll->start_line) ?
(-1) * CONFIG_INTEGER(config_look_scroll_amount) :
(-1) * ( (window->win_chat_height - 1) +
CONFIG_INTEGER(config_look_scroll_amount)));
gui_chat_draw (window->buffer, 0);
}
}
void
gui_history_global_add (const char *string)
{
struct t_gui_history *new_history, *ptr_history;
if (!string)
return;
if (!history_global
|| (history_global
&& (strcmp (history_global->text, string) != 0)))
{
new_history = malloc (sizeof (*new_history));
if (new_history)
{
new_history->text = strdup (string);
/*if (config_log_hide_nickserv_pwd)
irc_display_hide_password (new_history->text, 1);*/
if (history_global)
history_global->prev_history = new_history;
else
last_history_global = new_history;
new_history->next_history = history_global;
new_history->prev_history = NULL;
history_global = new_history;
num_history_global++;
/* remove one command if necessary */
if ((CONFIG_INTEGER(config_history_max_commands) > 0)
&& (num_history_global > CONFIG_INTEGER(config_history_max_commands)))
{
ptr_history = last_history_global->prev_history;
if (history_global_ptr == last_history_global)
history_global_ptr = ptr_history;
(last_history_global->prev_history)->next_history = NULL;
if (last_history_global->text)
free (last_history_global->text);
free (last_history_global);
last_history_global = ptr_history;
num_history_global--;
}
}
}
}
void
gui_history_buffer_add (struct t_gui_buffer *buffer, const char *string)
{
struct t_gui_history *new_history, *ptr_history;
if (!string)
return;
if (!buffer->history
|| (buffer->history
&& (strcmp (buffer->history->text, string) != 0)))
{
new_history = malloc (sizeof (*new_history));
if (new_history)
{
new_history->text = strdup (string);
/*if (config_log_hide_nickserv_pwd)
irc_display_hide_password (new_history->text, 1);*/
if (buffer->history)
buffer->history->prev_history = new_history;
else
buffer->last_history = new_history;
new_history->next_history = buffer->history;
new_history->prev_history = NULL;
buffer->history = new_history;
buffer->num_history++;
/* remove one command if necessary */
if ((CONFIG_INTEGER(config_history_max_commands) > 0)
&& (buffer->num_history > CONFIG_INTEGER(config_history_max_commands)))
{
ptr_history = buffer->last_history->prev_history;
if (buffer->ptr_history == buffer->last_history)
buffer->ptr_history = ptr_history;
((buffer->last_history)->prev_history)->next_history = NULL;
if (buffer->last_history->text)
free (buffer->last_history->text);
free (buffer->last_history);
buffer->last_history = ptr_history;
buffer->num_history++;
}
}
}
}
void
gui_history_global_add (const char *string)
{
struct t_gui_history *new_history, *ptr_history;
if (!string)
return;
if (!gui_history
|| (gui_history
&& (strcmp (gui_history->text, string) != 0)))
{
new_history = malloc (sizeof (*new_history));
if (new_history)
{
new_history->text = strdup (string);
if (gui_history)
gui_history->prev_history = new_history;
else
last_gui_history = new_history;
new_history->next_history = gui_history;
new_history->prev_history = NULL;
gui_history = new_history;
num_gui_history++;
/* remove one command if necessary */
if ((CONFIG_INTEGER(config_history_max_commands) > 0)
&& (num_gui_history > CONFIG_INTEGER(config_history_max_commands)))
{
ptr_history = last_gui_history->prev_history;
if (gui_history_ptr == last_gui_history)
gui_history_ptr = ptr_history;
(last_gui_history->prev_history)->next_history = NULL;
if (last_gui_history->text)
free (last_gui_history->text);
free (last_gui_history);
last_gui_history = ptr_history;
num_gui_history--;
}
}
}
}
int
gui_bar_window_get_size (struct t_gui_bar *bar, struct t_gui_window *window,
enum t_gui_bar_position position)
{
struct t_gui_bar_window *ptr_bar_window;
int total_size;
total_size = 0;
for (ptr_bar_window = window->bar_windows; ptr_bar_window;
ptr_bar_window = ptr_bar_window->next_bar_window)
{
/* stop before bar */
if (bar && (ptr_bar_window->bar == bar))
return total_size;
if (!CONFIG_BOOLEAN(ptr_bar_window->bar->options[GUI_BAR_OPTION_HIDDEN]))
{
if ((CONFIG_INTEGER(ptr_bar_window->bar->options[GUI_BAR_OPTION_TYPE]) != GUI_BAR_TYPE_ROOT)
&& (CONFIG_INTEGER(ptr_bar_window->bar->options[GUI_BAR_OPTION_POSITION]) == (int)position))
{
switch (position)
{
case GUI_BAR_POSITION_BOTTOM:
case GUI_BAR_POSITION_TOP:
total_size += ptr_bar_window->height;
break;
case GUI_BAR_POSITION_LEFT:
case GUI_BAR_POSITION_RIGHT:
total_size += ptr_bar_window->width;
break;
case GUI_BAR_NUM_POSITIONS:
break;
}
if (CONFIG_INTEGER(ptr_bar_window->bar->options[GUI_BAR_OPTION_SEPARATOR]))
total_size++;
}
}
}
return total_size;
}
void
gui_bar_window_set_current_size (struct t_gui_bar_window *bar_window,
struct t_gui_window *window, int size)
{
int new_size, max_size;
if (size == 0)
new_size = 1;
else
{
new_size = size;
if ((size != 0) && (CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_SIZE_MAX]) > 0)
&& (size > CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_SIZE_MAX])))
{
new_size = CONFIG_INTEGER(bar_window->bar->options[GUI_BAR_OPTION_SIZE_MAX]);
if (new_size < 1)
new_size = 1;
}
}
if (bar_window->current_size != new_size)
{
max_size = gui_bar_window_get_max_size (bar_window, window);
new_size = (max_size < new_size) ? max_size : new_size;
if (bar_window->current_size != new_size)
{
bar_window->current_size = new_size;
if (!CONFIG_BOOLEAN(bar_window->bar->options[GUI_BAR_OPTION_HIDDEN]))
{
gui_bar_window_calculate_pos_size (bar_window, window);
gui_bar_window_create_win (bar_window);
if (window)
window->refresh_needed = 1;
else
gui_window_ask_refresh (1);
}
}
}
}
void
gui_mouse_event_init ()
{
gui_mouse_event_pending = 1;
if (gui_mouse_event_timer)
unhook (gui_mouse_event_timer);
gui_mouse_event_timer = hook_timer (NULL,
CONFIG_INTEGER(config_look_mouse_timer_delay),
0, 1,
&gui_mouse_event_timer_cb, NULL);
}
void
proxy_print_log ()
{
struct t_proxy *ptr_proxy;
for (ptr_proxy = weechat_proxies; ptr_proxy;
ptr_proxy = ptr_proxy->next_proxy)
{
log_printf ("");
log_printf ("[proxy (addr:0x%lx)]", ptr_proxy);
log_printf (" name . . . . . . . . . : '%s'", ptr_proxy->name);
log_printf (" type . . . . . . . . . : %d (%s)",
CONFIG_INTEGER(ptr_proxy->options[PROXY_OPTION_TYPE]),
proxy_type_string[CONFIG_INTEGER(ptr_proxy->options[PROXY_OPTION_TYPE])]);
log_printf (" ipv6 . . . . . . . . . : %d", CONFIG_INTEGER(ptr_proxy->options[PROXY_OPTION_IPV6]));
log_printf (" address. . . . . . . . : '%s'", CONFIG_STRING(ptr_proxy->options[PROXY_OPTION_ADDRESS]));
log_printf (" port . . . . . . . . . : %d", CONFIG_INTEGER(ptr_proxy->options[PROXY_OPTION_PORT]));
log_printf (" username . . . . . . . : '%s'", CONFIG_STRING(ptr_proxy->options[PROXY_OPTION_USERNAME]));
log_printf (" password . . . . . . . : '%s'", CONFIG_STRING(ptr_proxy->options[PROXY_OPTION_PASSWORD]));
log_printf (" prev_proxy . . . . . . : 0x%lx", ptr_proxy->prev_proxy);
log_printf (" next_proxy . . . . . . : 0x%lx", ptr_proxy->next_proxy);
}
}
int
network_connect_to (const char *proxy, int sock,
unsigned long address, int port)
{
struct t_proxy *ptr_proxy;
struct sockaddr_in addr;
struct hostent *hostent;
char *ip4;
ptr_proxy = NULL;
if (proxy && proxy[0])
{
ptr_proxy = proxy_search (proxy);
if (!ptr_proxy)
return 0;
}
if (ptr_proxy)
{
memset (&addr, 0, sizeof (addr));
addr.sin_addr.s_addr = htonl (address);
ip4 = inet_ntoa(addr.sin_addr);
memset (&addr, 0, sizeof (addr));
addr.sin_port = htons (CONFIG_INTEGER(ptr_proxy->options[PROXY_OPTION_PORT]));
addr.sin_family = AF_INET;
hostent = gethostbyname (CONFIG_STRING(ptr_proxy->options[PROXY_OPTION_ADDRESS]));
if (!hostent)
return 0;
memcpy(&(addr.sin_addr), *(hostent->h_addr_list), sizeof(struct in_addr));
if (!network_connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
return 0;
if (!network_pass_proxy (proxy, sock, ip4, port))
return 0;
}
else
{
memset (&addr, 0, sizeof (addr));
addr.sin_port = htons (port);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl (address);
if (!network_connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
return 0;
}
return 1;
}
void
gui_hotlist_remove_buffer (struct t_gui_buffer *buffer,
int force_remove_buffer)
{
int hotlist_changed, hotlist_remove, buffer_to_remove;
struct t_gui_hotlist *ptr_hotlist, *next_hotlist;
if (!buffer || weechat_upgrading)
return;
hotlist_changed = 0;
hotlist_remove = CONFIG_INTEGER(config_look_hotlist_remove);
ptr_hotlist = gui_hotlist;
while (ptr_hotlist)
{
next_hotlist = ptr_hotlist->next_hotlist;
buffer_to_remove = (force_remove_buffer) ?
(ptr_hotlist->buffer == buffer) : 0;
switch (hotlist_remove)
{
case CONFIG_LOOK_HOTLIST_REMOVE_BUFFER:
buffer_to_remove |= (ptr_hotlist->buffer == buffer);
break;
case CONFIG_LOOK_HOTLIST_REMOVE_MERGED:
buffer_to_remove |=
((ptr_hotlist->buffer->number == buffer->number)
&& (!ptr_hotlist->buffer->zoomed
|| (ptr_hotlist->buffer->active == 2)));
break;
}
if (buffer_to_remove)
{
gui_hotlist_free (&gui_hotlist, &last_gui_hotlist, ptr_hotlist);
hotlist_changed = 1;
}
ptr_hotlist = next_hotlist;
}
if (hotlist_changed)
gui_hotlist_changed_signal ();
}
struct t_gui_lines *
gui_lines_alloc ()
{
struct t_gui_lines *new_lines;
new_lines = malloc (sizeof (*new_lines));
if (new_lines)
{
new_lines->first_line = NULL;
new_lines->last_line = NULL;
new_lines->last_read_line = NULL;
new_lines->lines_count = 0;
new_lines->first_line_not_read = 0;
new_lines->lines_hidden = 0;
new_lines->buffer_max_length = 0;
new_lines->buffer_max_length_refresh = 0;
new_lines->prefix_max_length = CONFIG_INTEGER(config_look_prefix_align_min);
new_lines->prefix_max_length_refresh = 0;
}
return new_lines;
}
int
gui_bar_window_add_missing_bars (struct t_gui_window *window)
{
int rc;
struct t_gui_bar *ptr_bar;
rc = 0;
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
if ((CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_WINDOW)
&& gui_bar_check_conditions_for_window (ptr_bar, window))
{
if (!gui_bar_window_search_bar (window, ptr_bar))
{
gui_bar_window_new (ptr_bar, window);
rc = 1;
}
}
}
return rc;
}
void
gui_line_compute_prefix_max_length (struct t_gui_lines *lines)
{
struct t_gui_line *ptr_line;
int prefix_length, prefix_is_nick;
lines->prefix_max_length = CONFIG_INTEGER(config_look_prefix_align_min);
for (ptr_line = lines->first_line; ptr_line;
ptr_line = ptr_line->next_line)
{
if (ptr_line->data->displayed)
{
gui_line_get_prefix_for_display (ptr_line, NULL, &prefix_length,
NULL, &prefix_is_nick);
if (prefix_is_nick)
prefix_length += config_length_nick_prefix_suffix;
if (prefix_length > lines->prefix_max_length)
lines->prefix_max_length = prefix_length;
}
}
lines->prefix_max_length_refresh = 0;
}
void
gui_main_init ()
{
struct t_gui_buffer *ptr_buffer;
struct t_gui_bar *ptr_bar;
struct t_gui_bar_window *ptr_bar_win;
GdkColor color_fg, color_bg;
gui_color_init ();
gui_ok = 1;
/* build prefixes according to config */
gui_chat_prefix_build ();
/* init clipboard buffer */
gui_input_clipboard = NULL;
/* create Gtk widgets */
gdk_color_parse ("white", &color_fg);
gdk_color_parse ("black", &color_bg);
gui_gtk_main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (gui_gtk_main_window), PACKAGE_STRING);
g_signal_connect (G_OBJECT (gui_gtk_main_window), "destroy", gtk_main_quit, NULL);
gui_gtk_vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (gui_gtk_vbox1);
gtk_container_add (GTK_CONTAINER (gui_gtk_main_window), gui_gtk_vbox1);
gui_gtk_entry_topic = gtk_entry_new ();
gtk_widget_show (gui_gtk_entry_topic);
gtk_box_pack_start (GTK_BOX (gui_gtk_vbox1), gui_gtk_entry_topic, FALSE, FALSE, 0);
gtk_widget_modify_text (gui_gtk_entry_topic, GTK_STATE_NORMAL, &color_fg);
gtk_widget_modify_base (gui_gtk_entry_topic, GTK_STATE_NORMAL, &color_bg);
gui_gtk_notebook1 = gtk_notebook_new ();
gtk_widget_show (gui_gtk_notebook1);
gtk_box_pack_start (GTK_BOX (gui_gtk_vbox1), gui_gtk_notebook1, TRUE, TRUE, 0);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (gui_gtk_notebook1), GTK_POS_BOTTOM);
gui_gtk_vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (gui_gtk_vbox2);
gtk_container_add (GTK_CONTAINER (gui_gtk_notebook1), gui_gtk_vbox2);
gui_gtk_hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (gui_gtk_hbox1);
gtk_box_pack_start (GTK_BOX (gui_gtk_vbox2), gui_gtk_hbox1, TRUE, TRUE, 0);
gui_gtk_hpaned1 = gtk_hpaned_new ();
gtk_widget_show (gui_gtk_hpaned1);
gtk_box_pack_start (GTK_BOX (gui_gtk_hbox1), gui_gtk_hpaned1, TRUE, TRUE, 0);
gtk_paned_set_position (GTK_PANED (gui_gtk_hpaned1), 0);
gui_gtk_scrolledwindow_chat = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (gui_gtk_scrolledwindow_chat);
gtk_paned_pack1 (GTK_PANED (gui_gtk_hpaned1), gui_gtk_scrolledwindow_chat,
FALSE, TRUE);
//gtk_box_pack_start (GTK_PANED (hpaned1), scrolledwindow_chat, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (gui_gtk_scrolledwindow_chat),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_widget_modify_text (gui_gtk_scrolledwindow_chat, GTK_STATE_NORMAL, &color_fg);
gtk_widget_modify_base (gui_gtk_scrolledwindow_chat, GTK_STATE_NORMAL, &color_bg);
gui_gtk_scrolledwindow_nick = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (gui_gtk_scrolledwindow_nick);
gtk_paned_pack2 (GTK_PANED (gui_gtk_hpaned1), gui_gtk_scrolledwindow_nick,
FALSE, TRUE);
//gtk_box_pack_start (GTK_PANED (hpaned1), scrolledwindow_nick, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (gui_gtk_scrolledwindow_nick),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_widget_modify_text (gui_gtk_scrolledwindow_nick, GTK_STATE_NORMAL, &color_fg);
gtk_widget_modify_base (gui_gtk_scrolledwindow_nick, GTK_STATE_NORMAL, &color_bg);
gui_gtk_entry_input = gtk_entry_new ();
gtk_widget_show (gui_gtk_entry_input);
gtk_box_pack_start (GTK_BOX (gui_gtk_vbox2), gui_gtk_entry_input, FALSE,
FALSE, 0);
gtk_widget_modify_text (gui_gtk_entry_input, GTK_STATE_NORMAL, &color_fg);
gtk_widget_modify_base (gui_gtk_entry_input, GTK_STATE_NORMAL, &color_bg);
gui_gtk_label1 = gtk_label_new (_("server"));
gtk_widget_show (gui_gtk_label1);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (gui_gtk_notebook1),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (gui_gtk_notebook1), 0),
gui_gtk_label1);
gtk_label_set_justify (GTK_LABEL (gui_gtk_label1), GTK_JUSTIFY_LEFT);
gtk_widget_show_all (gui_gtk_main_window);
gui_init_ok = 0;
/* create core buffer */
ptr_buffer = gui_buffer_new (NULL, "weechat", NULL, NULL, NULL, NULL);
if (ptr_buffer)
{
gui_init_ok = 1;
/* set title for core buffer */
gui_buffer_set_title (ptr_buffer,
"WeeChat " WEECHAT_COPYRIGHT_DATE
" - " WEECHAT_WEBSITE);
/* create main window (using full space) */
if (gui_window_new (NULL, ptr_buffer, 0, 0, 0, 0, 100, 100))
{
gui_current_window = gui_windows;
if (CONFIG_BOOLEAN(config_look_set_title))
gui_window_set_title (PACKAGE_NAME " " PACKAGE_VERSION);
}
/* create bar windows for root bars (they were read from config,
but no window was created (GUI was not initialized) */
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
if ((CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
&& (!ptr_bar->bar_window))
{
gui_bar_window_new (ptr_bar, NULL);
}
}
for (ptr_bar_win = gui_windows->bar_windows;
ptr_bar_win; ptr_bar_win = ptr_bar_win->next_bar_window)
{
gui_bar_window_calculate_pos_size (ptr_bar_win, gui_windows);
gui_bar_window_create_win (ptr_bar_win);
}
}
}
struct t_gui_hotlist *
gui_hotlist_find_pos (struct t_gui_hotlist *hotlist,
struct t_gui_hotlist *new_hotlist)
{
struct t_gui_hotlist *ptr_hotlist;
switch (CONFIG_INTEGER(config_look_hotlist_sort))
{
case CONFIG_LOOK_HOTLIST_SORT_GROUP_TIME_ASC:
for (ptr_hotlist = hotlist; ptr_hotlist;
ptr_hotlist = ptr_hotlist->next_hotlist)
{
if ((new_hotlist->priority > ptr_hotlist->priority)
|| ((new_hotlist->priority == ptr_hotlist->priority)
&& (util_timeval_diff (&(new_hotlist->creation_time),
&(ptr_hotlist->creation_time)) > 0)))
return ptr_hotlist;
}
break;
case CONFIG_LOOK_HOTLIST_SORT_GROUP_TIME_DESC:
for (ptr_hotlist = hotlist; ptr_hotlist;
ptr_hotlist = ptr_hotlist->next_hotlist)
{
if ((new_hotlist->priority > ptr_hotlist->priority)
|| ((new_hotlist->priority == ptr_hotlist->priority)
&& (util_timeval_diff (&(new_hotlist->creation_time),
&(ptr_hotlist->creation_time)) < 0)))
return ptr_hotlist;
}
break;
case CONFIG_LOOK_HOTLIST_SORT_GROUP_NUMBER_ASC:
for (ptr_hotlist = hotlist; ptr_hotlist;
ptr_hotlist = ptr_hotlist->next_hotlist)
{
if ((new_hotlist->priority > ptr_hotlist->priority)
|| ((new_hotlist->priority == ptr_hotlist->priority)
&& (new_hotlist->buffer->number < ptr_hotlist->buffer->number)))
return ptr_hotlist;
}
break;
case CONFIG_LOOK_HOTLIST_SORT_GROUP_NUMBER_DESC:
for (ptr_hotlist = hotlist; ptr_hotlist;
ptr_hotlist = ptr_hotlist->next_hotlist)
{
if ((new_hotlist->priority > ptr_hotlist->priority)
|| ((new_hotlist->priority == ptr_hotlist->priority)
&& (new_hotlist->buffer->number > ptr_hotlist->buffer->number)))
return ptr_hotlist;
}
break;
case CONFIG_LOOK_HOTLIST_SORT_NUMBER_ASC:
for (ptr_hotlist = hotlist; ptr_hotlist;
ptr_hotlist = ptr_hotlist->next_hotlist)
{
if (new_hotlist->buffer->number < ptr_hotlist->buffer->number)
return ptr_hotlist;
}
break;
case CONFIG_LOOK_HOTLIST_SORT_NUMBER_DESC:
for (ptr_hotlist = hotlist; ptr_hotlist;
ptr_hotlist = ptr_hotlist->next_hotlist)
{
if (new_hotlist->buffer->number > ptr_hotlist->buffer->number)
return ptr_hotlist;
}
break;
}
return NULL;
}
char *
eval_replace_vars_cb (void *data, const char *text)
{
struct t_hashtable *pointers, *extra_vars;
struct t_eval_regex *eval_regex;
struct t_config_option *ptr_option;
struct t_gui_buffer *ptr_buffer;
char str_value[512], *value, *pos, *pos1, *pos2, *hdata_name, *list_name;
char *tmp, *info_name, *hide_char, *hidden_string, *error;
const char *prefix, *suffix, *ptr_value, *ptr_arguments, *ptr_string;
struct t_hdata *hdata;
void *pointer;
int i, length_hide_char, length, index, rc, extra_vars_eval;
long number;
long unsigned int ptr;
time_t date;
struct tm *date_tmp;
pointers = (struct t_hashtable *)(((void **)data)[0]);
extra_vars = (struct t_hashtable *)(((void **)data)[1]);
extra_vars_eval = *(int *)(((void **)data)[2]);
prefix = (const char *)(((void **)data)[3]);
suffix = (const char *)(((void **)data)[4]);
eval_regex = (struct t_eval_regex *)(((void **)data)[5]);
/* 1. variable in hashtable "extra_vars" */
if (extra_vars)
{
ptr_value = hashtable_get (extra_vars, text);
if (ptr_value)
{
if (extra_vars_eval)
{
return eval_replace_vars (ptr_value, pointers,
extra_vars, extra_vars_eval,
prefix, suffix,
eval_regex);
}
else
{
return strdup (ptr_value);
}
}
}
/*
* 2. force evaluation of string (recursive call)
* --> use with caution: the text must be safe!
*/
if (strncmp (text, "eval:", 5) == 0)
{
return eval_replace_vars (text + 5, pointers,
extra_vars, extra_vars_eval,
prefix, suffix,
eval_regex);
}
/* 3. convert escaped chars */
if (strncmp (text, "esc:", 4) == 0)
return string_convert_escaped_chars (text + 4);
if ((text[0] == '\\') && text[1] && (text[1] != '\\'))
return string_convert_escaped_chars (text);
/* 4. hide chars: replace all chars by a given char/string */
if (strncmp (text, "hide:", 5) == 0)
{
hidden_string = NULL;
ptr_string = strchr (text + 5,
(text[5] == ',') ? ';' : ',');
if (!ptr_string)
return strdup ("");
hide_char = string_strndup (text + 5, ptr_string - text - 5);
if (hide_char)
{
length_hide_char = strlen (hide_char);
length = utf8_strlen (ptr_string + 1);
hidden_string = malloc ((length * length_hide_char) + 1);
if (hidden_string)
{
index = 0;
for (i = 0; i < length; i++)
{
memcpy (hidden_string + index, hide_char,
length_hide_char);
index += length_hide_char;
}
hidden_string[length * length_hide_char] = '\0';
}
free (hide_char);
}
return (hidden_string) ? hidden_string : strdup ("");
}
/* 5. regex group captured */
if (strncmp (text, "re:", 3) == 0)
{
if (eval_regex && eval_regex->result)
{
if (strcmp (text + 3, "+") == 0)
number = eval_regex->last_match;
else
{
number = strtol (text + 3, &error, 10);
if (!error || error[0])
number = -1;
}
if ((number >= 0) && (number <= eval_regex->last_match))
{
return string_strndup (
eval_regex->result + eval_regex->match[number].rm_so,
eval_regex->match[number].rm_eo - eval_regex->match[number].rm_so);
}
}
return strdup ("");
}
/* 6. color code */
if (strncmp (text, "color:", 6) == 0)
{
ptr_value = gui_color_search_config (text + 6);
if (ptr_value)
return strdup (ptr_value);
ptr_value = gui_color_get_custom (text + 6);
return strdup ((ptr_value) ? ptr_value : "");
}
/* 7. info */
if (strncmp (text, "info:", 5) == 0)
{
ptr_value = NULL;
ptr_arguments = strchr (text + 5, ',');
if (ptr_arguments)
{
info_name = string_strndup (text + 5, ptr_arguments - text - 5);
ptr_arguments++;
}
else
info_name = strdup (text + 5);
if (info_name)
{
ptr_value = hook_info_get (NULL, info_name, ptr_arguments);
free (info_name);
}
return strdup ((ptr_value) ? ptr_value : "");
}
/* 8. current date/time */
if ((strncmp (text, "date", 4) == 0) && (!text[4] || (text[4] == ':')))
{
date = time (NULL);
date_tmp = localtime (&date);
if (!date_tmp)
return strdup ("");
rc = (int) strftime (str_value, sizeof (str_value),
(text[4] == ':') ? text + 5 : "%F %T",
date_tmp);
return strdup ((rc > 0) ? str_value : "");
}
/* 9. environment variable */
if (strncmp (text, "env:", 4) == 0)
{
ptr_value = getenv (text + 4);
if (ptr_value)
return strdup (ptr_value);
}
/* 10. option: if found, return this value */
if (strncmp (text, "sec.data.", 9) == 0)
{
ptr_value = hashtable_get (secure_hashtable_data, text + 9);
return strdup ((ptr_value) ? ptr_value : "");
}
else
{
config_file_search_with_string (text, NULL, NULL, &ptr_option, NULL);
if (ptr_option)
{
if (!ptr_option->value)
return strdup ("");
switch (ptr_option->type)
{
case CONFIG_OPTION_TYPE_BOOLEAN:
return strdup (CONFIG_BOOLEAN(ptr_option) ? EVAL_STR_TRUE : EVAL_STR_FALSE);
case CONFIG_OPTION_TYPE_INTEGER:
if (ptr_option->string_values)
return strdup (ptr_option->string_values[CONFIG_INTEGER(ptr_option)]);
snprintf (str_value, sizeof (str_value),
"%d", CONFIG_INTEGER(ptr_option));
return strdup (str_value);
case CONFIG_OPTION_TYPE_STRING:
return strdup (CONFIG_STRING(ptr_option));
case CONFIG_OPTION_TYPE_COLOR:
return strdup (gui_color_get_name (CONFIG_COLOR(ptr_option)));
case CONFIG_NUM_OPTION_TYPES:
return strdup ("");
}
}
}
/* 11. local variable in buffer */
ptr_buffer = hashtable_get (pointers, "buffer");
if (ptr_buffer)
{
ptr_value = hashtable_get (ptr_buffer->local_variables, text);
if (ptr_value)
return strdup (ptr_value);
}
/* 12. hdata */
value = NULL;
hdata_name = NULL;
list_name = NULL;
pointer = NULL;
pos = strchr (text, '.');
if (pos > text)
hdata_name = string_strndup (text, pos - text);
else
hdata_name = strdup (text);
if (!hdata_name)
goto end;
pos1 = strchr (hdata_name, '[');
if (pos1 > hdata_name)
{
pos2 = strchr (pos1 + 1, ']');
if (pos2 > pos1 + 1)
{
list_name = string_strndup (pos1 + 1, pos2 - pos1 - 1);
}
tmp = string_strndup (hdata_name, pos1 - hdata_name);
if (tmp)
{
free (hdata_name);
hdata_name = tmp;
}
}
hdata = hook_hdata_get (NULL, hdata_name);
if (!hdata)
goto end;
if (list_name)
{
if (strncmp (list_name, "0x", 2) == 0)
{
rc = sscanf (list_name, "%lx", &ptr);
if ((rc != EOF) && (rc != 0))
{
pointer = (void *)ptr;
if (!hdata_check_pointer (hdata, NULL, pointer))
goto end;
}
else
goto end;
}
else
pointer = hdata_get_list (hdata, list_name);
}
if (!pointer)
{
pointer = hashtable_get (pointers, hdata_name);
if (!pointer)
goto end;
}
value = eval_hdata_get_value (hdata, pointer, (pos) ? pos + 1 : NULL);
end:
if (hdata_name)
free (hdata_name);
if (list_name)
free (list_name);
return (value) ? value : strdup ("");
}
void
gui_main_init ()
{
struct t_gui_buffer *ptr_buffer;
struct t_gui_bar *ptr_bar;
struct t_gui_bar_window *ptr_bar_win;
char title[256];
initscr ();
if (CONFIG_BOOLEAN(config_look_eat_newline_glitch))
gui_term_set_eat_newline_glitch (0);
curs_set (1);
noecho ();
nodelay (stdscr, TRUE);
raw ();
gui_color_init ();
/* build prefixes according to configuration */
gui_chat_prefix_build ();
refresh ();
gui_term_cols = COLS;
gui_term_lines = LINES;
gui_window_read_terminal_size ();
/* init clipboard buffer */
gui_input_clipboard = NULL;
/* get time length */
gui_chat_time_length = gui_chat_get_time_length ();
/* init bar items */
gui_bar_item_init ();
gui_init_ok = 0;
/* create core buffer */
ptr_buffer = gui_buffer_new (NULL, GUI_BUFFER_MAIN,
NULL, NULL, NULL, NULL);
if (ptr_buffer)
{
gui_init_ok = 1;
ptr_buffer->num_displayed = 1;
/* set short name */
if (!ptr_buffer->short_name)
ptr_buffer->short_name = strdup (GUI_BUFFER_MAIN);
/* set title for core buffer */
snprintf (title, sizeof (title), "WeeChat %s %s - %s",
version_get_version (),
WEECHAT_COPYRIGHT_DATE,
WEECHAT_WEBSITE);
gui_buffer_set_title (ptr_buffer, title);
/* create main window (using full space) */
if (gui_window_new (NULL, ptr_buffer, 0, 0,
gui_term_cols, gui_term_lines, 100, 100))
{
gui_current_window = gui_windows;
if (CONFIG_STRING(config_look_window_title)
&& CONFIG_STRING(config_look_window_title)[0])
{
gui_window_set_title (CONFIG_STRING(config_look_window_title));
}
}
/*
* create bar windows for root bars (they were read from config,
* but no window was created, GUI was not initialized)
*/
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
if ((CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
&& (!ptr_bar->bar_window))
{
gui_bar_window_new (ptr_bar, NULL);
}
}
for (ptr_bar_win = gui_windows->bar_windows;
ptr_bar_win; ptr_bar_win = ptr_bar_win->next_bar_window)
{
gui_bar_window_calculate_pos_size (ptr_bar_win, gui_windows);
gui_bar_window_create_win (ptr_bar_win);
}
}
if (CONFIG_BOOLEAN(config_look_mouse))
gui_mouse_enable ();
else
gui_mouse_disable ();
gui_window_set_bracketed_paste_mode (CONFIG_BOOLEAN(config_look_paste_bracketed));
}