/*
* status.c: handles the status line updating, etc for IRCII
*
* Written By Michael Sandrof
*
* Copyright(c) 1990
*
* See the COPYRIGHT file, or do a HELP IRCII COPYRIGHT
*/
#include "irc.h"
static char cvsrevision[] = "$Id: status.c,v 1.1.1.1 2003/04/11 01:09:07 dan Exp $";
CVS_REVISION(status_c)
#include "struct.h"
#include "ircterm.h"
#include "status.h"
#include "server.h"
#include "vars.h"
#include "hook.h"
#include "input.h"
#include "commands.h"
#include "window.h"
#include "screen.h"
#include "mail.h"
#include "output.h"
#include "names.h"
#include "ircaux.h"
#include "misc.h"
#include "notify.h"
#include "hash2.h"
#include "cset.h"
#ifdef TRANSLATE
#include "translat.h"
#endif
#define MAIN_SOURCE
#include "modval.h"
#ifdef WANT_HEBREW
#include "hebrew.h"
#endif
#define MY_BUFFER 120
extern char *DCC_get_current_transfer (void);
extern long oper_kills;
extern long nick_collisions;
static char *convert_format (Window *, char *, int);
static char *status_nickname (Window *);
static char *status_query_nick (Window *);
static char *status_right_justify (Window *);
static char *status_chanop (Window *);
static char *status_channel (Window *);
static char *status_server (Window *);
static char *status_mode (Window *);
static char *status_umode (Window *);
static char *status_insert_mode (Window *);
static char *status_overwrite_mode (Window *);
static char *status_away (Window *);
static char *status_oper (Window *);
static char *status_users (Window *);
static char *status_user0s (Window *);
static char *status_user1s (Window *);
static char *status_user2s (Window *);
static char *status_user3s (Window *);
static char *status_user4s (Window *);
static char *status_user5s (Window *);
static char *status_user6s (Window *);
static char *status_user7s (Window *);
static char *status_user8s (Window *);
static char *status_user9s (Window *);
static char *status_user10s (Window *);
static char *status_user11s (Window *);
static char *status_user12s (Window *);
static char *status_user13s (Window *);
static char *status_user14s (Window *);
static char *status_user15s (Window *);
static char *status_user16s (Window *);
static char *status_user17s (Window *);
static char *status_user18s (Window *);
static char *status_user19s (Window *);
static char *status_user20s (Window *);
static char *status_user21s (Window *);
static char *status_user22s (Window *);
static char *status_user23s (Window *);
static char *status_user24s (Window *);
static char *status_user25s (Window *);
static char *status_user26s (Window *);
static char *status_user27s (Window *);
static char *status_user28s (Window *);
static char *status_user29s (Window *);
static char *status_user30s (Window *);
static char *status_user31s (Window *);
static char *status_user32s (Window *);
static char *status_user33s (Window *);
static char *status_user34s (Window *);
static char *status_user35s (Window *);
static char *status_user36s (Window *);
static char *status_user37s (Window *);
static char *status_user38s (Window *);
static char *status_user39s (Window *);
static char *status_lag (Window *);
static char *status_dcc (Window *);
static char *status_oper_kills (Window *);
static char *status_msgcount (Window *);
static char *status_hold (Window *);
static char *status_version (Window *);
static char *status_clock (Window *);
static char *status_hold_lines (Window *);
static char *status_window (Window *);
static char *status_mail (Window *);
static char *status_refnum (Window *);
static char *status_topic (Window *);
static char *status_null_function (Window *);
static char *status_notify_windows (Window *);
static char *convert_sub_format (char *, char, char *);
static char *status_voice (Window *);
static char *status_cpu_saver_mode (Window *);
static char *status_dcccount (Window *);
static char *status_cdcccount (Window *);
static char *status_position (Window *);
static char *status_lastjoin (Window *);
static char *status_userlist (Window *);
static char *status_shitlist (Window *);
static char *status_nethack (Window *);
static char *status_aop (Window *);
static char *status_bitch (Window *);
static char *status_newserver (Window *);
static char *status_scrollback (Window *);
static char *status_percent (Window *);
static char *status_windowspec (Window *);
static char *status_halfop (Window *);
static char *status_notifyusers(Window *);
#define cparse(format, str) convert_output_format(fget_string_var(format), "%s", str)
#if 1
/*
* This is how we store status line expandos.
*/
struct status_formats {
int map;
char key;
char *(*callback_function)(Window *);
char **format_var;
int format_set;
};
char *away_format = NULL,
*hold_lines_format = NULL,
*channel_format = NULL,
*notify_format = NULL,
*cpu_saver_format = NULL,
*kill_format = NULL,
*lag_format = NULL,
*mail_format = NULL,
*nick_format = NULL,
*query_format = NULL,
*server_format = NULL,
*clock_format = NULL,
*dcccount_format = NULL,
*cdcc_format = NULL,
*msgcount_format = NULL,
*umode_format = NULL,
*mode_format = NULL,
*topic_format = NULL,
*user_format = NULL;
/*
* This is the list of possible expandos. Note that you should not use
* the '{' character, as it would be confusing. It is already used for
* specifying the map.
*/
struct status_formats status_expandos[] = {
{ 0, 'A', status_away, NULL, STATUS_AWAY_WSET },
{ 0, 'B', status_hold_lines, NULL, STATUS_HOLD_LINES_WSET },
{ 0, 'C', status_channel, NULL, STATUS_CHANNEL_WSET },
{ 0, 'D', status_dcc, NULL, -1 },
{ 0, 'E', status_scrollback, NULL, -1 },
{ 0, 'F', status_notify_windows, NULL, STATUS_NOTIFY_WSET },
{ 0, 'H', status_hold, NULL, -1 },
{ 0, 'G', status_halfop, NULL, -1 },
{ 0, 'I', status_insert_mode, NULL, -1 },
{ 0, 'J', status_cpu_saver_mode, NULL, STATUS_CPU_SAVER_WSET },
{ 0, 'K', status_oper_kills, NULL, STATUS_OPER_KILLS_WSET },
{ 0, 'L', status_lag, NULL, STATUS_LAG_WSET },
{ 0, 'M', status_mail, NULL, STATUS_MAIL_WSET },
{ 0, 'N', status_nickname, NULL, STATUS_NICKNAME_WSET },
{ 0, 'O', status_overwrite_mode, NULL, -1 },
{ 0, 'P', status_position, NULL, -1 },
{ 0, 'Q', status_query_nick, NULL, STATUS_QUERY_WSET },
{ 0, 'R', status_refnum, NULL, -1 },
{ 0, 'S', status_server, NULL, STATUS_SERVER_WSET },
{ 0, 'T', status_clock, NULL, STATUS_CLOCK_WSET },
{ 0, 'U', status_user0s, NULL, -1 },
{ 0, 'V', status_version, NULL, -1 },
{ 0, 'W', status_window, NULL, -1 },
{ 0, 'X', status_user1s, NULL, -1 },
{ 0, 'Y', status_user2s, NULL, -1 },
{ 0, 'Z', status_user3s, NULL, -1 },
{ 0, '&', status_dcccount, NULL, STATUS_DCCCOUNT_WSET },
{ 0, '|', status_cdcccount, NULL, STATUS_CDCCCOUNT_WSET },
{ 0, '^', status_msgcount, NULL, STATUS_MSGCOUNT_WSET },
{ 0, '#', status_umode, NULL, STATUS_UMODE_WSET },
{ 0, '%', status_percent, NULL, -1 },
{ 0, '*', status_oper, NULL, -1 },
{ 0, '+', status_mode, NULL, STATUS_MODE_WSET },
{ 0, '.', status_windowspec, NULL, -1 },
{ 0, '=', status_voice, NULL, -1 },
{ 0, '>', status_right_justify, NULL, -1 },
{ 0, '-', status_topic, NULL, STATUS_TOPIC_WSET },
{ 0, '!', status_users, NULL, STATUS_USERS_WSET },
{ 0, '@', status_chanop, NULL, -1 },
{ 0, '0', status_user0s, NULL, -1 },
{ 0, '1', status_user1s, NULL, -1 },
{ 0, '2', status_user2s, NULL, -1 },
{ 0, '3', status_user3s, NULL, -1 },
{ 0, '4', status_user4s, NULL, -1 },
{ 0, '5', status_user5s, NULL, -1 },
{ 0, '6', status_user6s, NULL, -1 },
{ 0, '7', status_user7s, NULL, -1 },
{ 0, '8', status_user8s, NULL, -1 },
{ 0, '9', status_user9s, NULL, -1 },
{ 0, 'f', status_shitlist, NULL, -1 },
{ 0, 'a', status_aop, NULL, -1 },
{ 0, 'b', status_bitch, NULL, -1 },
{ 0, 'h', status_nethack, NULL, -1 },
{ 0, 'l', status_lastjoin, NULL, -1 },
{ 0, 'n', status_notifyusers, NULL, -1 },
{ 0, 's', status_newserver, NULL, -1 },
{ 0, 'u', status_userlist, NULL, -1 },
{ 1, '0', status_user10s, NULL, -1 },
{ 1, '1', status_user11s, NULL, -1 },
{ 1, '2', status_user12s, NULL, -1 },
{ 1, '3', status_user13s, NULL, -1 },
{ 1, '4', status_user14s, NULL, -1 },
{ 1, '5', status_user15s, NULL, -1 },
{ 1, '6', status_user16s, NULL, -1 },
{ 1, '7', status_user17s, NULL, -1 },
{ 1, '8', status_user18s, NULL, -1 },
{ 1, '9', status_user19s, NULL, -1 },
{ 2, '0', status_user20s, NULL, -1 },
{ 2, '1', status_user21s, NULL, -1 },
{ 2, '2', status_user22s, NULL, -1 },
{ 2, '3', status_user23s, NULL, -1 },
{ 2, '4', status_user24s, NULL, -1 },
{ 2, '5', status_user25s, NULL, -1 },
{ 2, '6', status_user26s, NULL, -1 },
{ 2, '7', status_user27s, NULL, -1 },
{ 2, '8', status_user28s, NULL, -1 },
{ 2, '9', status_user29s, NULL, -1 },
{ 3, '0', status_user30s, NULL, -1 },
{ 3, '1', status_user31s, NULL, -1 },
{ 3, '2', status_user32s, NULL, -1 },
{ 3, '3', status_user33s, NULL, -1 },
{ 3, '4', status_user34s, NULL, -1 },
{ 3, '5', status_user35s, NULL, -1 },
{ 3, '6', status_user36s, NULL, -1 },
{ 3, '7', status_user37s, NULL, -1 },
{ 3, '8', status_user38s, NULL, -1 },
{ 3, '9', status_user39s, NULL, -1 },
};
#define NUMBER_OF_EXPANDOS (sizeof(status_expandos) / sizeof(struct status_formats))
#endif
void *default_status_output_function = make_status;
/*
* convert_sub_format: This is used to convert the formats of the
* sub-portions of the status line to a format statement specially designed
* for that sub-portions. convert_sub_format looks for a single occurence of
* %c (where c is passed to the function). When found, it is replaced by "%s"
* for use is a sprintf. All other occurences of % followed by any other
* character are left unchanged. Only the first occurence of %c is
* converted, all subsequence occurences are left unchanged. This routine
* mallocs the returned string.
*/
static char * convert_sub_format(char *format, char c, char *padded)
{
char buffer[BIG_BUFFER_SIZE + 1];
static char bletch[] = "%% ";
char *ptr = NULL;
int dont_got_it = 1;
if (format == NULL)
return (NULL);
*buffer = (char) 0;
memset(buffer, 0, sizeof(buffer));
while (format)
{
#if 0
/wset status_mode +#%+%
#endif
if ((ptr = (char *) strchr(format, '%')) != NULL)
{
*ptr = (char) 0;
strmcat(buffer, format, BIG_BUFFER_SIZE);
*(ptr++) = '%';
if ((*ptr == c)/* && dont_got_it*/)
{
dont_got_it = 0;
if (*padded)
{
strmcat(buffer, "%", BIG_BUFFER_SIZE);
strmcat(buffer, padded, BIG_BUFFER_SIZE);
strmcat(buffer, "s", BIG_BUFFER_SIZE);
}
else
strmcat(buffer, "%s", BIG_BUFFER_SIZE);
}
else if (*ptr == '<')
{
char *s = ptr + 1;
while(*ptr && *ptr != '>') ptr++;
if (*ptr)
{
ptr++;
if (!*ptr)
continue;
else if (*ptr == c)
{
strmcat(buffer, "%", BIG_BUFFER_SIZE);
strmcat(buffer, s, (ptr - s));
strmcat(buffer, "s", BIG_BUFFER_SIZE);
}
}
}
else
{
bletch[2] = *ptr;
strmcat(buffer, bletch, BIG_BUFFER_SIZE);
if (!*ptr)
{
format = ptr;
continue;
}
}
ptr++;
}
else
strmcat(buffer, format, BIG_BUFFER_SIZE);
format = ptr;
}
malloc_strcpy(&ptr, buffer);
return (ptr);
}
static char *convert_format(Window *win, char *format, int k)
{
char buffer[BIG_BUFFER_SIZE + 1];
char padded[BIG_BUFFER_SIZE + 1];
int pos = 0;
int *cp;
int map;
char key;
int i;
cp = &win->func_cnt[k];
while (*format && pos < BIG_BUFFER_SIZE - 4)
{
*padded = 0;
if (*format != '%')
{
buffer[pos++] = *format++;
continue;
}
/* Its a % */
map = 0;
/* Find the map, if neccesary */
if (*++format == '{')
{
char *endptr;
format++;
map = strtoul(format, &endptr, 10);
if (*endptr != '}')
{
/* Unrecognized */
continue;
}
format = endptr + 1;
}
else if (*format == '<')
{
char *p = padded;
format++;
while(*format && *format != '>')
*p++ = *format++;
*p = 0;
format++;
}
key = *format++;
/* Choke once we get to the maximum number of expandos */
if (*cp >= MAX_FUNCTIONS)
continue;
for (i = 0; i < NUMBER_OF_EXPANDOS; i++)
{
char **s = NULL;
if (status_expandos[i].map != map ||
status_expandos[i].key != key)
continue;
if (status_expandos[i].format_set != -1)
{
s = get_wset_format_var_address(win->wset, status_expandos[i].format_set);
if (s)
new_free(s);
if (s)
*s = convert_sub_format(get_wset_string_var(win->wset, status_expandos[i].format_set), key, padded);
}
buffer[pos++] = '%';
buffer[pos++] = 's';
win->status_func[k][(*cp)++] =
status_expandos[i].callback_function;
break;
}
}
win->func_cnt[k] = *cp;
buffer[pos] = 0;
return m_strdup(buffer);
}
void fix_status_buffer(Window *win, char *buffer, int in_status)
{
unsigned char rhs_buffer[3*BIG_BUFFER_SIZE + 1];
unsigned char lhs_buffer[3*BIG_BUFFER_SIZE + 1];
unsigned char lhs_fillchar[6],
rhs_fillchar[6],
*fillchar = lhs_fillchar,
*lhp = lhs_buffer,
*rhp = rhs_buffer,
*cp,
*start_rhs = 0,
*str = NULL, *ptr = NULL;
int in_rhs = 0,
pr_lhs = 0,
pr_rhs = 0,
*prc = &pr_lhs;
lhs_buffer[0] = 0;
rhs_buffer[0] = 0;
if (!buffer || !*buffer)
return;
if (get_int_var(STATUS_DOES_EXPANDOS_VAR))
{
int af = 0;
char *stuff;
Window *old = current_window;
current_window = win;
stuff = expand_alias(buffer, empty_string, &af, NULL);
strmcpy(buffer, stuff, BIG_BUFFER_SIZE);
new_free(&stuff);
current_window = old;
}
/*
* This converts away any ansi codes in the status line
* in accordance with the current settings. This leaves us
* with nothing but logical characters, which are then easy
* to count. :-)
*/
str = strip_ansi(buffer);
/*
* Count out the characters.
* Walk the entire string, looking for nonprintable
* characters. We count all the printable characters
* on both sides of the %> tag.
*/
ptr = str;
cp = lhp;
lhs_buffer[0] = rhs_buffer[0] = 0;
while (*ptr)
{
/*
* The FIRST such %> tag is used.
* Using multiple %>s is bogus.
*/
if (*ptr == '\f' && start_rhs == NULL)
{
ptr++;
start_rhs = ptr;
fillchar = rhs_fillchar;
in_rhs = 1;
*cp = 0;
cp = rhp;
prc = &pr_rhs;
}
/*
* Skip over color attributes if we're not
* doing color.
*/
else if (*ptr == '\003')
{
const u_char *end = skip_ctl_c_seq(ptr, NULL, NULL, 0);
while (ptr < end)
*cp++ = *ptr++;
}
/*
* If we have a ROM character code here, we need to
* copy it to the output buffer, as well as the fill
* character, and increment the printable counter by
* only 1.
*/
else if (*ptr == ROM_CHAR)
{
fillchar[0] = *cp++ = *ptr++;
fillchar[1] = *cp++ = *ptr++;
fillchar[2] = *cp++ = *ptr++;
fillchar[3] = *cp++ = *ptr++;
fillchar[4] = 0;
*prc += 1;
}
/*
* Is it NOT a printable character?
*/
else if ((*ptr == REV_TOG) || (*ptr == UND_TOG) ||
(*ptr == ALL_OFF) || (*ptr == BOLD_TOG) ||
(*ptr == BLINK_TOG))
*cp++ = *ptr++;
#if 0
else if (*ptr == 9) /* TAB */
{
fillchar[0] = ' ';
fillchar[1] = 0;
do
*cp++ = ' ';
while (++(*prc) % 8);
ptr++;
}
#endif
/*
* So it is a printable character.
* Or maybe its a tab. ;-)
*/
else
{
*prc += 1;
fillchar[0] = *cp++ = *ptr++;
fillchar[1] = 0;
}
/*
* Dont allow more than CO printable characters
*/
if (pr_lhs + pr_rhs >= win->screen->co)
{
*cp = 0;
break;
}
}
*cp = 0;
#if 0
/* What will we be filling with? */
if (get_int_var(STATUS_NO_REPEAT_VAR))
{
lhs_fillchar[0] = ' ';
lhs_fillchar[1] = 0;
rhs_fillchar[0] = ' ';
rhs_fillchar[1] = 0;
}
/*
* Now if we have a rhs, then we have to adjust it.
*/
if (start_rhs)
{
int numf = 0;
numf = win->screen->co - pr_lhs - pr_rhs -1;
while (numf-- >= 0)
strmcat(lhs_buffer, lhs_fillchar,
BIG_BUFFER_SIZE);
}
/*
* No rhs? If the user wants us to pad it out, do so.
*/
else if (get_int_var(FULL_STATUS_LINE_VAR))
{
int chars = win->screen->co - pr_lhs - 1;
while (chars-- >= 0)
strmcat(lhs_buffer, lhs_fillchar,
BIG_BUFFER_SIZE);
}
#endif
strcpy(buffer, lhs_buffer);
strmcat(buffer, rhs_buffer, BIG_BUFFER_SIZE);
new_free(&str);
}
char *stat_convert_format(Window *win, char *form)
{
unsigned char buffer[2 * BIG_BUFFER_SIZE + 1];
char *ptr = form;
int pos = 0;
int map;
char key;
int i;
if (!form || !*form)
return m_strdup(empty_string);
*buffer = 0;
while (*ptr && pos < (2 * BIG_BUFFER_SIZE) - 4)
{
if (*ptr != '%')
{
buffer[pos++] = *ptr++;
continue;
}
/* Its a % */
map = 0;
/* Find the map, if neccesary */
if (*++ptr == '{')
{
char *endptr;
ptr++;
map = strtoul(ptr, &endptr, 10);
if (*endptr != '}')
{
/* Unrecognized */
continue;
}
ptr = endptr + 1;
}
key = *ptr++;
/* Choke once we get to the maximum number of expandos */
for (i = 0; i < NUMBER_OF_EXPANDOS; i++)
{
if (status_expandos[i].map != map || status_expandos[i].key != key)
continue;
strmcat(buffer, (status_expandos[i].callback_function)(win), BIG_BUFFER_SIZE);
pos = strlen(buffer);
break;
}
}
buffer[pos] = 0;
fix_status_buffer(win, buffer, 0);
return m_strdup(buffer);
}
void BX_build_status(Window *win, char *format, int unused)
{
int i, k;
char *f = NULL;
int ofs = from_server;
if (!win)
return;
if (win->server > -1)
from_server = win->server;
for (k = 0; k < 3; k++)
{
if (!win->wset)
continue;
new_free(&(win->wset->status_format[k]));
win->func_cnt[k] = 0;
switch(k)
{
case 0:
f = win->wset->format_status[1];
break;
case 1:
f = win->wset->format_status[2];
break;
case 2:
f = win->wset->format_status[3];
break;
}
if (f)
win->wset->status_format[k] = convert_format(win, f, k);
for (i = win->func_cnt[k]; i < MAX_FUNCTIONS; i++)
win->status_func[k][i] = status_null_function;
}
update_all_status(win, NULL, 0);
from_server = ofs;
}
void make_status(Window *win)
{
u_char buffer [BIG_BUFFER_SIZE + 1];
u_char lhs_buffer [BIG_BUFFER_SIZE + 1];
u_char rhs_buffer [BIG_BUFFER_SIZE + 1];
char *func_value[MAX_FUNCTIONS+10] = {NULL};
u_char *ptr;
int len = 1,
status_line,
ansi = get_int_var(DISPLAY_ANSI_VAR);
/* The second status line is only displayed in the bottom window
* and should always be displayed, no matter what SHOW_STATUS_ALL
* is set to - krys
*/
for (status_line = 0 ; status_line < 1+win->double_status + win->status_lines; status_line++)
{
u_char lhs_fillchar[6],
rhs_fillchar[6],
*fillchar = lhs_fillchar,
*lhp = lhs_buffer,
*rhp = rhs_buffer,
*cp,
*start_rhs = 0,
*str;
int in_rhs = 0,
pr_lhs = 0,
pr_rhs = 0,
line = status_line,
*prc = &pr_lhs,
i;
fillchar[0] = fillchar[1] = 0;
if (!win->wset || !win->wset->status_format[line])
continue;
for (i = 0; i < MAX_FUNCTIONS; i++)
func_value[i] = (win->status_func[line][i]) (win);
len = 1;
if (get_int_var(REVERSE_STATUS_VAR))
buffer[0] = get_int_var(REVERSE_STATUS_VAR) ? REV_TOG : ' ';
else
len = 0;
str = &buffer[len];
snprintf(str, BIG_BUFFER_SIZE - 1,
win->wset->status_format[line],
func_value[0], func_value[1], func_value[2],
func_value[3], func_value[4], func_value[5],
func_value[6], func_value[7], func_value[8],
func_value[9], func_value[10], func_value[11],
func_value[12], func_value[13], func_value[14],
func_value[15], func_value[16], func_value[17],
func_value[18], func_value[19], func_value[20],
func_value[21], func_value[22], func_value[23],
func_value[24], func_value[25], func_value[26],
func_value[27], func_value[28], func_value[29],
func_value[30], func_value[31],func_value[32],
func_value[33], func_value[34],func_value[35],
func_value[36], func_value[37],func_value[38]);
/* Patched 26-Mar-93 by Aiken
* make_window now right-justifies everything
* after a %>
* it's also more efficient.
*/
/*
* If the user wants us to, pass the status bar through the
* expander to pick any variables/function calls.
* This is horribly expensive, but what do i care if you
* want to waste cpu cycles? ;-)
*/
if (get_int_var(STATUS_DOES_EXPANDOS_VAR))
{
int af = 0;
str = expand_alias(buffer, empty_string, &af, NULL);
strmcpy(buffer, str, BIG_BUFFER_SIZE);
new_free(&str);
}
/*
* This converts away any ansi codes in the status line
* in accordance with the current settings. This leaves us
* with nothing but logical characters, which are then easy
* to count. :-)
*/
str = strip_ansi(buffer);
/*
* Count out the characters.
* Walk the entire string, looking for nonprintable
* characters. We count all the printable characters
* on both sides of the %> tag.
*/
ptr = str;
cp = lhp;
lhs_buffer[0] = rhs_buffer[0] = 0;
while (*ptr)
{
/*
* The FIRST such %> tag is used.
* Using multiple %>s is bogus.
*/
if (*ptr == '\f' && start_rhs == NULL)
{
ptr++;
start_rhs = ptr;
fillchar = rhs_fillchar;
in_rhs = 1;
*cp = 0;
cp = rhp;
prc = &pr_rhs;
}
/*
* Skip over color attributes if we're not
* doing color.
*/
else if (*ptr == '\003')
{
const u_char *end = skip_ctl_c_seq(ptr, NULL, NULL, 0);
while (ptr < end)
*cp++ = *ptr++;
}
/*
* If we have a ROM character code here, we need to
* copy it to the output buffer, as well as the fill
* character, and increment the printable counter by
* only 1.
*/
else if (*ptr == ROM_CHAR)
{
fillchar[0] = *cp++ = *ptr++;
fillchar[1] = *cp++ = *ptr++;
fillchar[2] = *cp++ = *ptr++;
fillchar[3] = *cp++ = *ptr++;
fillchar[4] = 0;
*prc += 1;
}
/*
* Is it NOT a printable character?
*/
else if ((*ptr == REV_TOG) || (*ptr == UND_TOG) ||
(*ptr == ALL_OFF) || (*ptr == BOLD_TOG) ||
(*ptr == BLINK_TOG))
*cp++ = *ptr++;
#if 0
else if (*ptr == 9) /* TAB */
{
fillchar[0] = ' ';
fillchar[1] = 0;
do
*cp++ = ' ';
while (++(*prc) % 8);
ptr++;
}
#endif
/*
* So it is a printable character.
* Or maybe its a tab. ;-)
*/
else
{
*prc += 1;
fillchar[0] = *cp++ = *ptr++;
fillchar[1] = 0;
}
/*
* Dont allow more than CO printable characters
*/
if (pr_lhs + pr_rhs >= win->screen->co)
{
*cp = 0;
break;
}
}
*cp = 0;
/* What will we be filling with? */
if (get_int_var(STATUS_NO_REPEAT_VAR))
{
lhs_fillchar[0] = ' ';
lhs_fillchar[1] = 0;
rhs_fillchar[0] = ' ';
rhs_fillchar[1] = 0;
}
/*
* Now if we have a rhs, then we have to adjust it.
*/
if (start_rhs)
{
int numf = 0;
numf = win->screen->co - pr_lhs - pr_rhs -1;
while (numf-- >= 0)
strmcat(lhs_buffer, lhs_fillchar,
BIG_BUFFER_SIZE);
}
/*
* No rhs? If the user wants us to pad it out, do so.
*/
else if (get_int_var(FULL_STATUS_LINE_VAR))
{
int chars = win->screen->co - pr_lhs - 1;
while (chars-- >= 0)
strmcat(lhs_buffer, lhs_fillchar,
BIG_BUFFER_SIZE);
}
strcpy(buffer, lhs_buffer);
strmcat(buffer, rhs_buffer, BIG_BUFFER_SIZE);
strmcat(buffer, ALL_OFF_STR, BIG_BUFFER_SIZE);
new_free(&str);
do_hook(STATUS_UPDATE_LIST, "%d %d %s",
win->refnum,
status_line,
buffer);
if (dumb_mode)
{
/* lets see what happens here */
continue;
}
if (!win->wset->status_line[status_line] ||
strcmp(buffer, win->wset->status_line[status_line]))
{
unsigned char *st = NULL;
malloc_strcpy(&win->wset->status_line[status_line], buffer);
output_screen = win->screen;
st = cparse((line==3)?FORMAT_STATUS3_FSET:(line==2)?FORMAT_STATUS2_FSET:(line==1)?FORMAT_STATUS1_FSET:FORMAT_STATUS_FSET, buffer);
if (!ansi)
st = stripansicodes(st);
if (win->status_lines && (line == win->double_status+win->status_lines) && win->status_split)
term_move_cursor(0,win->top);
else if (win->status_lines && !win->status_split)
term_move_cursor(0,win->bottom+status_line-win->status_lines);
else
term_move_cursor(0,win->bottom+status_line);
output_line(st);
cursor_in_display(win);
term_bold_off();
}
}
cursor_to_input();
}
/* Some useful macros */
/*
* This is used to get the current window on a window's screen
*/
#define CURRENT_WINDOW window->screen->current_window
/*
* This tests to see if the window IS the current window on its screen
*/
#define IS_CURRENT_WINDOW (window->screen->current_window == window)
/*
* This tests to see if all expandoes are to appear in all status bars
*/
#define SHOW_ALL_WINDOWS (get_int_var(SHOW_STATUS_ALL_VAR))
/*
* "Current-type" window expandoes occur only on the current window for a
* screen. However, if /set show_status_all is on, then ALL windows act as
* "Current-type" windows.
*/
#define DISPLAY_ON_WINDOW (IS_CURRENT_WINDOW || SHOW_ALL_WINDOWS)
#define RETURN_EMPTY return empty_string
static char *status_nickname(Window *window)
{
static char my_buffer[MY_BUFFER/2+1];
snprintf(my_buffer, MY_BUFFER/2, window->wset->nick_format, get_server_nickname(window->server));
return my_buffer;
}
static char *status_server(Window *window)
{
char *name;
static char my_buffer[MY_BUFFER+1];
if (connected_to_server)
{
if (window->server != -1)
{
if (window->wset->server_format)
{
if (!(name = get_server_itsname(window->server)))
name = get_server_name(window->server);
snprintf(my_buffer, MY_BUFFER, window->wset->server_format, name);
}
else
RETURN_EMPTY;
}
else
strcpy(my_buffer, " No Server");
}
else
RETURN_EMPTY;
return my_buffer;
}
static char *status_query_nick(Window *window)
{
static char my_buffer[BIG_BUFFER_SIZE+1];
if (window->query_nick && window->wset->query_format)
{
snprintf(my_buffer, BIG_BUFFER_SIZE, window->wset->query_format, window->query_nick);
return my_buffer;
}
else
RETURN_EMPTY;
}
static char *status_right_justify(Window *window)
{
static char my_buffer[] = "\f";
return my_buffer;
}
static char *status_notify_windows(Window *window)
{
int doneone = 0;
char buf2[MY_BUFFER+2];
static char my_buffer[MY_BUFFER/2+1];
if (get_int_var(SHOW_STATUS_ALL_VAR) || window == window->screen->current_window)
{
*buf2='\0';
window = NULL;
while ((traverse_all_windows(&window)))
{
if (window->miscflags & WINDOW_NOTIFIED)
{
if (doneone++)
strmcat(buf2, ",", MY_BUFFER/2);
strmcat(buf2, ltoa(window->refnum), MY_BUFFER/2);
}
}
}
if (doneone && window->wset->notify_format)
{
snprintf(my_buffer, MY_BUFFER/2, window->wset->notify_format, buf2);
return (my_buffer);
}
RETURN_EMPTY;
}
static char *status_clock(Window *window)
{
static char my_buf[MY_BUFFER+1];
if ((get_int_var(CLOCK_VAR) && window->wset->clock_format) &&
(get_int_var(SHOW_STATUS_ALL_VAR) ||
(window == window->screen->current_window)))
snprintf(my_buf, MY_BUFFER, window->wset->clock_format, update_clock(GET_TIME));
else
RETURN_EMPTY;
return my_buf;
}
static char *status_mode(Window *window)
{
char *mode = NULL;
static char my_buffer[MY_BUFFER+1];
if (window->current_channel)
{
mode = get_channel_mode(window->current_channel,window->server);
if (mode && *mode && window->wset->mode_format)
{
if (get_int_var(STATUS_DOES_EXPANDOS_VAR))
{
char *mode2 = alloca(strlen(mode) * 2 + 1);
double_quote(mode, "$", mode2);
mode = mode2;
}
snprintf(my_buffer, MY_BUFFER, window->wset->mode_format, mode);
}
else
RETURN_EMPTY;
} else
RETURN_EMPTY;
return my_buffer;
}
static char *status_umode(Window *window)
{
char localbuf[MY_BUFFER+1];
static char my_buffer[MY_BUFFER/2+1];
if ((connected_to_server) && !get_int_var(SHOW_STATUS_ALL_VAR)
&& (window->screen->current_window != window))
*localbuf = 0;
else {
if (window->server > -1)
strmcpy(localbuf, get_umode(window->server), MY_BUFFER);
else
*localbuf = 0;
}
if (*localbuf && window->wset->umode_format)
snprintf(my_buffer, MY_BUFFER/2, window->wset->umode_format, localbuf);
else
RETURN_EMPTY;
return my_buffer;
}
static char *status_chanop(Window *window)
{
char *text;
if (window->current_channel && get_channel_oper(window->current_channel, window->server) &&
(text = get_wset_string_var(window->wset, STATUS_CHANOP_WSET)))
return (text);
else
RETURN_EMPTY;
}
static char *status_halfop(Window *window)
{
char *text;
if (window->current_channel && get_channel_halfop(window->current_channel, window->server) &&
(text = get_wset_string_var(window->wset, STATUS_HALFOP_WSET)))
return (text);
else
RETURN_EMPTY;
}
static char *status_hold_lines(Window *window)
{
int num;
static char my_buffer[MY_BUFFER/2+1];
if ((num = (window->lines_held /10) * 10))
{
snprintf(my_buffer, MY_BUFFER/2, window->wset->hold_lines_format, ltoa(num));
return(my_buffer);
}
RETURN_EMPTY;
}
static char *status_msgcount(Window *window)
{
static char my_buffer[MY_BUFFER/2+1];
if (get_int_var(MSGCOUNT_VAR) && window->wset->msgcount_format)
{
snprintf(my_buffer, MY_BUFFER/2, window->wset->msgcount_format, ltoa(get_int_var(MSGCOUNT_VAR)));
return my_buffer;
}
RETURN_EMPTY;
}
static char *status_channel(Window *window)
{
char channel[IRCD_BUFFER_SIZE + 1];
static char my_buffer[IRCD_BUFFER_SIZE + 1];
if (window->current_channel/* && chan_is_connected(s, window->server)*/)
{
extern const int MODE_PRIVATE, MODE_SECRET;
int num;
if (get_int_var(HIDE_PRIVATE_CHANNELS_VAR) &&
is_channel_mode(window->current_channel,
MODE_PRIVATE | MODE_SECRET,
window->server))
strmcpy(channel, "*private*", IRCD_BUFFER_SIZE);
else
strmcpy(channel, window->current_channel, IRCD_BUFFER_SIZE);
#ifdef WANT_HEBREW
if (get_int_var(HEBREW_TOGGLE_VAR))
hebrew_process((char *)&channel);
#endif
if ((num = get_int_var(CHANNEL_NAME_WIDTH_VAR)) &&
((int) strlen(channel) > num))
channel[num] = (char) 0;
snprintf(my_buffer, IRCD_BUFFER_SIZE, window->wset->channel_format, channel);
return my_buffer;
}
RETURN_EMPTY;
}
static char *status_mail(Window *window)
{
char *number;
static char my_buffer[MY_BUFFER/2+1];
if (window && (get_int_var(MAIL_VAR) && (number = check_mail()) && window->wset->mail_format) &&
(get_int_var(SHOW_STATUS_ALL_VAR) ||
(window == window->screen->current_window)))
{
snprintf(my_buffer, MY_BUFFER/2, window->wset->mail_format, number);
return my_buffer;
}
RETURN_EMPTY;
}
static char *status_insert_mode(Window *window)
{
char *text;
if (get_int_var(INSERT_MODE_VAR) && (get_int_var(SHOW_STATUS_ALL_VAR)
|| (window->screen->current_window == window)))
if ((text = get_string_var(STATUS_INSERT_VAR)))
return text;
RETURN_EMPTY;
}
static char *status_overwrite_mode(Window *window)
{
char *text;
if (!get_int_var(INSERT_MODE_VAR) && (get_int_var(SHOW_STATUS_ALL_VAR)
|| (window->screen->current_window == window)))
{
if ((text = get_string_var(STATUS_OVERWRITE_VAR)))
return text;
}
RETURN_EMPTY;
}
static char *status_away(Window *window)
{
static char my_buffer[MY_BUFFER+1];
if (window && connected_to_server && !get_int_var(SHOW_STATUS_ALL_VAR)
&& (window->screen->current_window != window))
RETURN_EMPTY;
else if (window)
{
if (window->server != -1 && get_server_away(window->server))
{
snprintf(my_buffer, MY_BUFFER, window->wset->away_format, ltoa(get_int_var(MSGCOUNT_VAR)));
return my_buffer;
}
else
RETURN_EMPTY;
}
RETURN_EMPTY;
}
/*
* This is a generic status_userX variable. All of these go to the
* current-type window, although i think they should go to all windows.
*/
#define STATUS_VAR(x) \
static char *status_user ## x ## s (Window *window) \
{ \
char *text; \
\
if ((text = get_wset_string_var(window->wset, STATUS_USER ## x ## _WSET)) && \
DISPLAY_ON_WINDOW) \
return text; \
else \
RETURN_EMPTY; \
}
STATUS_VAR(0)
STATUS_VAR(1)
STATUS_VAR(2)
STATUS_VAR(3)
STATUS_VAR(4)
STATUS_VAR(5)
STATUS_VAR(6)
STATUS_VAR(7)
STATUS_VAR(8)
STATUS_VAR(9)
STATUS_VAR(10)
STATUS_VAR(11)
STATUS_VAR(12)
STATUS_VAR(13)
STATUS_VAR(14)
STATUS_VAR(15)
STATUS_VAR(16)
STATUS_VAR(17)
STATUS_VAR(18)
STATUS_VAR(19)
STATUS_VAR(20)
STATUS_VAR(21)
STATUS_VAR(22)
STATUS_VAR(23)
STATUS_VAR(24)
STATUS_VAR(25)
STATUS_VAR(26)
STATUS_VAR(27)
STATUS_VAR(28)
STATUS_VAR(29)
STATUS_VAR(30)
STATUS_VAR(31)
STATUS_VAR(32)
STATUS_VAR(33)
STATUS_VAR(34)
STATUS_VAR(35)
STATUS_VAR(36)
STATUS_VAR(37)
STATUS_VAR(38)
STATUS_VAR(39)
static char *status_hold(Window *window)
{
char *text;
if (window->holding_something && (text = get_wset_string_var(window->wset, STATUS_HOLD_WSET)))
return(text);
RETURN_EMPTY;
}
static char *status_lag (Window *window)
{
static char my_buffer[MY_BUFFER/2+1];
if ((window->server > -1) && window->wset->lag_format)
{
if (get_server_lag(window->server) > -1)
{
char p[40];
sprintf(p, "%2d",get_server_lag(window->server));
snprintf(my_buffer,MY_BUFFER/2, window->wset->lag_format, p);
}
else
snprintf(my_buffer, MY_BUFFER/2, window->wset->lag_format, "??");
return(my_buffer);
}
RETURN_EMPTY;
}
static char *status_topic (Window *window)
{
static char my_buffer[MY_BUFFER+41];
if (window && window->current_channel && window->wset->topic_format)
{
ChannelList *chan;
if ((chan = lookup_channel(window->current_channel, window->server, 0)))
{
char *t;
if ((t = chan->topic))
{
char *t2 = alloca(strlen(t) * 2 + 1 );
if (get_int_var(STATUS_DOES_EXPANDOS_VAR))
double_quote(t, "()[]$\"", t2);
else
strcpy(t2, t);
snprintf(my_buffer, MY_BUFFER, window->wset->topic_format, stripansicodes(t2));
}
else
strmcpy(my_buffer, "No Topic", MY_BUFFER);
return(my_buffer);
}
}
RETURN_EMPTY;
}
static char *status_oper(Window *window)
{
char *text;
if (get_server_operator(window->server) &&
(text = get_string_var(STATUS_OPER_VAR)) &&
(get_int_var(SHOW_STATUS_ALL_VAR) ||
connected_to_server ||
(window->screen->current_window == window)))
return(text);
RETURN_EMPTY;
}
static char *status_voice(Window *window)
{
char *text;
if (window->current_channel &&
get_channel_voice(window->current_channel, window->server) &&
!get_channel_oper(window->current_channel, window->server) &&
(text = get_wset_string_var(window->wset, STATUS_VOICE_WSET)))
return text;
RETURN_EMPTY;
}
static char *status_window(Window *window)
{
char *text;
if ((number_of_windows_on_screen(window) > 1) && (window->screen->current_window == window) &&
(text = get_wset_string_var(window->wset, STATUS_WINDOW_WSET)))
return(text);
RETURN_EMPTY;
}
static char *status_refnum(Window *window)
{
static char my_buffer[MY_BUFFER/3+1];
strmcpy(my_buffer, window->name ? window->name : ltoa(window->refnum), MY_BUFFER/3);
return (my_buffer);
}
static char *status_version(Window *window)
{
if ((connected_to_server) && !get_int_var(SHOW_STATUS_ALL_VAR)
&& (window->screen->current_window != window))
return(empty_string);
return ((char *)irc_version);
}
static char * status_oper_kills (Window *window)
{
static char my_buffer[MY_BUFFER+1];
if (window->wset->kills_format && (nick_collisions || oper_kills))
{
char tmp[30];
snprintf(tmp, 29, "%ld", nick_collisions);
snprintf(my_buffer, MY_BUFFER, window->wset->kills_format, tmp, ltoa(oper_kills));
return my_buffer;
}
RETURN_EMPTY;
}
static char *status_dcccount (Window *window)
{
extern int get_count_stat, send_count_stat;
static char my_buffer[2 * MY_BUFFER+1];
if (window->wset->dcccount_format && send_count_stat)
{
char tmp[30];
strcpy(tmp, ltoa(send_count_stat));
snprintf(my_buffer, 2 * MY_BUFFER, window->wset->dcccount_format, ltoa(get_count_stat), tmp);
return my_buffer;
}
RETURN_EMPTY;
}
static char *status_cdcccount (Window *window)
{
#ifdef WANT_CDCC
extern int cdcc_numpacks, send_numpacks;
static char my_buffer[2 * MY_BUFFER+1];
if (window->wset->cdcc_format && cdcc_numpacks)
{
char tmp[30];
strcpy(tmp, ltoa(cdcc_numpacks));
snprintf(my_buffer, 2 * MY_BUFFER, window->wset->cdcc_format, ltoa(send_numpacks), tmp);
return my_buffer;
}
#endif
RETURN_EMPTY;
}
static char *status_cpu_saver_mode (Window *window)
{
static char my_buffer[MY_BUFFER/2+1];
if (cpu_saver && window->wset->cpu_saver_format)
{
snprintf(my_buffer, MY_BUFFER/2, window->wset->cpu_saver_format, "cpu");
return my_buffer;
}
RETURN_EMPTY;
}
static char * status_users (Window *window)
{
static char my_buffer[MY_BUFFER * 2 + 1];
ChannelList *chan;
NickList *nick;
int serv = window->server;
if (window->server != -1 && window->wset->status_users_format)
{
if ((chan = prepare_command(&serv, NULL, 3)))
{
int ops = 0, nonops = 0, voice = 0, ircop = 0, friends = 0;
char buff[40], buff1[40], buff2[40], buff3[40], buff4[40];
for (nick = next_nicklist(chan, NULL); nick; nick = next_nicklist(chan, nick))
{
if (nick_isop(nick))
ops++;
else
nonops++;
if (nick_isvoice(nick))
voice++;
if (nick_isircop(nick))
ircop++;
if (nick->userlist)
friends++;
}
strcpy(buff, ltoa(ops));
strcpy(buff1, ltoa(nonops));
strcpy(buff2,ltoa(ircop));
strcpy(buff3, ltoa(voice));
strcpy(buff4, ltoa(friends));
snprintf(my_buffer, MY_BUFFER*2, window->wset->status_users_format, buff, buff1, buff2, buff3, buff4);
return my_buffer;
}
}
RETURN_EMPTY;
}
static char *status_null_function(Window *window)
{
RETURN_EMPTY;
}
static char *status_dcc(Window *window)
{
if (window->window_level & LOG_DCC || !window->window_level)
return(DCC_get_current_transfer());
RETURN_EMPTY;
}
static char *status_position (Window *window)
{
static char my_buffer[MY_BUFFER/2+1];
snprintf(my_buffer, MY_BUFFER/2, "(%d-%d)", window->lines_scrolled_back,
window->distance_from_display);
return my_buffer;
}
static char *status_userlist (Window *window)
{
ChannelList *chan;
int serv = window->server;
static char my_buffer[3] = "\0";
if (window->server != -1)
{
if ((chan = prepare_command(&serv, NULL, 3)))
{
my_buffer[0] = chan->csets->set_userlist ? 'U':'u';
return my_buffer;
}
}
RETURN_EMPTY;
}
static char *status_shitlist (Window *window)
{
ChannelList *chan;
int serv = window->server;
static char my_buffer[3] = "\0";
if (window->server != -1)
{
if ((chan = prepare_command(&serv, NULL, 3)))
{
my_buffer[0] = chan->csets->set_shitlist ? 'S':'s';
return my_buffer;
}
}
RETURN_EMPTY;
}
static char *status_nethack (Window *window)
{
ChannelList *chan;
int serv = window->server;
static char my_buffer[3] = "\0";
if (window->server != -1)
{
if ((chan = prepare_command(&serv, NULL, 3)))
{
my_buffer[0] = chan->csets->set_hacking ? 'H':'h';
return my_buffer;
}
}
RETURN_EMPTY;
}
static char *status_aop (Window *window)
{
ChannelList *chan;
int serv = window->server;
static char my_buffer[3] = "\0";
if (window->server != -1)
{
if ((chan = prepare_command(&serv, NULL, 3)))
{
my_buffer[0] = chan->csets->set_aop ? 'A':'a';
return my_buffer;
}
}
RETURN_EMPTY;
}
static char *status_bitch (Window *window)
{
ChannelList *chan;
int serv = window->server;
static char my_buffer[3] = "\0";
if (window->server != -1)
{
if ((chan = prepare_command(&serv, NULL, 3)))
{
my_buffer[0] = chan->csets->bitch_mode ? 'B':'b';
return my_buffer;
}
}
RETURN_EMPTY;
}
static char *status_notifyusers (Window *window)
{
int serv = window->server;
static char my_buffer[40] = "\0";
int on, off;
notify_count(serv, &on, &off);
sprintf(my_buffer, "%d %d", on, off);
return my_buffer;
}
static char *status_lastjoin (Window *window)
{
if (window->server != -1)
{
if (joined_nick)
return joined_nick;
}
RETURN_EMPTY;
}
static char *status_newserver (Window *window)
{
extern char *ov_server(int);
if (window->server != -1)
return ov_server(window->server);
RETURN_EMPTY;
}
static char *status_scrollback(Window *win)
{
char *stuff;
if (win->scrollback_point &&
(stuff = get_wset_string_var(win->wset, STATUS_SCROLLBACK_WSET)))
return stuff;
else
RETURN_EMPTY;
}
static char *status_windowspec (Window *window)
{
static char my_buffer[81];
if (window->wset->window_special_format)
strmcpy(my_buffer, window->wset->window_special_format, 80);
else
*my_buffer = 0;
return my_buffer;
}
static char *status_percent (Window *window)
{
static char percent[] = "%";
return percent;
}
syntax highlighted by Code2HTML, v. 0.9.1