/* * status.c: handles the status line updating, etc for IRCII * * Written By Michael Sandrof * * Copyright (c) 1990 Michael Sandrof. * Copyright (c) 1991, 1992 Troy Rollo. * Copyright (c) 1992-2003 Matthew R. Green. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $Id: status.c,v 1.32 2006/04/30 14:15:43 f Exp $ */ #include "irc.h" #include "ircterm.h" #include "status.h" #include "server.h" #include "vars.h" #include "hook.h" #include "input.h" #include "edit.h" #include "window.h" #include "screen.h" #include "mail.h" #include "output.h" #include "names.h" #include "ircaux.h" #include "translat.h" /**************************** PATCHED by Flier ******************************/ #include "ctcp.h" #include "myvars.h" #ifdef WANTANSI extern int vt100Decode _((char)); #endif extern int CheckChannel _((char *, char *)); extern void StripAnsi _((char *, char *, int)); extern int CheckServer _((int)); extern time_t start_time; /****************************************************************************/ static char *convert_format _((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 *)); /**************************** PATCHED by Flier ******************************/ /*static char *status_user0 _((Window *)); static char *status_user1 _((Window *)); static char *status_user2 _((Window *)); static char *status_user3 _((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_null_function _((Window *)); static char *status_notify_windows _((Window *)); static char *status_group _((Window *)); static void alarm_switch _((int)); static char *convert_sub_format _((char *, int)); static void make_status_one _((Window *, int, int)); /**************************** PATCHED by Flier ******************************/ static char *status_user00 _((Window *)); static char *status_user01 _((Window *)); static char *status_user02 _((Window *)); static char *status_user03 _((Window *)); #ifndef LITE static char *status_user04 _((Window *)); static char *status_user05 _((Window *)); static char *status_user06 _((Window *)); static char *status_user07 _((Window *)); static char *status_user08 _((Window *)); static char *status_user09 _((Window *)); #endif static char *status_uptime _((Window *)); static char *status_lag _((Window *)); static char *status_lastjoin _((Window *)); static char *status_dcc _((Window *)); static char *status_channeltopic _((Window *)); static char *status_fullserver _((Window *)); /****** Coded by Zakath ******/ static char *status_packs _((Window *)); static char *status_dccgets _((Window *)); static char *status_dccsends _((Window *)); static char *status_autoget _((Window *)); static char *status_security _((Window *)); static char *status_frlist _((Window *)); static char *status_nhprot _((Window *)); static char *status_floodp _((Window *)); static char *status_ctcpcloak _((Window *)); static char *status_channelcount _((Window *)); #ifdef CELE static char *status_loadavg _((Window *)); #endif #ifdef WANTANSI static char *status_Cbarcolor0 _((Window *)); static char *status_Cbarcolor1 _((Window *)); static char *status_Cbarcolor2 _((Window *)); static char *status_Cbarcolor3 _((Window *)); static char *status_Cbarcolor4 _((Window *)); static char *status_Cbarcolor5 _((Window *)); static char *status_Cbarcolor6 _((Window *)); static char *status_Cbarcolor7 _((Window *)); static char *status_Cbarcolor8 _((Window *)); static char *status_Cbarcolor9 _((Window *)); static char *status_Cbarcolora _((Window *)); static char *status_Cbarcolorb _((Window *)); static char *status_Cbarcolorc _((Window *)); #endif /*****************************/ /****************************************************************************/ /* * Maximum number of "%" expressions in a status line format. If you change * this number, you must manually change the snprintf() in make_status */ #define MAX_FUNCTIONS 36 /* The format statements to build each portion of the status line */ static char *mode_format = (char *) 0; static char *umode_format = (char *) 0; /**************************** PATCHED by Flier ******************************/ /*static char *status_format[3] = {(char *) 0, (char *) 0, (char *) 0,};*/ static char *status_format[4] = {(char *) 0, (char *) 0, (char *) 0,}; /****************************************************************************/ static char *query_format = (char *) 0; static char *clock_format = (char *) 0; static char *hold_lines_format = (char *) 0; static char *channel_format = (char *) 0; static char *mail_format = (char *) 0; static char *server_format = (char *) 0; static char *notify_format = (char *) 0; static char *group_format = (char *) 0; /**************************** PATCHED by Flier ******************************/ static char *away_format = (char *) 0; static char *channelcount_format = (char *) 0; static char *uptime_format = (char *) 0; #ifdef CELE static char *loadavg_format = (char *) 0; #endif static char locbuf[mybufsize]; /****************************************************************************/ /* * status_func: The list of status line function in the proper order for * display. This list is set in convert_format() */ /**************************** PATCHED by Flier ******************************/ /*static char *(*status_func[3][MAX_FUNCTIONS]) _((Window *));*/ static char *(*status_func[4][MAX_FUNCTIONS]) _((Window *)); /****************************************************************************/ /* func_cnt: the number of status line functions assigned */ /**************************** PATCHED by Flier ******************************/ /*static int func_cnt[3];*/ static int func_cnt[4]; /****************************************************************************/ static int alarm_hours, /* hour setting for alarm in 24 hour time */ alarm_minutes; /* minute setting for alarm */ /* Stuff for the alarm */ static struct itimerval clock_timer = { { 10L, 0L }, { 1L, 0L } }; static struct itimerval off_timer = { { 0L, 0L }, { 0L, 0L } }; static RETSIGTYPE alarmed _((void)); int do_status_alarmed; /* alarmed: This is called whenever a SIGALRM is received and the alarm is on */ static RETSIGTYPE alarmed() { do_status_alarmed = 1; } void real_status_alarmed() { char time_str[16]; say("The time is %s", update_clock(time_str, 16, GET_TIME)); term_beep(); term_beep(); term_beep(); } /* * alarm_switch: turns on and off the alarm display. Sets the system timer * and sets up a signal to trap SIGALRMs. If flag is 1, the alarmed() * routine will be activated every 10 seconds or so. If flag is 0, the timer * and signal stuff are reset */ static void alarm_switch(flag) int flag; { static int alarm_on = 0; if (flag) { if (!alarm_on) { setitimer(ITIMER_REAL, &clock_timer, (struct itimerval *) 0); (void) MY_SIGNAL(SIGALRM, alarmed, 0); alarm_on = 1; } } else if (alarm_on) { setitimer(ITIMER_REAL, &off_timer, (struct itimerval *) 0); (void) MY_SIGNAL(SIGALRM, (sigfunc *)SIG_IGN, 0); alarm_on = 0; } } /* * set_alarm: given an input string, this checks it's validity as a clock * type time thingy. It accepts two time formats. The first is the HH:MM:XM * format where HH is between 1 and 12, MM is between 0 and 59, and XM is * either AM or PM. The second is the HH:MM format where HH is between 0 and * 23 and MM is between 0 and 59. This routine also looks for one special * case, "OFF", which sets the alarm string to null */ void set_alarm(str) char *str; { char hours[10], minutes[10], merid[3]; char time_str[10]; int c, h, m, min_hours, max_hours; if (str == (char *) 0) { alarm_switch(0); return; } if (!my_stricmp(str, var_settings[OFF])) { set_string_var(CLOCK_ALARM_VAR, (char *) 0); alarm_switch(0); return; } c = sscanf(str, " %2[^:]:%2[^paPA]%2s ", hours, minutes, merid); switch (c) { case 2: min_hours = 0; max_hours = 23; break; case 3: min_hours = 1; max_hours = 12; upper(merid); break; default: say("CLOCK_ALARM: Bad time format."); set_string_var(CLOCK_ALARM_VAR, (char *) 0); return; } h = atoi(hours); m = atoi(minutes); if (h >= min_hours && h <= max_hours && isdigit(hours[0]) && (isdigit(hours[1]) || hours[1] == (char) 0)) { if (m >= 0 && m <= 59 && isdigit(minutes[0]) && isdigit(minutes[1])) { alarm_minutes = m; alarm_hours = h; if (max_hours == 12) { if (merid[0] != 'A') { if (merid[0] == 'P') { if (h != 12) alarm_hours += 12; } else { say("CLOCK_ALARM: alarm time must end with either \"AM\" or \"PM\""); set_string_var(CLOCK_ALARM_VAR, (char *) 0); } } else { if (h == 12) alarm_hours = 0; } if (merid[1] == 'M') { snprintf(time_str, sizeof time_str, "%02d:%02d%s", h, m, merid); set_string_var(CLOCK_ALARM_VAR, time_str); } else { say("CLOCK_ALARM: alarm time must end with either \"AM\" or \"PM\""); set_string_var(CLOCK_ALARM_VAR, (char *) 0); } } else { snprintf(CP(time_str), sizeof time_str, "%02d:%02d", h, m); set_string_var(CLOCK_ALARM_VAR, time_str); } } else { say("CLOCK_ALARM: alarm minutes value must be between 0 and 59."); set_string_var(CLOCK_ALARM_VAR, (char *) 0); } } else { say("CLOCK_ALARM: alarm hour value must be between %d and %d.", min_hours, max_hours); set_string_var(CLOCK_ALARM_VAR, (char *) 0); } } /* update_clock: figures out the current time and returns it in a nice format */ char * update_clock(buf, len, flag) char *buf; size_t len; int flag; { static char time_str[10]; static int min = -1, hour = -1; struct tm *time_val; char *merid; time_t t; t = time(0); time_val = localtime(&t); if (get_string_var(CLOCK_ALARM_VAR)) { if ((time_val->tm_hour == alarm_hours) && (time_val->tm_min == alarm_minutes)) alarm_switch(1); else alarm_switch(0); } if (flag == RESET_TIME || time_val->tm_min != min || time_val->tm_hour != hour) { int tmp_hour, tmp_min, server; tmp_hour = time_val->tm_hour; tmp_min = time_val->tm_min; if (get_int_var(CLOCK_24HOUR_VAR)) merid = empty_string; else { if (time_val->tm_hour < 12) /**************************** PATCHED by Flier ******************************/ /*merid = "AM";*/ #ifdef TDF merid = "am"; #else merid = "AM"; #endif /****************************************************************************/ else /**************************** PATCHED by Flier ******************************/ /*merid = "PM";*/ #ifdef TDF merid = "pm"; #else merid = "PM"; #endif /****************************************************************************/ if (time_val->tm_hour > 12) time_val->tm_hour -= 12; else if (time_val->tm_hour == 0) time_val->tm_hour = 12; } server = from_server; from_server = primary_server; snprintf(CP(time_str), sizeof time_str, "%02d:%02d%s", time_val->tm_hour, time_val->tm_min, merid); if (buf) { strncpy(buf, time_str, len - 1); buf[len - 1] = '\0'; } if (tmp_min != min || tmp_hour != hour) { hour = tmp_hour; min = tmp_min; do_hook(TIMER_LIST, "%s", time_str); } do_hook(IDLE_LIST, "%ld", (t - idle_time) / 60L); from_server = server; flag = GET_TIME; } if (buf) { strncpy(buf, time_str, len - 1); buf[len - 1] = '\0'; } if (flag == GET_TIME) return(buf ? buf : time_str); else return ((char *) 0); } /*ARGSUSED*/ void reset_clock(unused) char *unused; { update_clock(0, 0, RESET_TIME); update_all_status(); } /**************************** PATCHED by Flier ******************************/ /* Insert SBAR color into buffer - for status bar */ #ifdef WANTANSI void InsertStatusColor(ccode,buffer,bufsize) char ccode; char *buffer; int bufsize; { char *color=empty_string; if (get_int_var(DISPLAY_ANSI_VAR)) { switch (ccode) { case '0': color=Colors[COLOFF]; break; case '1': color=CmdsColors[COLSBAR1].color1; break; case '2': color=CmdsColors[COLSBAR1].color2; break; case '3': color=CmdsColors[COLSBAR1].color3; break; case '4': color=CmdsColors[COLSBAR1].color4; break; case '5': color=CmdsColors[COLSBAR1].color5; break; case '6': color=CmdsColors[COLSBAR1].color6; break; case '7': color=CmdsColors[COLSBAR2].color1; break; case '8': color=CmdsColors[COLSBAR2].color2; break; case '9': color=CmdsColors[COLSBAR2].color3; break; case 'a': color=CmdsColors[COLSBAR2].color4; break; case 'b': color=CmdsColors[COLSBAR2].color5; break; case 'c': color=CmdsColors[COLSBAR2].color6; break; } strmcat(buffer,color,bufsize); } } #endif /****************************************************************************/ /* * 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 snprintf. 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(format, c) char *format; int c; { char lbuf[BIG_BUFFER_SIZE + 1]; static char bletch[] = "%% "; char *ptr = (char *) 0; int dont_got_it = 1; if (format == (char *) 0) return ((char *) 0); *lbuf = (char) 0; while (format) { if ((ptr = (char *) index(format, '%')) != NULL) { *ptr = (char) 0; strmcat(lbuf, format, BIG_BUFFER_SIZE); *(ptr++) = '%'; if ((*ptr == c) && dont_got_it) { dont_got_it = 0; strmcat(lbuf, "%s", BIG_BUFFER_SIZE); } /**************************** PATCHED by Flier ******************************/ /* This little bit of code allows colors to be embedded within * sub-portions of the status bar variables, e.g.: * /set status_clock %y6[%y4%T%y6] */ #ifdef WANTANSI else if ((*ptr=='Y') || (*ptr=='y')) InsertStatusColor(*(++ptr),lbuf,sizeof(lbuf)); #endif /****************************************************************************/ else { bletch[2] = *ptr; strmcat(lbuf, bletch, BIG_BUFFER_SIZE); } ptr++; } else strmcat(lbuf, format, BIG_BUFFER_SIZE); format = ptr; } malloc_strcpy(&ptr, lbuf); return (ptr); } static char * convert_format(format, k) char *format; int k; { char lbuf[BIG_BUFFER_SIZE + 1]; char *ptr, *malloc_ptr = (char *) 0; int *cp; *lbuf = (char) 0; while (format) { if ((ptr = (char *) index(format, '%')) != NULL) { *ptr = (char) 0; strmcat(lbuf, format, BIG_BUFFER_SIZE); *(ptr++) = '%'; cp = &func_cnt[k]; if (*cp < MAX_FUNCTIONS) { switch (*(ptr++)) { case '%': /* %% instead of %, because this will be passed to snprintf */ strmcat(lbuf, "%%", BIG_BUFFER_SIZE); break; case 'N': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_nickname; break; case '>': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_right_justify; break; case 'G': new_free(&group_format); group_format = convert_sub_format(get_string_var(STATUS_GROUP_VAR), 'G'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_group; break; case 'Q': new_free(&query_format); query_format = convert_sub_format(get_string_var(STATUS_QUERY_VAR), 'Q'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_query_nick; break; case 'F': new_free(¬ify_format); notify_format = convert_sub_format(get_string_var(STATUS_NOTIFY_VAR), 'F'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_notify_windows; break; case '@': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_chanop; break; case 'C': new_free(&channel_format); channel_format = convert_sub_format(get_string_var(STATUS_CHANNEL_VAR), 'C'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_channel; break; case 'S': new_free(&server_format); server_format = convert_sub_format(get_string_var(STATUS_SERVER_VAR), 'S'); strmcat(lbuf,"%s",BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_server; break; case '+': new_free(&mode_format); mode_format = convert_sub_format(get_string_var(STATUS_MODE_VAR), '+'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_mode; break; case '#': new_free(&umode_format); umode_format = convert_sub_format(get_string_var(STATUS_UMODE_VAR), '#'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_umode; break; case 'M': new_free(&mail_format); mail_format = convert_sub_format(get_string_var(STATUS_MAIL_VAR), 'M'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_mail; break; case 'I': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_insert_mode; break; case 'O': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_overwrite_mode; break; case 'A': /**************************** PATCHED by Flier ******************************/ /*strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_away; break;*/ new_free(&away_format); away_format = convert_sub_format(get_string_var(STATUS_AWAY_VAR), 'A'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_away; break; /****************************************************************************/ case 'V': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_version; break; case 'R': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_refnum; break; case 'T': new_free(&clock_format); clock_format = convert_sub_format(get_string_var(STATUS_CLOCK_VAR), 'T'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_clock; break; /**************************** PATCHED by Flier ******************************/ /*case 'U': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user0; break;*/ /****************************************************************************/ case 'H': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_hold; break; case 'B': new_free(&hold_lines_format); hold_lines_format = convert_sub_format(get_string_var(STATUS_HOLD_LINES_VAR), 'B'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_hold_lines; break; case '*': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_oper; break; case 'W': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_window; break; /**************************** PATCHED by Flier ******************************/ /*case 'X': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user1; break; case 'Y': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user2; break; case 'Z': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user3; break;*/ case '1': new_free(&uptime_format); uptime_format = convert_sub_format(get_string_var(STATUS_UPTIME_VAR), '1'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_uptime; break; case '2': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_lag; break; case '3': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_lastjoin; break; case 'J': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_dcc; break; case 'U': new_free(&channelcount_format); channelcount_format = convert_sub_format(get_string_var(STATUS_CHANNELCOUNT_VAR), 'U'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_channelcount; break; /****** Coded by Zakath ******/ case '4': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_packs; break; case '5': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_dccsends; break; case '6': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_dccgets; break; case '7': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_autoget; break; case '8': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_security; break; case '9': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_channeltopic; break; case 'D': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_frlist; break; case 'E': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_nhprot; break; case 'P': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_floodp; break; case 'L': strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_ctcpcloak; break; #ifdef CELE case 'Z': new_free(&loadavg_format); loadavg_format= convert_sub_format(get_string_var(STATUS_LOADAVG_VAR), 'Z'); strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_loadavg; break; #endif #ifdef WANTANSI case 'Y': /* Celerity StatusBar %Y? junt */ case 'y': if (get_int_var(DISPLAY_ANSI_VAR)) { switch (*(ptr++)) { case '0' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor0; break; case '1' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor1; break; case '2' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor2; break; case '3' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor3; break; case '4' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor4; break; case '5' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor5; break; case '6' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor6; break; case '7' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor7; break; case '8' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor8; break; case '9' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolor9; break; case 'a' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolora; break; case 'b' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolorb; break; case 'c' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_Cbarcolorc; break; } } else ptr++; break; #endif case '!': /* %!## Status_user format by Zakath */ /* Thx to Sheik & Flier for help */ switch (*(ptr++)) { case '0' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user00; break; case '1' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user01; break; case '2' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user02; break; case '3' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user03; break; #ifndef LITE case '4' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user04; break; case '5' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user05; break; case '6' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user06; break; case '7' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user07; break; case '8' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user08; break; case '9' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_user09; break; #endif case 'S' : strmcat(lbuf, "%s", BIG_BUFFER_SIZE); status_func[k][(*cp)++] = status_fullserver; break; } break; default: ptr++; break; /****************************************************************************/ /* no default..?? - phone, jan 1993 */ /* empty is a good default -lynx, mar 93 */ } } else ptr++; } else strmcat(lbuf, format, BIG_BUFFER_SIZE); format = ptr; } /* this frees the old str first */ malloc_strcpy(&malloc_ptr, lbuf); return (malloc_ptr); } void build_status(format) char *format; { int i, k; /**************************** PATCHED by Flier ******************************/ /*for (k = 0; k < 3; k++)*/ for (k = 0; k < 4; k++) /****************************************************************************/ { new_free(&status_format[k]); func_cnt[k] = 0; switch (k) { case 0 : format = get_string_var(STATUS_FORMAT_VAR); break; case 1 : format = get_string_var(STATUS_FORMAT1_VAR); break; case 2 : format = get_string_var(STATUS_FORMAT2_VAR); break; /**************************** PATCHED by Flier ******************************/ case 3 : format = get_string_var(STATUS_FORMAT3_VAR); break; /****************************************************************************/ } if (format != NULL) /* convert_format mallocs for us */ status_format[k] = convert_format(format, k); for (i = func_cnt[k]; i < MAX_FUNCTIONS; i++) status_func[k][i] = status_null_function; } update_all_status(); } /**************************** PATCHED by Flier ******************************/ #ifdef CELE void Cquick_status(format,qstat) char *format; int qstat; { int i,k; for (k=0;k<4;k++) { new_free(&status_format[k]); func_cnt[k]=0; if (qstat) { /* Turn QuickStat ON */ switch (k) { case 0: format=get_string_var(STATUS_FORMAT_VAR); break; case 1: format=get_string_var(STATUS_FORMAT3_VAR); break; case 2: format=get_string_var(STATUS_FORMAT1_VAR); break; case 3: format=get_string_var(STATUS_FORMAT2_VAR); break; } } else { /* Turn QuickStat OFF */ switch (k) { case 0: format=get_string_var(STATUS_FORMAT_VAR); break; case 1: format=get_string_var(STATUS_FORMAT2_VAR); break; case 2: format=get_string_var(STATUS_FORMAT3_VAR); break; case 3: format=get_string_var(STATUS_FORMAT1_VAR); break; } } if (format) /* convert_format mallocs for us */ status_format[k]=convert_format(format, k); for (i=func_cnt[k];idouble_status) { case -1: new_free(&window->status_line[0]); new_free(&window->status_line[1]); goto out; case 0: new_free(&window->status_line[1]); final = 1; break; case 1: final = 2; break; /**************************** PATCHED by Flier ******************************/ case 2: final = 3; break; default: /****************************************************************************/ yell("--- make_status: unknown window->double value %d", window->double_status); final = 1; } for (k = 0 ; k < final; k++) { if (k) /**************************** PATCHED by Flier ******************************/ /*l = 2;*/ l = k + 1; /****************************************************************************/ else if (window->double_status) l = 1; else l = 0; if (!dumb && status_format[l]) make_status_one(window, k, l); } out: cursor_to_input(); } static void make_status_one(window, k, l) Window *window; int k; int l; { u_char lbuf[BIG_BUFFER_SIZE]; u_char rbuf[BIG_BUFFER_SIZE]; u_char *func_value[MAX_FUNCTIONS]; size_t len; int i; int rjustifypos; int justifypadlen; int RealPosition; /* * XXX: note that this code below depends on the definition * of MAX_FUNCTIONS (currently 33), and the snprintf must * be updated if MAX_FUNCTIONS is changed. */ for (i = 0; i < MAX_FUNCTIONS; i++) func_value[i] = (status_func[l][i]) (window); /**************************** PATCHED by Flier ******************************/ /*lbuf[0] = REV_TOG;*/ lbuf[0] = get_int_var(STATUS_REVERSE_VAR) ? REV_TOG : ALL_OFF; /****************************************************************************/ snprintf(CP(lbuf+1), sizeof(lbuf) - 1, CP(status_format[l]), 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]); for (i = 0; i < MAX_FUNCTIONS; i++) new_free(&(func_value[i])); /* Patched 26-Mar-93 by Aiken * make_window now right-justifies everything * after a %> * it's also more efficient. */ rjustifypos = -1; justifypadlen = 0; for (i = 0; lbuf[i]; i++) { /* formfeed is a marker for left/right border*/ if (lbuf[i] == '\f') { int len_left; int len_right; /* Split the line to left and right part */ lbuf[i] = '\0'; /* Get lengths of left and right part in number of columns */ len_right = my_strlen_c(lbuf); len_left = my_strlen_c(lbuf+i+1); justifypadlen = current_screen->co - len_right - len_left; if (justifypadlen < 0) justifypadlen = 0; /* Delete the marker */ /* FIXME: strcpy may not be used for overlapping buffers */ strcpy(lbuf+i, lbuf+i+1); rjustifypos = i; } } if (get_int_var(FULL_STATUS_LINE_VAR)) { if (rjustifypos == -1) { int length = my_strlen_c(lbuf); justifypadlen = current_screen->co - length; if (justifypadlen < 0) justifypadlen = 0; rjustifypos = strlen(lbuf); } if (justifypadlen > 0) { /* Move a part of the data out of way */ memmove(lbuf + rjustifypos + justifypadlen, lbuf + rjustifypos, strlen(lbuf) - rjustifypos + 1); // +1 = zero terminator /* Then fill the part with spaces */ memset(lbuf + rjustifypos, ' ', justifypadlen); } } len = strlen(lbuf); if (len > (sizeof(lbuf) - 2)) len = sizeof(lbuf) - 2; lbuf[len] = ALL_OFF; lbuf[len+1] = '\0'; my_strcpy_ci(rbuf, lbuf); RealPosition = 0; i = 0; #if 0 /* obsoleted this stuff because the character set conversion * thing may render the positions bad -Bisqwit */ ----- /* * Thanks to Max Bell (mbell@cie.uoregon.edu) for info * about TVI terminals and the sg terminal capability */ if (window->status_line[k] && (SG == -1)) { for (i = 0; rbuf[i] && window->status_line[k][i]; i++) { if ((u_char) rbuf[i] != window->status_line[k][i]) break; if (rbuf[i] != REV_TOG && rbuf[i] != UND_TOG && rbuf[i] != ALL_OFF && rbuf[i] != BOLD_TOG) RealPosition++; } } else i = 0; if ((len = my_strlen(rbuf + i)) || rbuf[i] || window->status_line[k] || window->status_line[k][i]) #endif { Screen *old_current_screen; old_current_screen = current_screen; set_current_screen(window->screen); term_move_cursor(RealPosition, window->bottom + k); len = output_line(rbuf, i); cursor_in_display(); if (term_clear_to_eol() && len < current_screen->co) term_space_erase(current_screen->co - len); malloc_strcpy(&window->status_line[k], rbuf); set_current_screen(old_current_screen); } } static char * status_nickname(window) Window *window; { char *ptr = (char *) 0; if ((connected_to_server == 1) && !get_int_var(SHOW_STATUS_ALL_VAR) && (!window->current_channel) && (window->screen->current_window != window)) malloc_strcpy(&ptr, empty_string); else malloc_strcpy(&ptr, get_server_nickname(window->server)); return (ptr); } static char * status_server(window) Window *window; { char *ptr = NULL, *rest, *name; char lbuf[BIG_BUFFER_SIZE+1]; if (connected_to_server != 1) { if (window->server != -1) { if (server_format) { name = get_server_name(window->server); rest = (char *) index(name, '.'); if (rest != NULL && my_strnicmp(name, "irc", 3) != 0 && my_strnicmp(name, "icb", 3) != 0) { if (is_number(name)) snprintf(lbuf, sizeof lbuf, server_format, name); else { *rest = '\0'; snprintf(lbuf, sizeof lbuf, server_format, name); *rest = '.'; } } else snprintf(lbuf, sizeof lbuf, server_format, name); } else *lbuf = '\0'; } else strcpy(lbuf, " No Server"); } else *lbuf = '\0'; malloc_strcpy(&ptr, lbuf); return (ptr); } static char * status_group(window) Window *window; { char *ptr = (char *) 0; if (window->server_group && group_format) { char lbuf[BIG_BUFFER_SIZE+1]; snprintf(lbuf, sizeof lbuf, group_format, find_server_group_name(window->server_group)); malloc_strcpy(&ptr, lbuf); } else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_query_nick(window) Window *window; { char *ptr = (char *) 0; if (window->query_nick && query_format) { char lbuf[BIG_BUFFER_SIZE+1]; /**************************** PATCHED by Flier ******************************/ /*snprintf(lbuf, sizeof lbuf, query_format, window->query_nick);*/ int buflen = get_int_var(CHANNEL_NAME_WIDTH_VAR); char tmpbuf[mybufsize / 4]; if (buflen > sizeof(tmpbuf)) buflen = sizeof(tmpbuf); strmcpy(tmpbuf, window->query_nick, buflen); snprintf(lbuf, sizeof(lbuf), query_format, tmpbuf); /****************************************************************************/ malloc_strcpy(&ptr, lbuf); } else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_right_justify(window) Window *window; { char *ptr = (char *) 0; malloc_strcpy(&ptr, "\f"); return (ptr); } static char * status_notify_windows(window) Window *window; { char refnum[10]; int doneone = 0; char *ptr = (char *) 0; int flag = 1; char buf2[81]; if (get_int_var(SHOW_STATUS_ALL_VAR) || window == window->screen->current_window) { *buf2='\0'; while ((window = traverse_all_windows(&flag)) != NULL) { if (window->miscflags & WINDOW_NOTIFIED) { if (!doneone) { doneone++; snprintf(refnum, sizeof refnum, "%d", window->refnum); } else snprintf(refnum, sizeof refnum, ",%d", window->refnum); strmcat(buf2, refnum, 81); } } } if (doneone && notify_format) { char lbuf[BIG_BUFFER_SIZE+1]; snprintf(lbuf, sizeof lbuf, notify_format, buf2); malloc_strcpy(&ptr, lbuf); } else malloc_strcpy(&ptr, empty_string); return ptr; } static char * status_clock(window) Window *window; { char *ptr = (char *) 0; if ((get_int_var(CLOCK_VAR) && clock_format) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window == window->screen->current_window))) { char lbuf[BIG_BUFFER_SIZE+1]; char time_str[16]; snprintf(lbuf, sizeof lbuf, clock_format, update_clock(time_str, 16, GET_TIME)); malloc_strcpy(&ptr, lbuf); } else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_mode(window) Window *window; { char *ptr = (char *) 0, *mode; if (window->current_channel && chan_is_connected(window->current_channel, window->server)) { mode = get_channel_mode(window->current_channel,window->server); if (mode && *mode && mode_format) { char lbuf[BIG_BUFFER_SIZE+1]; snprintf(lbuf, sizeof lbuf, mode_format, mode); malloc_strcpy(&ptr, lbuf); return (ptr); } } malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_umode(window) Window *window; { char *ptr = (char *) 0; /**************************** PATCHED by Flier ******************************/ /*char localbuf[10];*/ char localbuf[64]; int i; /****************************************************************************/ char *c; if (connected_to_server == 0) malloc_strcpy(&ptr, empty_string); else if ((connected_to_server == 1) && !get_int_var(SHOW_STATUS_ALL_VAR) && (window->screen->current_window != window)) malloc_strcpy(&ptr, empty_string); else { c = localbuf; /**************************** PATCHED by Flier ******************************/ for (i = 0; i < 26; i++) if (get_server_umode_flag(window->server, 'a' + i)) *c ++= 'a' + i; for (i = 0; i < 27; i++) if (get_server_umode_flag(window->server, '@' + i)) *c ++= '@' + i; /****************************************************************************/ *c++ = '\0'; if (*localbuf != '\0' && umode_format) { char lbuf[BIG_BUFFER_SIZE+1]; snprintf(lbuf, sizeof lbuf, umode_format, localbuf); malloc_strcpy(&ptr, lbuf); } else malloc_strcpy(&ptr, empty_string); } return (ptr); } static char * status_chanop(window) Window *window; { char *ptr = (char *) 0, *text; /**************************** PATCHED by Flier ******************************/ ChannelList *chan; /****************************************************************************/ if (window->current_channel && chan_is_connected(window->current_channel, window->server) && (chan=lookup_channel(window->current_channel, window->server, 0))) { if (chan->status & CHAN_CHOP) { text = get_string_var(STATUS_CHANOP_VAR); malloc_strcpy(&ptr,text ? text : "@"); } else if (chan->status & CHAN_HALFOP) malloc_strcpy(&ptr, "%"); else if (chan->status & CHAN_VOICE) malloc_strcpy(&ptr, "+"); else malloc_strcpy(&ptr, empty_string); } else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_hold_lines(window) Window *window; { char *ptr = (char *) 0; int num; char localbuf[40]; num = window->held_lines - window->held_lines%10; if (num) { char lbuf[BIG_BUFFER_SIZE+1]; snprintf(localbuf, sizeof localbuf, "%d", num); snprintf(lbuf, sizeof lbuf, hold_lines_format, localbuf); malloc_strcpy(&ptr, lbuf); } else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_channel(window) Window *window; { int num; char *s, *ptr, channel[IRCD_BUFFER_SIZE + 1]; s = window->current_channel; if (s && chan_is_connected(s, window->server)) { char lbuf[BIG_BUFFER_SIZE+1]; if (get_int_var(HIDE_PRIVATE_CHANNELS_VAR) && is_channel_mode(window->current_channel, MODE_PRIVATE | MODE_SECRET, window->server)) ptr = "*private*"; else ptr = window->current_channel; strmcpy(channel, ptr, IRCD_BUFFER_SIZE); if ((num = get_int_var(CHANNEL_NAME_WIDTH_VAR)) && ((int) strlen(channel) > num)) channel[num] = (char) 0; /* num = atoi(channel); */ ptr = (char *) 0; snprintf(lbuf, sizeof lbuf, channel_format, channel); malloc_strcpy(&ptr, lbuf); } else { ptr = (char *) 0; malloc_strcpy(&ptr, empty_string); } return (ptr); } static char * status_mail(window) Window *window; { char *ptr = (char *) 0, *number; if ((get_int_var(MAIL_VAR) && (number = check_mail()) && mail_format) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window == window->screen->current_window))) { char lbuf[BIG_BUFFER_SIZE+1]; snprintf(lbuf, sizeof lbuf, mail_format, number); malloc_strcpy(&ptr, lbuf); } else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_insert_mode(window) Window *window; { char *ptr = (char *) 0, *text; text = empty_string; 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)) == (char *) 0) text = empty_string; } malloc_strcpy(&ptr, text); return (ptr); } static char * status_overwrite_mode(window) Window *window; { char *ptr = (char *) 0, *text; text = empty_string; 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)) == (char *) 0) text = empty_string; } malloc_strcpy(&ptr, text); return (ptr); } static char * status_away(window) Window *window; { /**************************** PATCHED by Flier ******************************/ /*char *ptr = (char *) 0, *text;*/ char *ptr = (char *) 0; char buf[10]; /****************************************************************************/ if (connected_to_server == 0) malloc_strcpy(&ptr, empty_string); else if ((connected_to_server == 1) && !get_int_var(SHOW_STATUS_ALL_VAR) && (window->screen->current_window != window)) malloc_strcpy(&ptr, empty_string); else { /**************************** PATCHED by Flier ******************************/ /*if (server_list[window->server].away && (text = get_string_var(STATUS_AWAY_VAR))) malloc_strcpy(&ptr, text); else malloc_strcpy(&ptr, empty_string);*/ if (server_list[window->server].away && away_format) { snprintf(buf, sizeof(buf), "%d", AwayMsgNum); snprintf(locbuf, sizeof(locbuf), away_format, buf); malloc_strcpy(&ptr, locbuf); } else malloc_strcpy(&ptr, empty_string); /****************************************************************************/ } return (ptr); } /**************************** PATCHED by Flier ******************************/ /*static char * status_user0(window) Window *window; { char *ptr = (char *) 0, *text; if ((text = get_string_var(STATUS_USER_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window == window->screen->current_window))) malloc_strcpy(&ptr, text); else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_user1(window) Window *window; { char *ptr = (char *) 0, *text; if ((text = get_string_var(STATUS_USER1_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window == window->screen->current_window))) malloc_strcpy(&ptr, text); else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_user2(window) Window *window; { char *ptr = (char *) 0, *text; if ((text = get_string_var(STATUS_USER2_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window == window->screen->current_window))) malloc_strcpy(&ptr, text); else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_user3(window) Window *window; { char *ptr = (char *) 0, *text; if ((text = get_string_var(STATUS_USER3_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window == window->screen->current_window))) malloc_strcpy(&ptr, text); else malloc_strcpy(&ptr, empty_string); return (ptr); }*/ /****************************************************************************/ static char * status_hold(window) Window *window; { char *ptr = (char *) 0, *text; if (window->held && (text = get_string_var(STATUS_HOLD_VAR))) malloc_strcpy(&ptr, text); else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_oper(window) Window *window; { char *ptr = (char *) 0, *text; if (!connected_to_server) malloc_strcpy(&ptr, empty_string); else if (get_server_operator(window->server) && (text = get_string_var(STATUS_OPER_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || connected_to_server != 1 || (window->screen->current_window == window))) malloc_strcpy(&ptr, text); else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_window(window) Window *window; { char *ptr = (char *) 0, *text; if ((text = get_string_var(STATUS_WINDOW_VAR)) && (number_of_windows() > 1) && (window->screen->current_window == window)) malloc_strcpy(&ptr, text); else malloc_strcpy(&ptr, empty_string); return (ptr); } static char * status_refnum(window) Window *window; { char *ptr = (char *) 0; if (window->name) malloc_strcpy(&ptr, window->name); else { char lbuf[10]; snprintf(lbuf, sizeof lbuf, "%u", window->refnum); malloc_strcpy(&ptr, lbuf); } return (ptr); } static char * status_version(window) Window *window; { char *ptr = (char *) 0; if ((connected_to_server == 1) && !get_int_var(SHOW_STATUS_ALL_VAR) && (window->screen->current_window != window)) malloc_strcpy(&ptr, empty_string); else { malloc_strcpy(&ptr, irc_version); } return (ptr); } static char * status_null_function(window) Window *window; { char *ptr = (char *) 0; malloc_strcpy(&ptr, empty_string); return (ptr); } /**************************** PATCHED by Flier ******************************/ /* by Zakath */ static char *status_user00(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_user01(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER1_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_user02(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER2_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_user03(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER3_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } #ifndef LITE static char *status_user04(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER4_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_user05(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER5_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_user06(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER6_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_user07(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER7_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_user08(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER8_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_user09(window) Window *window; { char *ptr=(char *) 0; char *text; if ((text=get_string_var(STATUS_USER9_VAR)) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) malloc_strcpy(&ptr,text); else malloc_strcpy(&ptr,empty_string); return(ptr); } #endif static char *status_lag(window) Window *window; { char *ptr=(char *) 0; #if defined(CELE) char lagbuf[8]; #endif if (get_int_var(SHOW_STATUS_ALL_VAR) || current_screen->current_window==window) { #if defined(CELE) snprintf(lagbuf,sizeof(lagbuf),"%06ld",LagTimer.tv_usec); lagbuf[3]='\0'; snprintf(locbuf,sizeof(locbuf),"%ld.%s",LagTimer.tv_sec,lagbuf); #else snprintf(locbuf,sizeof(locbuf),"%02d",LagTimer); #endif malloc_strcpy(&ptr,locbuf); } else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_lastjoin(window) Window *window; { char *ptr=(char *) 0; if (CheckServer(curr_scr_win->server) && server_list[curr_scr_win->server].LastJoin && (get_int_var(SHOW_STATUS_ALL_VAR) || current_screen->current_window==window)) malloc_strcpy(&ptr,server_list[curr_scr_win->server].LastJoin); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_dcc(window) Window *window; { char *ptr=(char *) 0; if (CurrentDCC && (get_int_var(SHOW_STATUS_ALL_VAR) || current_screen->current_window==window)) malloc_strcpy(&ptr,CurrentDCC); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_channelcount(window) Window *window; { int ops=0; int nonops=0; int tmpvar=0; char *ptr=(char *) 0; char *tmpstr1=(char *) 0; char *tmpstr2=(char *) 0; char *channel=window->current_channel; char tmpbuf[mybufsize/4]; NickList *tmp; ChannelList *chan; if (!channel || !chan_is_connected(channel, window->server) || !channelcount_format || !get_string_var(STATUS_CHANNELCOUNT_VAR) || (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window)) malloc_strcpy(&ptr,empty_string); else if ((chan=lookup_channel(channel,curr_scr_win->server,0))==NULL) malloc_strcpy(&ptr,empty_string); else { for (tmp=chan->nicks;tmp;tmp=tmp->next) if (tmp->chanop) ops++; else nonops++; for (tmpstr1=channelcount_format,tmpstr2=tmpbuf;*tmpstr1;tmpstr1++) if (*tmpstr1=='%') { tmpstr1++; if (*tmpstr1=='%') tmpstr1++; if (*tmpstr1=='o' || *tmpstr1=='O') tmpvar=ops; else if (*tmpstr1=='n' || *tmpstr1=='N') tmpvar=nonops; else if (*tmpstr1=='t' || *tmpstr1=='T') tmpvar=ops+nonops; else tmpvar=-1; if (tmpvar>=0) { snprintf(locbuf,sizeof(locbuf),"%d",tmpvar); *tmpstr2='\0'; strmcat(tmpstr2,locbuf,sizeof(tmpbuf)); tmpstr2+=strlen(locbuf); } else *tmpstr2++=*tmpstr1; } else *tmpstr2++=*tmpstr1; *tmpstr2='\0'; malloc_strcpy(&ptr,tmpbuf); } return(ptr); } static char *status_channeltopic(window) Window *window; { char *ptr=(char *) 0; char *channel=window->current_channel; char topicbuf[mybufsize]; ChannelList *chan; if (!channel || !chan_is_connected(channel,window->server) || (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window)) malloc_strcpy(&ptr,empty_string); else if ((chan=lookup_channel(channel,window->server,0))==NULL) malloc_strcpy(&ptr,empty_string); else { StripAnsi(chan->topicstr?chan->topicstr:empty_string,topicbuf,3); malloc_strcpy(&ptr,topicbuf); } return(ptr); } static char *status_fullserver(window) Window *window; { char *ptr=(char *) 0; if (curr_scr_win->server!=-1 && (get_int_var(SHOW_STATUS_ALL_VAR) || current_screen->current_window==window)) malloc_strcpy(&ptr,server_list[curr_scr_win->server].itsname); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_uptime(window) Window *window; { int tmpvar; char *ptr=(char *) 0; char *tmpstr1; char *tmpstr2; char tmpbuf[mybufsize/4]; time_t timediff; if (get_int_var(SHOW_STATUS_ALL_VAR) || current_screen->current_window==window) { timediff=time((time_t *) 0)-start_time; for (tmpstr1=uptime_format,tmpstr2=tmpbuf;*tmpstr1;tmpstr1++) { if (*tmpstr1=='%') { tmpstr1++; if (*tmpstr1=='%') tmpstr1++; if (*tmpstr1=='d' || *tmpstr1=='D') tmpvar=timediff/86400; else if (*tmpstr1=='h' || *tmpstr1=='H') tmpvar=(timediff/3600)%24; else if (*tmpstr1=='m' || *tmpstr1=='M') tmpvar=(timediff/60)%60; else tmpvar=-1; if (tmpvar>=0) { snprintf(locbuf,sizeof(locbuf),"%02d",tmpvar); *tmpstr2='\0'; strmcat(tmpstr2,locbuf,sizeof(tmpbuf)); tmpstr2+=strlen(locbuf); } else *tmpstr2++=*tmpstr1; } else *tmpstr2++=*tmpstr1; } *tmpstr2='\0'; malloc_strcpy(&ptr,tmpbuf); } else malloc_strcpy(&ptr,empty_string); return(ptr); } /****** Coded by Zakath ******/ static char *status_ctcpcloak(window) Window *window; { char *ptr=(char *) 0; if (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window) malloc_strcpy(&ptr,empty_string); else if (CTCPCloaking==0) malloc_strcpy(&ptr,"k"); else if (CTCPCloaking==1) malloc_strcpy(&ptr,"K"); else malloc_strcpy(&ptr,"H"); return(ptr); } static char *status_floodp(window) Window *window; { char *ptr=(char *) 0; if (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window) malloc_strcpy(&ptr,empty_string); else if (FloodProt>1) malloc_strcpy(&ptr,"M"); else if (FloodProt) malloc_strcpy(&ptr,"P"); else malloc_strcpy(&ptr,"p"); return(ptr); } static char *status_nhprot(window) Window *window; { char *ptr=(char *) 0; if (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window) malloc_strcpy(&ptr,empty_string); else if (NHProt) { if (NHDisp==0) malloc_strcpy(&ptr,"Nq"); else if (NHDisp==1) malloc_strcpy(&ptr,"Nm"); else malloc_strcpy(&ptr,"Nf"); } else { if (NHDisp==0) malloc_strcpy(&ptr,"nq"); else if (NHDisp==1) malloc_strcpy(&ptr,"nm"); else malloc_strcpy(&ptr,"nf"); } return(ptr); } static char *status_frlist(window) Window *window; { char *ptr=(char *) 0; char *channel; if (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window) malloc_strcpy(&ptr,empty_string); else if (FriendList && (channel=get_channel_by_refnum(0)) && CheckChannel(FriendListChannels,channel)) malloc_strcpy(&ptr,"F"); else malloc_strcpy(&ptr,"f"); return(ptr); } static char *status_packs(window) Window *window; { char *ptr=(char *) 0; if (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window) malloc_strcpy(&ptr,empty_string); else { snprintf(locbuf,sizeof(locbuf),"%d",CdccPackNum); malloc_strcpy(&ptr,locbuf); } return(ptr); } static char *status_dccsends(window) Window *window; { char *ptr=(char *) 0; if (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window) malloc_strcpy(&ptr,empty_string); else { snprintf(locbuf,sizeof(locbuf),"%d",CdccSendNum); malloc_strcpy(&ptr,locbuf); } return(ptr); } static char *status_dccgets(window) Window *window; { char *ptr=(char *) 0; if (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window) malloc_strcpy(&ptr,empty_string); else { snprintf(locbuf,sizeof(locbuf),"%d",CdccRecvNum); malloc_strcpy(&ptr,locbuf); } return(ptr); } static char *status_autoget(window) Window *window; { char *ptr=(char *) 0; if (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window) malloc_strcpy(&ptr,empty_string); else if (AutoGet) malloc_strcpy(&ptr,"A"); else malloc_strcpy(&ptr,"a"); return(ptr); } static char *status_security(window) Window *window; { char *ptr=(char *) 0; if (!get_int_var(SHOW_STATUS_ALL_VAR) && current_screen->current_window!=window) malloc_strcpy(&ptr,empty_string); else if (Security) malloc_strcpy(&ptr,"S"); else malloc_strcpy(&ptr,"s"); return(ptr); } #ifdef WANTANSI static char *status_Cbarcolor0(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,Colors[COLOFF]); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolor1(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR1].color1); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolor2(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR1].color2); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolor3(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR1].color3); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolor4(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR1].color4); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolor5(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR1].color5); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolor6(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR1].color6); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolor7(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR2].color1); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolor8(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR2].color2); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolor9(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR2].color3); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolora(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR2].color4); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolorb(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR2].color5); else malloc_strcpy(&ptr,empty_string); return(ptr); } static char *status_Cbarcolorc(window) Window *window; { char *ptr=(char *) 0; if (get_int_var(DISPLAY_ANSI_VAR)) malloc_strcpy(&ptr,CmdsColors[COLSBAR2].color6); else malloc_strcpy(&ptr,empty_string); return(ptr); } #endif #ifdef CELE static char *status_loadavg(window) Window *window; { char *ptr=(char *) 0; #ifdef __linux__ char *pointer=(char *) 0; char loadbuf[64]; FILE *fip; if ((loadavg_format) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) { if ((fip=fopen("/proc/loadavg","r"))!=NULL) { if (fgets(loadbuf,sizeof(loadbuf),fip)) { pointer=loadbuf; new_next_arg(pointer,&pointer); } else strcpy(loadbuf,"error"); fclose(fip); snprintf(locbuf,sizeof(locbuf),loadavg_format,loadbuf); malloc_strcpy(&ptr,locbuf); } else malloc_strcpy(&ptr,empty_string); } else malloc_strcpy(&ptr,empty_string); #elif defined(HAVEGETLOADAVG) /* BSD systems */ double loadbuf[] = { 0 }; char loadbuf2[7]; if ((loadavg_format) && (get_int_var(SHOW_STATUS_ALL_VAR) || (window==window->screen->current_window))) { getloadavg(loadbuf,1); snprintf(loadbuf2,5,"%g",loadbuf[0]); snprintf(locbuf,sizeof(locbuf),loadavg_format,loadbuf2); malloc_strcpy(&ptr,locbuf); } else malloc_strcpy(&ptr,empty_string); /* kvm needs seteuid(0).. nice idea... #elif defined(__solaris__) double avg; double oavg; double davg; int numps; long temp[5]; char loadbuf[16]; if (kvm_read(kd,lst[0].n_value,(char *)temp,sizeof(temp))==sizeof(temp)) { avg=(double)temp[0]/(1<<8); oavg=(double)temp[1]/(1<<8); davg=(double)temp[2]/(1<<8); numps=0; snprintf(loadbuf,5,"%g",avg); snprintf(locbuf, sizeof(locbuf), loadavg_format, loadbuf); malloc_strcpy(&ptr,locbuf); } else malloc_strcpy(&ptr,empty_string); */ #else malloc_strcpy(&ptr,empty_string); #endif /* __linux__ && HAVEGETLOADAVG */ return (ptr); } #endif /* CELE */ /*****************************/ /****************************************************************************/