pegasus/weechat
1
0
Fork 0
mirror of https://github.com/weechat/weechat.git synced 2026-06-29 06:16:40 +02:00
Code Activity
Files
af83fb55e10b3648656f540a5cb3ec826ea7440c
weechat/src/gui/gui-bar.c
T
Sébastien Helleu cf6aca1619 core: add pointer in some callbacks (closes #406) 
This pointer is the first argument received by callbacks, and the
existing argument "data" is now automatically freed by WeeChat when the
object containing the callback is removed.

With this new pointer, the linked list of callbacks in scripts has been
removed. This will improve speed of scripts (using a lot of hooks),
reduce memory used by scripts and reduce time to unload scripts.

Following functions are affected in the C API:

* exec_on_files
* config_new
* config_new_section
* config_new_option
* hook_command
* hook_command_run
* hook_timer
* hook_fd
* hook_process
* hook_process_hashtable
* hook_connect
* hook_print
* hook_signal
* hook_hsignal
* hook_config
* hook_completion
* hook_modifier
* hook_info
* hook_info_hashtable
* hook_infolist
* hook_hdata
* hook_focus
* unhook_all_plugin
* buffer_new
* bar_item_new
* upgrade_new
* upgrade_read
2016-03-21 18:11:21 +01:00

2492 lines
78 KiB
C
Raw Blame History

/*
* gui-bar.c - bar functions (used by all GUI)
*
* Copyright (C) 2003-2016 Sébastien Helleu <flashcode@flashtux.org>
*
* This file is part of WeeChat, the extensible chat client.
*
* WeeChat is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* WeeChat is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with WeeChat. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <limits.h>
#include "../core/weechat.h"
#include "../core/wee-config.h"
#include "../core/wee-eval.h"
#include "../core/wee-hashtable.h"
#include "../core/wee-hdata.h"
#include "../core/wee-hook.h"
#include "../core/wee-infolist.h"
#include "../core/wee-log.h"
#include "../core/wee-string.h"
#include "../plugins/plugin.h"
#include "gui-bar.h"
#include "gui-bar-item.h"
#include "gui-bar-window.h"
#include "gui-buffer.h"
#include "gui-chat.h"
#include "gui-color.h"
#include "gui-window.h"
char *gui_bar_option_string[GUI_BAR_NUM_OPTIONS] =
{ "hidden", "priority", "type", "conditions", "position", "filling_top_bottom",
"filling_left_right", "size", "size_max", "color_fg", "color_delim",
"color_bg", "separator", "items" };
char *gui_bar_option_default[GUI_BAR_NUM_OPTIONS] =
{ "0", "0", "0", "", "top", "horizontal",
"vertical", "0", "0", "default", "default",
"default", "off", "" };
char *gui_bar_type_string[GUI_BAR_NUM_TYPES] =
{ "root", "window" };
char *gui_bar_position_string[GUI_BAR_NUM_POSITIONS] =
{ "bottom", "top", "left", "right" };
char *gui_bar_filling_string[GUI_BAR_NUM_FILLING] =
{ "horizontal", "vertical", "columns_horizontal", "columns_vertical" };
struct t_gui_bar *gui_bars = NULL; /* first bar */
struct t_gui_bar *last_gui_bar = NULL; /* last bar */
struct t_gui_bar *gui_temp_bars = NULL; /* bars used when reading config */
struct t_gui_bar *last_gui_temp_bar = NULL;
void gui_bar_free_bar_windows (struct t_gui_bar *bar);
/*
* Checks if a bar pointer is valid.
*
* Returns:
* 1: bar exists
* 0: bar does not exist
*/
int
gui_bar_valid (struct t_gui_bar *bar)
{
struct t_gui_bar *ptr_bar;
if (!bar)
return 0;
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
if (ptr_bar == bar)
return 1;
}
/* bar not found */
return 0;
}
/*
* Searches for a bar option name.
*
* Returns index of option in enum t_gui_bar_option, -1 if not found.
*/
int
gui_bar_search_option (const char *option_name)
{
int i;
if (!option_name)
return -1;
for (i = 0; i < GUI_BAR_NUM_OPTIONS; i++)
{
if (string_strcasecmp (gui_bar_option_string[i], option_name) == 0)
return i;
}
/* bar option not found */
return -1;
}
/*
* Searches for a bar type.
*
* Returns index of type in enum t_gui_bar_type, -1 if not found.
*/
int
gui_bar_search_type (const char *type)
{
int i;
if (!type)
return -1;
for (i = 0; i < GUI_BAR_NUM_TYPES; i++)
{
if (string_strcasecmp (gui_bar_type_string[i], type) == 0)
return i;
}
/* type not found */
return -1;
}
/*
* Searches for a bar position.
*
* Returns index of position in enum t_gui_bar_position, -1 if not found.
*/
int
gui_bar_search_position (const char *position)
{
int i;
if (!position)
return -1;
for (i = 0; i < GUI_BAR_NUM_POSITIONS; i++)
{
if (string_strcasecmp (gui_bar_position_string[i], position) == 0)
return i;
}
/* position not found */
return -1;
}
/*
* Returns minimum width of a bar window displayed for a bar.
*
* For example, if a bar is displayed in 3 windows, this function returns min
* width of these 3 bar windows.
*/
int
gui_bar_get_min_width (struct t_gui_bar *bar)
{
struct t_gui_window *ptr_win;
struct t_gui_bar_window *ptr_bar_win;
int min_width;
if (CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
return bar->bar_window->width;
min_width = INT_MAX;
for (ptr_win = gui_windows; ptr_win; ptr_win = ptr_win->next_window)
{
for (ptr_bar_win = ptr_win->bar_windows; ptr_bar_win;
ptr_bar_win = ptr_bar_win->next_bar_window)
{
if (ptr_bar_win->bar == bar)
{
if (ptr_bar_win->width < min_width)
min_width = ptr_bar_win->width;
}
}
}
if (min_width == INT_MAX)
return 0;
return min_width;
}
/*
* Returns minimum height of a bar window displayed for a bar.
*
* For example, if a bar is displayed in 3 windows, this function returns min
* width of these 3 bar windows.
*/
int
gui_bar_get_min_height (struct t_gui_bar *bar)
{
struct t_gui_window *ptr_win;
struct t_gui_bar_window *ptr_bar_win;
int min_height;
if (CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
return bar->bar_window->height;
min_height = INT_MAX;
for (ptr_win = gui_windows; ptr_win; ptr_win = ptr_win->next_window)
{
for (ptr_bar_win = ptr_win->bar_windows; ptr_bar_win;
ptr_bar_win = ptr_bar_win->next_bar_window)
{
if (ptr_bar_win->bar == bar)
{
if (ptr_bar_win->height < min_height)
min_height = ptr_bar_win->height;
}
}
}
if (min_height == INT_MAX)
return 0;
return min_height;
}
/*
* Checks if "add_size" is OK for bar.
*
* Returns:
* 1: new size is OK
* 0: new size is too big
*/
int
gui_bar_check_size_add (struct t_gui_bar *bar, int add_size)
{
struct t_gui_window *ptr_window;
int sub_width, sub_height;
sub_width = 0;
sub_height = 0;
switch (CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_POSITION]))
{
case GUI_BAR_POSITION_BOTTOM:
case GUI_BAR_POSITION_TOP:
sub_height = add_size;
break;
case GUI_BAR_POSITION_LEFT:
case GUI_BAR_POSITION_RIGHT:
sub_width = add_size;
break;
case GUI_BAR_NUM_POSITIONS:
break;
}
for (ptr_window = gui_windows; ptr_window;
ptr_window = ptr_window->next_window)
{
if ((CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
|| (gui_bar_window_search_bar (ptr_window, bar)))
{
if ((ptr_window->win_chat_width - sub_width < 1)
|| (ptr_window->win_chat_height - sub_height < 1))
return 0;
}
}
/* new size OK */
return 1;
}
/*
* Returns filling option for bar, according to filling for current bar
* position.
*/
enum t_gui_bar_filling
gui_bar_get_filling (struct t_gui_bar *bar)
{
if ((CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_POSITION]) == GUI_BAR_POSITION_BOTTOM)
|| (CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_POSITION]) == GUI_BAR_POSITION_TOP))
return CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_FILLING_TOP_BOTTOM]);
return CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_FILLING_LEFT_RIGHT]);
}
/*
* Searches for position of a bar in list (to keep list sorted by priority).
*/
struct t_gui_bar *
gui_bar_find_pos (struct t_gui_bar *bar)
{
struct t_gui_bar *ptr_bar;
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
if (CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_PRIORITY]) >= CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_PRIORITY]))
return ptr_bar;
}
/* bar not found, add to end of list */
return NULL;
}
/*
* Inserts a bar to the list (at good position, according to priority).
*/
void
gui_bar_insert (struct t_gui_bar *bar)
{
struct t_gui_bar *pos_bar;
if (gui_bars)
{
pos_bar = gui_bar_find_pos (bar);
if (pos_bar)
{
/* insert bar into the list (before position found) */
bar->prev_bar = pos_bar->prev_bar;
bar->next_bar = pos_bar;
if (pos_bar->prev_bar)
(pos_bar->prev_bar)->next_bar = bar;
else
gui_bars = bar;
pos_bar->prev_bar = bar;
}
else
{
/* add bar to the end */
bar->prev_bar = last_gui_bar;
bar->next_bar = NULL;
last_gui_bar->next_bar = bar;
last_gui_bar = bar;
}
}
else
{
bar->prev_bar = NULL;
bar->next_bar = NULL;
gui_bars = bar;
last_gui_bar = bar;
}
}
/*
* Checks if bar must be displayed in window according to conditions.
*
* If window is NULL (case of root bars), the current window is used.
*
* Returns:
* 1: bar must be displayed
* 0: bar must not be displayed
*/
int
gui_bar_check_conditions (struct t_gui_bar *bar,
struct t_gui_window *window)
{
int rc;
char str_modifier[256], str_window[128], *str_displayed, *result;
const char *conditions;
struct t_hashtable *pointers, *extra_vars, *options;
if (!window)
window = gui_current_window;
/* check bar condition(s) */
conditions = CONFIG_STRING(bar->options[GUI_BAR_OPTION_CONDITIONS]);
if (string_strcasecmp (conditions, "active") == 0)
{
if (gui_current_window && (gui_current_window != window))
return 0;
}
else if (string_strcasecmp (conditions, "inactive") == 0)
{
if (!gui_current_window || (gui_current_window == window))
return 0;
}
else if (string_strcasecmp (conditions, "nicklist") == 0)
{
if (window && window->buffer && !window->buffer->nicklist)
return 0;
}
else if (conditions[0])
{
pointers = hashtable_new (32,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_POINTER,
NULL, NULL);
if (pointers)
{
hashtable_set (pointers, "window", window);
if (window)
hashtable_set (pointers, "buffer", window->buffer);
}
extra_vars = hashtable_new (32,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_POINTER,
NULL, NULL);
if (extra_vars)
{
hashtable_set (extra_vars, "active",
(gui_current_window && (gui_current_window == window)) ? "1" : "0");
hashtable_set (extra_vars, "inactive",
(gui_current_window && (gui_current_window != window)) ? "1" : "0");
hashtable_set (extra_vars, "nicklist",
(window && window->buffer && window->buffer->nicklist) ? "1" : "0");
}
options = hashtable_new (32,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_POINTER,
NULL, NULL);
if (options)
hashtable_set (options, "type", "condition");
result = eval_expression (conditions, pointers, extra_vars, options);
rc = eval_is_true (result);
if (result)
free (result);
if (pointers)
hashtable_free (pointers);
if (extra_vars)
hashtable_free (extra_vars);
if (options)
hashtable_free (options);
if (!rc)
return 0;
}
/*
* call a modifier that will tell us if bar is displayed or not,
* for example it can be used to display nicklist on some buffers
* only, using a script that implements this modifier and return "1"
* to display bar, "0" to hide it
*/
snprintf (str_modifier, sizeof (str_modifier),
"bar_condition_%s", bar->name);
snprintf (str_window, sizeof (str_window),
"0x%lx", (long unsigned int)(window));
str_displayed = hook_modifier_exec (NULL,
str_modifier,
str_window,
"");
if (str_displayed && strcmp (str_displayed, "0") == 0)
rc = 0;
else
rc = 1;
if (str_displayed)
free (str_displayed);
return rc;
}
/*
* Gets total bar size ("root" type) for a position.
*/
int
gui_bar_root_get_size (struct t_gui_bar *bar, enum t_gui_bar_position position)
{
struct t_gui_bar *ptr_bar;
int total_size;
total_size = 0;
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
if (bar && (ptr_bar == bar))
return total_size;
if (!CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN])
&& ptr_bar->bar_window)
{
if ((CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
&& (CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_POSITION]) == (int)position))
{
total_size += gui_bar_window_get_current_size (ptr_bar->bar_window);
if (CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SEPARATOR]))
total_size++;
}
}
}
return total_size;
}
/*
* Searches for a bar by name.
*
* Returns pointer to bar found, NULL if not found.
*/
struct t_gui_bar *
gui_bar_search (const char *name)
{
struct t_gui_bar *ptr_bar;
if (!name || !name[0])
return NULL;
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
if (string_strcasecmp (ptr_bar->name, name) == 0)
return ptr_bar;
}
/* bar not found */
return NULL;
}
/*
* Searches for a bar with name of option (like "status.type").
*
* Returns pointer to bar found, NULL if not found.
*/
struct t_gui_bar *
gui_bar_search_with_option_name (const char *option_name)
{
char *bar_name, *pos_option;
struct t_gui_bar *ptr_bar;
ptr_bar = NULL;
pos_option = strchr (option_name, '.');
if (pos_option)
{
bar_name = string_strndup (option_name, pos_option - option_name);
if (bar_name)
{
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
if (string_strcasecmp (ptr_bar->name, bar_name) == 0)
break;
}
free (bar_name);
}
}
return ptr_bar;
}
/*
* Rebuilds content of bar windows for a bar.
*/
void
gui_bar_content_build_bar_windows (struct t_gui_bar *bar)
{
struct t_gui_window *ptr_window;
struct t_gui_bar_window *ptr_bar_window;
if (!bar)
return;
if (bar->bar_window)
{
gui_bar_window_content_build (bar->bar_window, NULL);
}
else
{
for (ptr_window = gui_windows; ptr_window;
ptr_window = ptr_window->next_window)
{
for (ptr_bar_window = ptr_window->bar_windows; ptr_bar_window;
ptr_bar_window = ptr_bar_window->next_bar_window)
{
if (ptr_bar_window->bar == bar)
gui_bar_window_content_build (ptr_bar_window, ptr_window);
}
}
}
}
/*
* Asks refresh for bar.
*/
void
gui_bar_ask_refresh (struct t_gui_bar *bar)
{
bar->bar_refresh_needed = 1;
}
/*
* Asks for bar refresh on screen (for all windows where bar is).
*/
void
gui_bar_refresh (struct t_gui_bar *bar)
{
struct t_gui_window *ptr_win;
if (CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
gui_window_ask_refresh (1);
else
{
for (ptr_win = gui_windows; ptr_win; ptr_win = ptr_win->next_window)
{
if (gui_bar_window_search_bar (ptr_win, bar))
ptr_win->refresh_needed = 1;
}
}
}
/*
* Draws a bar.
*/
void
gui_bar_draw (struct t_gui_bar *bar)
{
struct t_gui_window *ptr_win;
struct t_gui_bar_window *ptr_bar_win;
if (!CONFIG_BOOLEAN(bar->options[GUI_BAR_OPTION_HIDDEN]))
{
if (bar->bar_window)
{
/* root bar */
gui_bar_window_draw (bar->bar_window, NULL);
}
else
{
/* bar on each window */
for (ptr_win = gui_windows; ptr_win; ptr_win = ptr_win->next_window)
{
for (ptr_bar_win = ptr_win->bar_windows; ptr_bar_win;
ptr_bar_win = ptr_bar_win->next_bar_window)
{
if (ptr_bar_win->bar == bar)
{
gui_bar_window_draw (ptr_bar_win, ptr_win);
}
}
}
}
}
bar->bar_refresh_needed = 0;
}
/*
* Applies new size for all bar windows of bar.
*/
void
gui_bar_apply_current_size (struct t_gui_bar *bar)
{
struct t_gui_window *ptr_win;
struct t_gui_bar_window *ptr_bar_win;
if (CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
{
gui_bar_window_set_current_size (bar->bar_window,
NULL,
CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_SIZE]));
gui_window_ask_refresh (1);
}
else
{
for (ptr_win = gui_windows; ptr_win; ptr_win = ptr_win->next_window)
{
for (ptr_bar_win = ptr_win->bar_windows; ptr_bar_win;
ptr_bar_win = ptr_bar_win->next_bar_window)
{
if (ptr_bar_win->bar == bar)
{
gui_bar_window_set_current_size (ptr_bar_win,
ptr_win,
CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_SIZE]));
}
}
}
}
}
/*
* Frees arrays with items for a bar.
*/
void
gui_bar_free_items_arrays (struct t_gui_bar *bar)
{
int i, j;
for (i = 0; i < bar->items_count; i++)
{
if (bar->items_array[i])
string_free_split (bar->items_array[i]);
for (j = 0; j < bar->items_subcount[i]; j++)
{
if (bar->items_buffer[i][j])
free (bar->items_buffer[i][j]);
if (bar->items_prefix[i][j])
free (bar->items_prefix[i][j]);
if (bar->items_name[i][j])
free (bar->items_name[i][j]);
if (bar->items_suffix[i][j])
free (bar->items_suffix[i][j]);
}
if (bar->items_buffer[i])
free (bar->items_buffer[i]);
if (bar->items_prefix[i])
free (bar->items_prefix[i]);
if (bar->items_name[i])
free (bar->items_name[i]);
if (bar->items_suffix[i])
free (bar->items_suffix[i]);
}
if (bar->items_array)
{
free (bar->items_array);
bar->items_array = NULL;
}
if (bar->items_buffer)
{
free (bar->items_buffer);
bar->items_buffer = NULL;
}
if (bar->items_prefix)
{
free (bar->items_prefix);
bar->items_prefix = NULL;
}
if (bar->items_name)
{
free (bar->items_name);
bar->items_name = NULL;
}
if (bar->items_suffix)
{
free (bar->items_suffix);
bar->items_suffix = NULL;
}
if (bar->items_subcount)
{
free (bar->items_subcount);
bar->items_subcount = NULL;
}
bar->items_count = 0;
}
/*
* Builds array with items for a bar.
*/
void
gui_bar_set_items_array (struct t_gui_bar *bar, const char *items)
{
int i, j, count;
char **tmp_array;
gui_bar_free_items_arrays (bar);
if (items && items[0])
{
tmp_array = string_split (items, ",", 0, 0, &count);
if (count > 0)
{
bar->items_count = count;
bar->items_subcount = malloc (count * sizeof (*bar->items_subcount));
bar->items_array = malloc (count * sizeof (*bar->items_array));
bar->items_buffer = malloc (count * sizeof (*bar->items_buffer));
bar->items_prefix = malloc (count * sizeof (*bar->items_prefix));
bar->items_name = malloc (count * sizeof (*bar->items_name));
bar->items_suffix = malloc (count * sizeof (*bar->items_suffix));
for (i = 0; i < count; i++)
{
bar->items_array[i] = string_split (tmp_array[i], "+", 0, 0,
&(bar->items_subcount[i]));
if (bar->items_subcount[i] > 0)
{
bar->items_buffer[i] = malloc (bar->items_subcount[i] *
sizeof (*(bar->items_buffer[i])));
bar->items_prefix[i] = malloc (bar->items_subcount[i] *
sizeof (*(bar->items_prefix[i])));
bar->items_name[i] = malloc (bar->items_subcount[i] *
sizeof (*(bar->items_name[i])));
bar->items_suffix[i] = malloc (bar->items_subcount[i] *
sizeof (*(bar->items_suffix[i])));
for (j = 0; j < bar->items_subcount[i]; j++)
{
gui_bar_item_get_vars (bar->items_array[i][j],
&bar->items_buffer[i][j],
&bar->items_prefix[i][j],
&bar->items_name[i][j],
&bar->items_suffix[i][j]);
}
}
}
}
string_free_split (tmp_array);
}
}
/*
* Callback for checking bar type before changing it.
*
* Returns always 0 because changing the type of a bar is not allowed.
*/
int
gui_bar_config_check_type (const void *pointer, void *data,
struct t_config_option *option,
const char *value)
{
/* make C compiler happy */
(void) pointer;
(void) data;
(void) option;
(void) value;
gui_chat_printf (NULL,
_("%sUnable to change bar type: you must delete bar "
"and create another to do that"),
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR]);
return 0;
}
/*
* Callback called when "hidden" flag is changed.
*/
void
gui_bar_config_change_hidden (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_gui_bar *ptr_bar;
struct t_gui_window *ptr_win;
struct t_gui_bar_window *ptr_bar_win, *next_bar_win;
int bar_window_exists;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar)
{
if (CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
{
if (CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
{
if (ptr_bar->bar_window)
gui_bar_window_free (ptr_bar->bar_window, NULL);
}
else
{
if (!ptr_bar->bar_window)
gui_bar_window_new (ptr_bar, NULL);
}
}
else
{
for (ptr_win = gui_windows; ptr_win; ptr_win = ptr_win->next_window)
{
bar_window_exists = 0;
ptr_bar_win = ptr_win->bar_windows;
while (ptr_bar_win)
{
next_bar_win = ptr_bar_win->next_bar_window;
if (ptr_bar_win->bar == ptr_bar)
{
if (CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
gui_bar_window_free (ptr_bar_win, ptr_win);
else
bar_window_exists = 1;
}
ptr_bar_win = next_bar_win;
}
if (!bar_window_exists
&& !CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
{
gui_bar_window_new (ptr_bar, ptr_win);
}
}
}
gui_window_ask_refresh (1);
}
}
/*
* Callback called when "priority" is changed.
*/
void
gui_bar_config_change_priority (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_gui_bar *ptr_bar;
struct t_gui_window *ptr_win;
struct t_gui_bar_window *bar_windows, *ptr_bar_win, *next_bar_win;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar)
{
/* remove bar from list */
if (ptr_bar == gui_bars)
{
gui_bars = ptr_bar->next_bar;
gui_bars->prev_bar = NULL;
}
if (ptr_bar == last_gui_bar)
{
last_gui_bar = ptr_bar->prev_bar;
last_gui_bar->next_bar = NULL;
}
if (ptr_bar->prev_bar)
(ptr_bar->prev_bar)->next_bar = ptr_bar->next_bar;
if (ptr_bar->next_bar)
(ptr_bar->next_bar)->prev_bar = ptr_bar->prev_bar;
gui_bar_insert (ptr_bar);
for (ptr_win = gui_windows; ptr_win; ptr_win = ptr_win->next_window)
{
bar_windows = ptr_win->bar_windows;
ptr_win->bar_windows = NULL;
ptr_win->last_bar_window = NULL;
ptr_bar_win = bar_windows;
while (ptr_bar_win)
{
next_bar_win = ptr_bar_win->next_bar_window;
gui_bar_window_insert (ptr_bar_win, ptr_win);
ptr_bar_win = next_bar_win;
}
}
gui_window_ask_refresh (1);
}
}
/*
* Callback called when "conditions" is changed.
*/
void
gui_bar_config_change_conditions (const void *pointer, void *data,
struct t_config_option *option)
{
/* make C compiler happy */
(void) pointer;
(void) data;
(void) option;
gui_window_ask_refresh (1);
}
/*
* Callback called when "position" is changed.
*/
void
gui_bar_config_change_position (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_gui_bar *ptr_bar;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar && !CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
gui_bar_refresh (ptr_bar);
gui_window_ask_refresh (1);
}
/*
* Callback called when "filling" is changed.
*/
void
gui_bar_config_change_filling (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_gui_bar *ptr_bar;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar && !CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
gui_bar_refresh (ptr_bar);
gui_window_ask_refresh (1);
}
/*
* Callback for checking bar size before changing it.
*
* Returns:
* 1: new size is OK
* 0: new size is NOT OK
*/
int
gui_bar_config_check_size (const void *pointer, void *data,
struct t_config_option *option,
const char *value)
{
struct t_gui_bar *ptr_bar;
long number;
char *error;
int new_value;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar)
{
new_value = -1;
if (strncmp (value, "++", 2) == 0)
{
error = NULL;
number = strtol (value + 2, &error, 10);
if (error && !error[0])
{
new_value = CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE]) + number;
}
}
else if (strncmp (value, "--", 2) == 0)
{
error = NULL;
number = strtol (value + 2, &error, 10);
if (error && !error[0])
{
new_value = CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE]) - number;
}
}
else
{
error = NULL;
number = strtol (value, &error, 10);
if (error && !error[0])
{
new_value = number;
}
}
if (new_value < 0)
return 0;
if ((new_value > 0) &&
((CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE]) == 0)
|| (new_value > CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE]))))
{
if (!CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN])
&& !gui_bar_check_size_add (ptr_bar,
new_value - CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE])))
return 0;
}
return 1;
}
return 0;
}
/*
* Callback called when "size" is changed.
*/
void
gui_bar_config_change_size (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_gui_bar *ptr_bar;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar && !CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
{
gui_bar_apply_current_size (ptr_bar);
gui_bar_refresh (ptr_bar);
}
}
/*
* Callback called when "size_max" is changed.
*/
void
gui_bar_config_change_size_max (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_gui_bar *ptr_bar;
char value[32];
/* make C compiler happy */
(void) pointer;
(void) data;
(void) option;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar && !CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
{
if ((CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE_MAX]) > 0)
&& (CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE]) >
CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE_MAX])))
{
snprintf (value, sizeof (value), "%d",
CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE_MAX]));
config_file_option_set (ptr_bar->options[GUI_BAR_OPTION_SIZE], value, 1);
}
gui_window_ask_refresh (1);
}
}
/*
* Callback when color (fg or bg) is changed.
*/
void
gui_bar_config_change_color (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_gui_bar *ptr_bar;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar && !CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
gui_bar_refresh (ptr_bar);
}
/*
* Callback called when "separator" is changed.
*/
void
gui_bar_config_change_separator (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_gui_bar *ptr_bar;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar && !CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
gui_bar_refresh (ptr_bar);
}
/*
* Callback called when "items" is changed.
*/
void
gui_bar_config_change_items (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_gui_bar *ptr_bar;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_bar = gui_bar_search_with_option_name (option->name);
if (ptr_bar)
{
gui_bar_set_items_array (ptr_bar, CONFIG_STRING(ptr_bar->options[GUI_BAR_OPTION_ITEMS]));
gui_bar_content_build_bar_windows (ptr_bar);
if (!CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]))
gui_bar_ask_refresh (ptr_bar);
}
}
/*
* Sets name for a bar.
*/
void
gui_bar_set_name (struct t_gui_bar *bar, const char *name)
{
int length;
char *option_name;
if (!name || !name[0])
return;
length = strlen (name) + 64;
option_name = malloc (length);
if (option_name)
{
snprintf (option_name, length, "%s.hidden", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_HIDDEN], option_name);
snprintf (option_name, length, "%s.priority", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_PRIORITY], option_name);
snprintf (option_name, length, "%s.type", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_TYPE], option_name);
snprintf (option_name, length, "%s.conditions", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_CONDITIONS], option_name);
snprintf (option_name, length, "%s.position", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_POSITION], option_name);
snprintf (option_name, length, "%s.filling_top_bottom", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_FILLING_TOP_BOTTOM], option_name);
snprintf (option_name, length, "%s.filling_left_right", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_FILLING_LEFT_RIGHT], option_name);
snprintf (option_name, length, "%s.size", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_SIZE], option_name);
snprintf (option_name, length, "%s.size_max", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_SIZE_MAX], option_name);
snprintf (option_name, length, "%s.color_fg", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_COLOR_FG], option_name);
snprintf (option_name, length, "%s.color_delim", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_COLOR_DELIM], option_name);
snprintf (option_name, length, "%s.color_bg", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_COLOR_BG], option_name);
snprintf (option_name, length, "%s.separator", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_SEPARATOR], option_name);
snprintf (option_name, length, "%s.items", name);
config_file_option_rename (bar->options[GUI_BAR_OPTION_ITEMS], option_name);
if (bar->name)
free (bar->name);
bar->name = strdup (name);
free (option_name);
}
}
/*
* Sets a property for a bar.
*
* Returns:
* 1: OK
* 0: error
*/
int
gui_bar_set (struct t_gui_bar *bar, const char *property, const char *value)
{
if (!bar || !property || !value)
return 0;
if (string_strcasecmp (property, "name") == 0)
{
gui_bar_set_name (bar, value);
return 1;
}
else if (string_strcasecmp (property, "hidden") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_HIDDEN], value, 1);
return 1;
}
else if (string_strcasecmp (property, "priority") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_PRIORITY], value, 1);
return 1;
}
else if (string_strcasecmp (property, "conditions") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_CONDITIONS], value, 1);
return 1;
}
else if (string_strcasecmp (property, "position") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_POSITION], value, 1);
return 1;
}
else if (string_strcasecmp (property, "filling_top_bottom") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_FILLING_TOP_BOTTOM], value, 1);
return 1;
}
else if (string_strcasecmp (property, "filling_left_right") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_FILLING_LEFT_RIGHT], value, 1);
return 1;
}
else if (string_strcasecmp (property, "size") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_SIZE], value, 1);
return 1;
}
else if (string_strcasecmp (property, "size_max") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_SIZE_MAX], value, 1);
return 1;
}
else if (string_strcasecmp (property, "color_fg") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_COLOR_FG], value, 1);
gui_bar_refresh (bar);
return 1;
}
else if (string_strcasecmp (property, "color_delim") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_COLOR_DELIM], value, 1);
gui_bar_refresh (bar);
return 1;
}
else if (string_strcasecmp (property, "color_bg") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_COLOR_BG], value, 1);
gui_bar_refresh (bar);
return 1;
}
else if (string_strcasecmp (property, "separator") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_SEPARATOR],
(strcmp (value, "1") == 0) ? "on" : "off",
1);
gui_bar_refresh (bar);
return 1;
}
else if (string_strcasecmp (property, "items") == 0)
{
config_file_option_set (bar->options[GUI_BAR_OPTION_ITEMS], value, 1);
gui_bar_draw (bar);
return 1;
}
return 0;
}
/*
* Returns default items for a bar name.
*
* Default bars (input, title, status, nicklist) have default items, all other
* bars have empty default items.
*/
const char *
gui_bar_default_items (const char *bar_name)
{
int i;
static char empty_items[1] = { '\0' };
for (i = 0; gui_bar_items_default_for_bars[i][0]; i++)
{
if (string_strcasecmp (gui_bar_items_default_for_bars[i][0], bar_name) == 0)
return gui_bar_items_default_for_bars[i][1];
}
/* no default items in bar */
return empty_items;
}
/*
* Creates an option for a bar.
*
* Returns pointer to new option, NULL if error.
*/
struct t_config_option *
gui_bar_create_option (const char *bar_name, int index_option, const char *value)
{
struct t_config_option *ptr_option;
int length;
char *option_name;
ptr_option = NULL;
length = strlen (bar_name) + 1 +
strlen (gui_bar_option_string[index_option]) + 1;
option_name = malloc (length);
if (!option_name)
return NULL;
snprintf (option_name, length, "%s.%s",
bar_name, gui_bar_option_string[index_option]);
switch (index_option)
{
case GUI_BAR_OPTION_HIDDEN:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "boolean",
N_("true if bar is hidden, false if it is displayed"),
NULL, 0, 0, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_hidden, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_PRIORITY:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "integer",
N_("bar priority (high number means bar displayed first)"),
NULL, 0, INT_MAX, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_priority, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_TYPE:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "integer",
N_("bar type (root, window, window_active, window_inactive)"),
"root|window|window_active|window_inactive", 0, 0, value, NULL, 0,
&gui_bar_config_check_type, NULL, NULL,
NULL, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_CONDITIONS:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "string",
N_("conditions to display the bar: a simple condition: "
"\"active\", \"inactive\", \"nicklist\" (window must be "
"active/inactive, buffer must have a nicklist), or an "
"expression with condition(s) (see /help eval), "
"like: \"${nicklist} && ${info:term_width} > 100\" "
"(local variables for expression are ${active}, "
"${inactive} and ${nicklist})"),
NULL, 0, 0, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_conditions, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_POSITION:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "integer",
N_("bar position (bottom, top, left, right)"),
"bottom|top|left|right", 0, 0, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_position, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_FILLING_TOP_BOTTOM:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "integer",
N_("bar filling direction (\"horizontal\" (from left to right) "
"or \"vertical\" (from top to bottom)) when bar position is "
"top or bottom"),
"horizontal|vertical|columns_horizontal|columns_vertical",
0, 0, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_filling, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_FILLING_LEFT_RIGHT:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "integer",
N_("bar filling direction (\"horizontal\" (from left to right) "
"or \"vertical\" (from top to bottom)) when bar position is "
"left or right"),
"horizontal|vertical|columns_horizontal|columns_vertical",
0, 0, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_filling, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_SIZE:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "integer",
N_("bar size in chars (0 = auto size)"),
NULL, 0, INT_MAX, value, NULL, 0,
&gui_bar_config_check_size, NULL, NULL,
&gui_bar_config_change_size, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_SIZE_MAX:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "integer",
N_("max bar size in chars (0 = no limit)"),
NULL, 0, INT_MAX, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_size_max, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_COLOR_FG:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "color",
N_("default text color for bar"),
NULL, 0, 0, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_color, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_COLOR_DELIM:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "color",
N_("default delimiter color for bar"),
NULL, 0, 0, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_color, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_COLOR_BG:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "color",
N_("default background color for bar"),
NULL, 0, 0, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_color, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_SEPARATOR:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "boolean",
N_("separator line between bar and other bars/windows"),
NULL, 0, 0, value, NULL, 0,
NULL, NULL, NULL,
&gui_bar_config_change_separator, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_OPTION_ITEMS:
ptr_option = config_file_new_option (
weechat_config_file, weechat_config_section_bar,
option_name, "string",
N_("items of bar, they can be separated by comma (space "
"between items) or \"+\" (glued items); special syntax "
"\"@buffer:item\" can be used to force buffer used when "
"displaying the bar item"),
NULL, 0, 0, gui_bar_default_items (bar_name), value, 0,
NULL, NULL, NULL,
&gui_bar_config_change_items, NULL, NULL,
NULL, NULL, NULL);
break;
case GUI_BAR_NUM_OPTIONS:
break;
}
free (option_name);
return ptr_option;
}
/*
* Creates option for a temporary bar (when reading configuration file).
*/
void
gui_bar_create_option_temp (struct t_gui_bar *temp_bar, int index_option,
const char *value)
{
struct t_config_option *new_option;
new_option = gui_bar_create_option (temp_bar->name,
index_option,
value);
if (new_option
&& (index_option >= 0) && (index_option < GUI_BAR_NUM_OPTIONS))
{
temp_bar->options[index_option] = new_option;
}
}
/*
* Allocates and initializes new bar structure.
*
* Returns pointer to new bar, NULL if error.
*/
struct t_gui_bar *
gui_bar_alloc (const char *name)
{
struct t_gui_bar *new_bar;
int i;
new_bar = malloc (sizeof (*new_bar));
if (new_bar)
{
new_bar->name = strdup (name);
for (i = 0; i < GUI_BAR_NUM_OPTIONS; i++)
{
new_bar->options[i] = NULL;
}
new_bar->items_count = 0;
new_bar->items_array = NULL;
new_bar->items_buffer = NULL;
new_bar->items_prefix = NULL;
new_bar->items_name = NULL;
new_bar->items_suffix = NULL;
new_bar->bar_window = NULL;
new_bar->bar_refresh_needed = 0;
new_bar->prev_bar = NULL;
new_bar->next_bar = NULL;
}
return new_bar;
}
/*
* Creates a new bar with options.
*
* Returns pointer to new bar, NULL if error.
*/
struct t_gui_bar *
gui_bar_new_with_options (const char *name,
struct t_config_option *hidden,
struct t_config_option *priority,
struct t_config_option *type,
struct t_config_option *conditions,
struct t_config_option *position,
struct t_config_option *filling_top_bottom,
struct t_config_option *filling_left_right,
struct t_config_option *size,
struct t_config_option *size_max,
struct t_config_option *color_fg,
struct t_config_option *color_delim,
struct t_config_option *color_bg,
struct t_config_option *separator,
struct t_config_option *items)
{
struct t_gui_bar *new_bar;
struct t_gui_window *ptr_win;
/* create bar */
new_bar = gui_bar_alloc (name);
if (!new_bar)
return NULL;
new_bar->options[GUI_BAR_OPTION_HIDDEN] = hidden;
new_bar->options[GUI_BAR_OPTION_PRIORITY] = priority;
new_bar->options[GUI_BAR_OPTION_TYPE] = type;
new_bar->options[GUI_BAR_OPTION_CONDITIONS] = conditions;
new_bar->options[GUI_BAR_OPTION_POSITION] = position;
new_bar->options[GUI_BAR_OPTION_FILLING_TOP_BOTTOM] = filling_top_bottom;
new_bar->options[GUI_BAR_OPTION_FILLING_LEFT_RIGHT] = filling_left_right;
new_bar->options[GUI_BAR_OPTION_SIZE] = size;
new_bar->options[GUI_BAR_OPTION_SIZE_MAX] = size_max;
new_bar->options[GUI_BAR_OPTION_COLOR_FG] = color_fg;
new_bar->options[GUI_BAR_OPTION_COLOR_DELIM] = color_delim;
new_bar->options[GUI_BAR_OPTION_COLOR_BG] = color_bg;
new_bar->options[GUI_BAR_OPTION_SEPARATOR] = separator;
new_bar->options[GUI_BAR_OPTION_ITEMS] = items;
new_bar->items_count = 0;
new_bar->items_subcount = NULL;
new_bar->items_array = NULL;
new_bar->items_buffer = NULL;
new_bar->items_prefix = NULL;
new_bar->items_name = NULL;
new_bar->items_suffix = NULL;
gui_bar_set_items_array (new_bar, CONFIG_STRING(items));
new_bar->bar_window = NULL;
new_bar->bar_refresh_needed = 1;
/* add bar to bars list */
gui_bar_insert (new_bar);
/* add window bar */
if (CONFIG_INTEGER(new_bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
{
/* create only one window for bar */
gui_bar_window_new (new_bar, NULL);
gui_window_ask_refresh (1);
}
else
{
/* create bar window for all opened windows */
for (ptr_win = gui_windows; ptr_win;
ptr_win = ptr_win->next_window)
{
gui_bar_window_new (new_bar, ptr_win);
}
}
return new_bar;
}
/*
* Creates a new bar.
*
* Returns pointer to new bar, NULL if error.
*/
struct t_gui_bar *
gui_bar_new (const char *name, const char *hidden, const char *priority,
const char *type, const char *conditions, const char *position,
const char *filling_top_bottom, const char *filling_left_right,
const char *size, const char *size_max,
const char *color_fg, const char *color_delim,
const char *color_bg, const char *separators, const char *items)
{
struct t_config_option *option_hidden, *option_priority, *option_type;
struct t_config_option *option_conditions, *option_position;
struct t_config_option *option_filling_top_bottom, *option_filling_left_right;
struct t_config_option *option_size, *option_size_max;
struct t_config_option *option_color_fg, *option_color_delim;
struct t_config_option *option_color_bg, *option_separator;
struct t_config_option *option_items;
struct t_gui_bar *new_bar;
if (!name || !name[0])
return NULL;
/* it's not possible to create 2 bars with same name */
if (gui_bar_search (name))
return NULL;
/* look for type */
if (gui_bar_search_type (type) < 0)
return NULL;
/* look for position */
if (gui_bar_search_position (position) < 0)
return NULL;
option_hidden = gui_bar_create_option (name, GUI_BAR_OPTION_HIDDEN,
hidden);
option_priority = gui_bar_create_option (name, GUI_BAR_OPTION_PRIORITY,
priority);
option_type = gui_bar_create_option (name, GUI_BAR_OPTION_TYPE,
type);
option_conditions = gui_bar_create_option (name, GUI_BAR_OPTION_CONDITIONS,
conditions);
option_position = gui_bar_create_option (name, GUI_BAR_OPTION_POSITION,
position);
option_filling_top_bottom = gui_bar_create_option (name, GUI_BAR_OPTION_FILLING_TOP_BOTTOM,
filling_top_bottom);
option_filling_left_right = gui_bar_create_option (name, GUI_BAR_OPTION_FILLING_LEFT_RIGHT,
filling_left_right);
option_size = gui_bar_create_option (name, GUI_BAR_OPTION_SIZE,
size);
option_size_max = gui_bar_create_option (name, GUI_BAR_OPTION_SIZE_MAX,
size_max);
option_color_fg = gui_bar_create_option (name, GUI_BAR_OPTION_COLOR_FG,
color_fg);
option_color_delim = gui_bar_create_option (name, GUI_BAR_OPTION_COLOR_DELIM,
color_delim);
option_color_bg = gui_bar_create_option (name, GUI_BAR_OPTION_COLOR_BG,
color_bg);
option_separator = gui_bar_create_option (name, GUI_BAR_OPTION_SEPARATOR,
(config_file_string_to_boolean (separators)) ?
"on" : "off");
option_items = gui_bar_create_option (name, GUI_BAR_OPTION_ITEMS,
items);
new_bar = gui_bar_new_with_options (name, option_hidden,
option_priority, option_type,
option_conditions, option_position,
option_filling_top_bottom,
option_filling_left_right,
option_size, option_size_max,
option_color_fg, option_color_delim,
option_color_bg, option_separator,
option_items);
if (!new_bar)
{
if (option_hidden)
config_file_option_free (option_hidden);
if (option_priority)
config_file_option_free (option_priority);
if (option_type)
config_file_option_free (option_type);
if (option_conditions)
config_file_option_free (option_conditions);
if (option_position)
config_file_option_free (option_position);
if (option_filling_top_bottom)
config_file_option_free (option_filling_top_bottom);
if (option_filling_left_right)
config_file_option_free (option_filling_left_right);
if (option_size)
config_file_option_free (option_size);
if (option_size_max)
config_file_option_free (option_size_max);
if (option_color_fg)
config_file_option_free (option_color_fg);
if (option_color_delim)
config_file_option_free (option_color_delim);
if (option_color_bg)
config_file_option_free (option_color_bg);
if (option_separator)
config_file_option_free (option_separator);
if (option_items)
config_file_option_free (option_items);
}
return new_bar;
}
/*
* Uses temporary bars (created by reading configuration file).
*/
void
gui_bar_use_temp_bars ()
{
struct t_gui_bar *ptr_temp_bar, *next_temp_bar;
int i, num_options_ok;
for (ptr_temp_bar = gui_temp_bars; ptr_temp_bar;
ptr_temp_bar = ptr_temp_bar->next_bar)
{
num_options_ok = 0;
for (i = 0; i < GUI_BAR_NUM_OPTIONS; i++)
{
if (!ptr_temp_bar->options[i])
{
ptr_temp_bar->options[i] = gui_bar_create_option (ptr_temp_bar->name,
i,
gui_bar_option_default[i]);
}
if (ptr_temp_bar->options[i])
num_options_ok++;
}
if (num_options_ok == GUI_BAR_NUM_OPTIONS)
{
gui_bar_new_with_options (ptr_temp_bar->name,
ptr_temp_bar->options[GUI_BAR_OPTION_HIDDEN],
ptr_temp_bar->options[GUI_BAR_OPTION_PRIORITY],
ptr_temp_bar->options[GUI_BAR_OPTION_TYPE],
ptr_temp_bar->options[GUI_BAR_OPTION_CONDITIONS],
ptr_temp_bar->options[GUI_BAR_OPTION_POSITION],
ptr_temp_bar->options[GUI_BAR_OPTION_FILLING_TOP_BOTTOM],
ptr_temp_bar->options[GUI_BAR_OPTION_FILLING_LEFT_RIGHT],
ptr_temp_bar->options[GUI_BAR_OPTION_SIZE],
ptr_temp_bar->options[GUI_BAR_OPTION_SIZE_MAX],
ptr_temp_bar->options[GUI_BAR_OPTION_COLOR_FG],
ptr_temp_bar->options[GUI_BAR_OPTION_COLOR_DELIM],
ptr_temp_bar->options[GUI_BAR_OPTION_COLOR_BG],
ptr_temp_bar->options[GUI_BAR_OPTION_SEPARATOR],
ptr_temp_bar->options[GUI_BAR_OPTION_ITEMS]);
}
else
{
for (i = 0; i < GUI_BAR_NUM_OPTIONS; i++)
{
if (ptr_temp_bar->options[i])
{
config_file_option_free (ptr_temp_bar->options[i]);
ptr_temp_bar->options[i] = NULL;
}
}
}
}
/* free all temporary bars */
while (gui_temp_bars)
{
next_temp_bar = gui_temp_bars->next_bar;
if (gui_temp_bars->name)
free (gui_temp_bars->name);
free (gui_temp_bars);
gui_temp_bars = next_temp_bar;
}
last_gui_temp_bar = NULL;
}
/*
* Creates default input bar if it does not exist.
*/
void
gui_bar_create_default_input ()
{
struct t_gui_bar *ptr_bar;
int length;
char *buf;
/* search an input_text item */
if (!gui_bar_item_used_in_at_least_one_bar (gui_bar_item_names[GUI_BAR_ITEM_INPUT_TEXT],
1, 0))
{
ptr_bar = gui_bar_search (GUI_BAR_DEFAULT_NAME_INPUT);
if (ptr_bar)
{
/* add item "input_text" to input bar */
length = 1;
if (CONFIG_STRING(ptr_bar->options[GUI_BAR_OPTION_ITEMS]))
length += strlen (CONFIG_STRING(ptr_bar->options[GUI_BAR_OPTION_ITEMS]));
length += 1; /* "," */
length += strlen (gui_bar_item_names[GUI_BAR_ITEM_INPUT_TEXT]);
buf = malloc (length);
if (buf)
{
snprintf (buf, length, "%s,%s",
(CONFIG_STRING(ptr_bar->options[GUI_BAR_OPTION_ITEMS])) ?
CONFIG_STRING(ptr_bar->options[GUI_BAR_OPTION_ITEMS]) : "",
gui_bar_item_names[GUI_BAR_ITEM_INPUT_TEXT]);
config_file_option_set (ptr_bar->options[GUI_BAR_OPTION_ITEMS], buf, 1);
gui_chat_printf (NULL, _("Bar \"%s\" updated"),
GUI_BAR_DEFAULT_NAME_INPUT);
gui_bar_draw (ptr_bar);
free (buf);
}
}
else
{
/* create input bar */
if (gui_bar_new (GUI_BAR_DEFAULT_NAME_INPUT,
"0", /* hidden */
"1000", /* priority */
"window", /* type */
"", /* conditions */
"bottom", /* position */
"horizontal", /* filling_top_bottom */
"vertical", /* filling_left_right */
"1", /* size */
"0", /* size_max */
"default", /* color fg */
"cyan", /* color delim */
"default", /* color bg */
"0", /* separators */
gui_bar_default_items (GUI_BAR_DEFAULT_NAME_INPUT))) /* items */
{
gui_chat_printf (NULL, _("Bar \"%s\" created"),
GUI_BAR_DEFAULT_NAME_INPUT);
}
}
}
}
/*
* Creates default title bar if it does not exist.
*/
void
gui_bar_create_default_title ()
{
struct t_gui_bar *ptr_bar;
/* search title bar */
ptr_bar = gui_bar_search (GUI_BAR_DEFAULT_NAME_TITLE);
if (!ptr_bar)
{
/* create title bar */
if (gui_bar_new (GUI_BAR_DEFAULT_NAME_TITLE,
"0", /* hidden */
"500", /* priority */
"window", /* type */
"", /* conditions */
"top", /* position */
"horizontal", /* filling_top_bottom */
"vertical" , /* filling_left_right */
"1", /* size */
"0", /* size_max */
"default", /* color fg */
"cyan", /* color delim */
"blue", /* color bg */
"0", /* separators */
gui_bar_default_items (GUI_BAR_DEFAULT_NAME_TITLE))) /* items */
{
gui_chat_printf (NULL, _("Bar \"%s\" created"),
GUI_BAR_DEFAULT_NAME_TITLE);
}
}
}
/*
* Creates default status bar if it does not exist.
*/
void
gui_bar_create_default_status ()
{
struct t_gui_bar *ptr_bar;
/* search status bar */
ptr_bar = gui_bar_search (GUI_BAR_DEFAULT_NAME_STATUS);
if (!ptr_bar)
{
/* create status bar */
if (gui_bar_new (GUI_BAR_DEFAULT_NAME_STATUS,
"0", /* hidden */
"500", /* priority */
"window", /* type */
"", /* conditions */
"bottom", /* position */
"horizontal", /* filling_top_bottom */
"vertical", /* filling_left_right */
"1", /* size */
"0", /* size_max */
"default", /* color fg */
"cyan", /* color delim */
"blue", /* color bg */
"0", /* separators */
gui_bar_default_items (GUI_BAR_DEFAULT_NAME_STATUS))) /* items */
{
gui_chat_printf (NULL, _("Bar \"%s\" created"),
GUI_BAR_DEFAULT_NAME_STATUS);
}
}
}
/*
* Creates default nicklist bar if it does not exist.
*/
void
gui_bar_create_default_nicklist ()
{
struct t_gui_bar *ptr_bar;
/* search nicklist bar */
ptr_bar = gui_bar_search (GUI_BAR_DEFAULT_NAME_NICKLIST);
if (!ptr_bar)
{
/* create nicklist bar */
if (gui_bar_new (GUI_BAR_DEFAULT_NAME_NICKLIST,
"0", /* hidden */
"200", /* priority */
"window", /* type */
"${nicklist}", /* conditions */
"right", /* position */
"columns_vertical", /* filling_top_bottom */
"vertical", /* filling_left_right */
"0", /* size */
"0", /* size_max */
"default", /* color fg */
"cyan", /* color delim */
"default", /* color bg */
"1", /* separators */
gui_bar_default_items (GUI_BAR_DEFAULT_NAME_NICKLIST))) /* items */
{
gui_chat_printf (NULL, _("Bar \"%s\" created"),
GUI_BAR_DEFAULT_NAME_NICKLIST);
}
}
}
/*
* Creates default bars if they do not exist.
*/
void
gui_bar_create_default ()
{
gui_bar_create_default_input ();
gui_bar_create_default_title ();
gui_bar_create_default_status ();
gui_bar_create_default_nicklist ();
}
/*
* Updates a bar on screen.
*/
void
gui_bar_update (const char *name)
{
struct t_gui_bar *ptr_bar;
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
if (!CONFIG_BOOLEAN(ptr_bar->options[GUI_BAR_OPTION_HIDDEN])
&& (string_strcasecmp (ptr_bar->name, name) == 0))
{
gui_bar_ask_refresh (ptr_bar);
}
}
}
/*
* Scrolls a bar.
*
* Returns:
* 1: scroll OK
* 0: error
*/
int
gui_bar_scroll (struct t_gui_bar *bar, struct t_gui_window *window,
const char *scroll)
{
struct t_gui_bar_window *ptr_bar_win;
long number;
char *str, *error;
int length, add_x, add, percent, scroll_beginning, scroll_end;
if (!bar)
return 0;
if (CONFIG_BOOLEAN(bar->options[GUI_BAR_OPTION_HIDDEN]))
return 1;
add_x = 0;
str = NULL;
number = 0;
add = 0;
percent = 0;
scroll_beginning = 0;
scroll_end = 0;
if ((scroll[0] == 'x') || (scroll[0] == 'X'))
{
add_x = 1;
scroll++;
}
else if ((scroll[0] == 'y') || (scroll[0] == 'Y'))
{
scroll++;
}
else
{
/* auto-detect if we scroll X/Y, according to filling */
if (gui_bar_get_filling (bar) == GUI_BAR_FILLING_HORIZONTAL)
add_x = 1;
}
if ((scroll[0] == 'b') || (scroll[0] == 'B'))
{
scroll_beginning = 1;
}
else if ((scroll[0] == 'e') || (scroll[0] == 'E'))
{
scroll_end = 1;
}
else
{
if (scroll[0] == '+')
{
add = 1;
scroll++;
}
else if (scroll[0] == '-')
{
scroll++;
}
else
return 0;
length = strlen (scroll);
if (length == 0)
return 0;
if (scroll[length - 1] == '%')
{
str = string_strndup (scroll, length - 1);
percent = 1;
}
else
str = strdup (scroll);
if (!str)
return 0;
error = NULL;
number = strtol (str, &error, 10);
if (!error || error[0] || (number <= 0))
{
free (str);
return 0;
}
}
if (CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_TYPE]) == GUI_BAR_TYPE_ROOT)
{
gui_bar_window_scroll (bar->bar_window, NULL,
add_x, scroll_beginning, scroll_end,
add, percent, number);
}
else if (window)
{
for (ptr_bar_win = window->bar_windows; ptr_bar_win;
ptr_bar_win = ptr_bar_win->next_bar_window)
{
if (ptr_bar_win->bar == bar)
{
gui_bar_window_scroll (ptr_bar_win, window,
add_x, scroll_beginning, scroll_end,
add, percent, number);
}
}
}
if (str)
free (str);
return 1;
}
/*
* Deletes a bar.
*/
void
gui_bar_free (struct t_gui_bar *bar)
{
int i;
if (!bar)
return;
/* remove bar window(s) */
if (bar->bar_window)
{
gui_bar_window_free (bar->bar_window, NULL);
gui_window_ask_refresh (1);
}
else
gui_bar_free_bar_windows (bar);
/* remove bar from bars list */
if (bar->prev_bar)
(bar->prev_bar)->next_bar = bar->next_bar;
if (bar->next_bar)
(bar->next_bar)->prev_bar = bar->prev_bar;
if (gui_bars == bar)
gui_bars = bar->next_bar;
if (last_gui_bar == bar)
last_gui_bar = bar->prev_bar;
/* free data */
if (bar->name)
free (bar->name);
for (i = 0; i < GUI_BAR_NUM_OPTIONS; i++)
{
if (bar->options[i])
config_file_option_free (bar->options[i]);
}
gui_bar_free_items_arrays (bar);
free (bar);
}
/*
* Deletes all bars.
*/
void
gui_bar_free_all ()
{
while (gui_bars)
{
gui_bar_free (gui_bars);
}
}
/*
* Frees bar windows for a bar.
*/
void
gui_bar_free_bar_windows (struct t_gui_bar *bar)
{
struct t_gui_window *ptr_win;
struct t_gui_bar_window *ptr_bar_win, *next_bar_win;
if (bar->bar_window)
{
gui_bar_window_free (bar->bar_window, NULL);
}
else
{
for (ptr_win = gui_windows; ptr_win; ptr_win = ptr_win->next_window)
{
ptr_bar_win = ptr_win->bar_windows;
while (ptr_bar_win)
{
next_bar_win = ptr_bar_win->next_bar_window;
if (ptr_bar_win->bar == bar)
gui_bar_window_free (ptr_bar_win, ptr_win);
ptr_bar_win = next_bar_win;
}
}
}
}
/*
* Returns hdata for bar.
*/
struct t_hdata *
gui_bar_hdata_bar_cb (const void *pointer, void *data, const char *hdata_name)
{
struct t_hdata *hdata;
/* make C compiler happy */
(void) pointer;
(void) data;
hdata = hdata_new (NULL, hdata_name, "prev_bar", "next_bar",
0, 0, NULL, NULL);
if (hdata)
{
HDATA_VAR(struct t_gui_bar, name, STRING, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, options, POINTER, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, items_count, INTEGER, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, items_subcount, POINTER, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, items_array, POINTER, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, items_buffer, POINTER, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, items_prefix, POINTER, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, items_name, POINTER, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, items_suffix, POINTER, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, bar_window, POINTER, 0, NULL, "bar_window");
HDATA_VAR(struct t_gui_bar, bar_refresh_needed, INTEGER, 0, NULL, NULL);
HDATA_VAR(struct t_gui_bar, prev_bar, POINTER, 0, NULL, hdata_name);
HDATA_VAR(struct t_gui_bar, next_bar, POINTER, 0, NULL, hdata_name);
HDATA_LIST(gui_bars, WEECHAT_HDATA_LIST_CHECK_POINTERS);
HDATA_LIST(last_gui_bar, 0);
}
return hdata;
}
/*
* Adds a bar in an infolist.
*
* Returns:
* 1: OK
* 0: error
*/
int
gui_bar_add_to_infolist (struct t_infolist *infolist,
struct t_gui_bar *bar)
{
struct t_infolist_item *ptr_item;
int i, j;
char option_name[64];
if (!infolist || !bar)
return 0;
ptr_item = infolist_new_item (infolist);
if (!ptr_item)
return 0;
if (!infolist_new_var_string (ptr_item, "name", bar->name))
return 0;
if (!infolist_new_var_integer (ptr_item, "hidden", CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_HIDDEN])))
return 0;
if (!infolist_new_var_integer (ptr_item, "priority", CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_PRIORITY])))
return 0;
if (!infolist_new_var_integer (ptr_item, "type", CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_TYPE])))
return 0;
if (!infolist_new_var_string (ptr_item, "conditions", CONFIG_STRING(bar->options[GUI_BAR_OPTION_CONDITIONS])))
return 0;
if (!infolist_new_var_integer (ptr_item, "position", CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_POSITION])))
return 0;
if (!infolist_new_var_integer (ptr_item, "filling_top_bottom", CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_FILLING_TOP_BOTTOM])))
return 0;
if (!infolist_new_var_integer (ptr_item, "filling_left_right", CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_FILLING_LEFT_RIGHT])))
return 0;
if (!infolist_new_var_integer (ptr_item, "size", CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_SIZE])))
return 0;
if (!infolist_new_var_integer (ptr_item, "size_max", CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_SIZE_MAX])))
return 0;
if (!infolist_new_var_string (ptr_item, "color_fg", gui_color_get_name (CONFIG_COLOR(bar->options[GUI_BAR_OPTION_COLOR_FG]))))
return 0;
if (!infolist_new_var_string (ptr_item, "color_delim", gui_color_get_name (CONFIG_COLOR(bar->options[GUI_BAR_OPTION_COLOR_DELIM]))))
return 0;
if (!infolist_new_var_string (ptr_item, "color_bg", gui_color_get_name (CONFIG_COLOR(bar->options[GUI_BAR_OPTION_COLOR_BG]))))
return 0;
if (!infolist_new_var_integer (ptr_item, "separator", CONFIG_INTEGER(bar->options[GUI_BAR_OPTION_SEPARATOR])))
return 0;
if (!infolist_new_var_string (ptr_item, "items", CONFIG_STRING(bar->options[GUI_BAR_OPTION_ITEMS])))
return 0;
if (!infolist_new_var_integer (ptr_item, "items_count", bar->items_count))
return 0;
for (i = 0; i < bar->items_count; i++)
{
for (j = 0; j < bar->items_subcount[i]; j++)
{
snprintf (option_name, sizeof (option_name),
"items_array_%05d_%05d", i + 1, j + 1);
if (!infolist_new_var_string (ptr_item, option_name,
bar->items_array[i][j]))
return 0;
snprintf (option_name, sizeof (option_name),
"items_buffer_%05d_%05d", i + 1, j + 1);
if (!infolist_new_var_string (ptr_item, option_name,
bar->items_buffer[i][j]))
return 0;
snprintf (option_name, sizeof (option_name),
"items_prefix_%05d_%05d", i + 1, j + 1);
if (!infolist_new_var_string (ptr_item, option_name,
bar->items_prefix[i][j]))
return 0;
snprintf (option_name, sizeof (option_name),
"items_suffix_%05d_%05d", i + 1, j + 1);
if (!infolist_new_var_string (ptr_item, option_name,
bar->items_suffix[i][j]))
return 0;
}
}
if (!infolist_new_var_pointer (ptr_item, "bar_window", bar->bar_window))
return 0;
return 1;
}
/*
* Prints bar infos in WeeChat log file (usually for crash dump).
*/
void
gui_bar_print_log ()
{
struct t_gui_bar *ptr_bar;
int i, j;
for (ptr_bar = gui_bars; ptr_bar; ptr_bar = ptr_bar->next_bar)
{
log_printf ("");
log_printf ("[bar (addr:0x%lx)]", ptr_bar);
log_printf (" name . . . . . . . . . : '%s'", ptr_bar->name);
log_printf (" hidden . . . . . . . . : %d", CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_HIDDEN]));
log_printf (" priority . . . . . . . : %d", CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_PRIORITY]));
log_printf (" type . . . . . . . . . : %d (%s)",
CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_TYPE]),
gui_bar_type_string[CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_TYPE])]);
log_printf (" conditions . . . . . . : '%s'", CONFIG_STRING(ptr_bar->options[GUI_BAR_OPTION_CONDITIONS]));
log_printf (" position . . . . . . . : %d (%s)",
CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_POSITION]),
gui_bar_position_string[CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_POSITION])]);
log_printf (" filling_top_bottom . . : %d (%s)",
CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_FILLING_TOP_BOTTOM]),
gui_bar_filling_string[CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_FILLING_TOP_BOTTOM])]);
log_printf (" filling_left_right . . : %d (%s)",
CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_FILLING_LEFT_RIGHT]),
gui_bar_filling_string[CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_FILLING_LEFT_RIGHT])]);
log_printf (" size . . . . . . . . . : %d", CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE]));
log_printf (" size_max . . . . . . . : %d", CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SIZE_MAX]));
log_printf (" color_fg . . . . . . . : %d (%s)",
CONFIG_COLOR(ptr_bar->options[GUI_BAR_OPTION_COLOR_FG]),
gui_color_get_name (CONFIG_COLOR(ptr_bar->options[GUI_BAR_OPTION_COLOR_FG])));
log_printf (" color_delim. . . . . . : %d (%s)",
CONFIG_COLOR(ptr_bar->options[GUI_BAR_OPTION_COLOR_DELIM]),
gui_color_get_name (CONFIG_COLOR(ptr_bar->options[GUI_BAR_OPTION_COLOR_DELIM])));
log_printf (" color_bg . . . . . . . : %d (%s)",
CONFIG_COLOR(ptr_bar->options[GUI_BAR_OPTION_COLOR_BG]),
gui_color_get_name (CONFIG_COLOR(ptr_bar->options[GUI_BAR_OPTION_COLOR_BG])));
log_printf (" separator. . . . . . . : %d", CONFIG_INTEGER(ptr_bar->options[GUI_BAR_OPTION_SEPARATOR]));
log_printf (" items. . . . . . . . . : '%s'", CONFIG_STRING(ptr_bar->options[GUI_BAR_OPTION_ITEMS]));
log_printf (" items_count. . . . . . : %d", ptr_bar->items_count);
for (i = 0; i < ptr_bar->items_count; i++)
{
log_printf (" items_subcount[%03d]. : %d",
i, ptr_bar->items_subcount[i]);
for (j = 0; j < ptr_bar->items_subcount[i]; j++)
{
log_printf (" items_array[%03d][%03d]: '%s' "
"(buffer: '%s', prefix: '%s', name: '%s', suffix: '%s')",
i, j,
ptr_bar->items_array[i][j],
ptr_bar->items_buffer[i][j],
ptr_bar->items_prefix[i][j],
ptr_bar->items_name[i][j],
ptr_bar->items_suffix[i][j]);
}
}
log_printf (" bar_window . . . . . . : 0x%lx", ptr_bar->bar_window);
log_printf (" bar_refresh_needed . . : %d", ptr_bar->bar_refresh_needed);
log_printf (" prev_bar . . . . . . . : 0x%lx", ptr_bar->prev_bar);
log_printf (" next_bar . . . . . . . : 0x%lx", ptr_bar->next_bar);
if (ptr_bar->bar_window)
gui_bar_window_print_log (ptr_bar->bar_window);
}
}
View Git Blame Copy Permalink