changed color codes to match Quake3
[divverent/darkplaces.git] / console.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // console.c
21
22 #if !defined(WIN32) || defined(__MINGW32__)
23 # include <unistd.h>
24 #endif
25 #include <time.h>
26 #include "quakedef.h"
27
28 int con_linewidth;
29
30 float con_cursorspeed = 4;
31
32 #define         CON_TEXTSIZE    131072
33
34 // total lines in console scrollback
35 int con_totallines;
36 // lines up from bottom to display
37 int con_backscroll;
38 // where next message will be printed
39 int con_current;
40 // offset in current line for next print
41 int con_x;
42 char con_text[CON_TEXTSIZE];
43
44 //seconds
45 cvar_t con_notifytime = {CVAR_SAVE, "con_notifytime","3"};
46 cvar_t con_notify = {CVAR_SAVE, "con_notify","4"};
47
48 #define MAX_NOTIFYLINES 32
49 // cl.time time the line was generated for transparent notify lines
50 float con_times[MAX_NOTIFYLINES];
51
52 int con_vislines;
53
54 #define MAXCMDLINE      256
55 extern char key_lines[32][MAXCMDLINE];
56 extern int edit_line;
57 extern int key_linepos;
58 extern int key_insert;
59
60
61 qboolean con_initialized;
62
63
64 /*
65 ==============================================================================
66
67 LOGGING
68
69 ==============================================================================
70 */
71
72 cvar_t log_file = {0, "log_file",""};
73 char crt_log_file [MAX_OSPATH] = "";
74 qfile_t* logfile = NULL;
75
76 qbyte* logqueue = NULL;
77 size_t logq_ind = 0;
78 size_t logq_size = 0;
79
80 void Log_ConPrint (const char *msg);
81
82 /*
83 ====================
84 Log_Timestamp
85 ====================
86 */
87 const char* Log_Timestamp (const char *desc)
88 {
89         static char timestamp [128];
90         time_t crt_time;
91         const struct tm *crt_tm;
92         char timestring [64];
93
94         // Build the time stamp (ex: "Wed Jun 30 21:49:08 1993");
95         time (&crt_time);
96         crt_tm = localtime (&crt_time);
97         strftime (timestring, sizeof (timestring), "%a %b %d %H:%M:%S %Y", crt_tm);
98
99         if (desc != NULL)
100                 dpsnprintf (timestamp, sizeof (timestamp), "====== %s (%s) ======\n", desc, timestring);
101         else
102                 dpsnprintf (timestamp, sizeof (timestamp), "====== %s ======\n", timestring);
103
104         return timestamp;
105 }
106
107
108 /*
109 ====================
110 Log_Init
111 ====================
112 */
113 void Log_Init (void)
114 {
115         // Allocate a log queue
116         logq_size = 512;
117         logqueue = Mem_Alloc (tempmempool, logq_size);
118         logq_ind = 0;
119
120         Cvar_RegisterVariable (&log_file);
121
122         // support for the classic Quake option
123 // COMMANDLINEOPTION: Console: -condebug logs console messages to qconsole.log, see also log_file
124         if (COM_CheckParm ("-condebug") != 0)
125                 Cvar_SetQuick (&log_file, "qconsole.log");
126 }
127
128
129 /*
130 ====================
131 Log_Open
132 ====================
133 */
134 void Log_Open (void)
135 {
136         if (logfile != NULL || log_file.string[0] == '\0')
137                 return;
138
139         logfile = FS_Open (log_file.string, "ab", false, false);
140         if (logfile != NULL)
141         {
142                 strlcpy (crt_log_file, log_file.string, sizeof (crt_log_file));
143                 FS_Print (logfile, Log_Timestamp ("Log started"));
144         }
145 }
146
147
148 /*
149 ====================
150 Log_Close
151 ====================
152 */
153 void Log_Close (void)
154 {
155         if (logfile == NULL)
156                 return;
157
158         FS_Print (logfile, Log_Timestamp ("Log stopped"));
159         FS_Print (logfile, "\n");
160         FS_Close (logfile);
161
162         logfile = NULL;
163         crt_log_file[0] = '\0';
164 }
165
166
167 /*
168 ====================
169 Log_Start
170 ====================
171 */
172 void Log_Start (void)
173 {
174         Log_Open ();
175
176         // Dump the contents of the log queue into the log file and free it
177         if (logqueue != NULL)
178         {
179                 if (logfile != NULL && logq_ind != 0)
180                         FS_Write (logfile, logqueue, logq_ind);
181                 Mem_Free (logqueue);
182                 logqueue = NULL;
183                 logq_ind = 0;
184                 logq_size = 0;
185         }
186 }
187
188
189 /*
190 ================
191 Log_ConPrint
192 ================
193 */
194 void Log_ConPrint (const char *msg)
195 {
196         static qboolean inprogress = false;
197
198         // don't allow feedback loops with memory error reports
199         if (inprogress)
200                 return;
201         inprogress = true;
202
203         // Until the host is completely initialized, we maintain a log queue
204         // to store the messages, since the log can't be started before
205         if (logqueue != NULL)
206         {
207                 size_t remain = logq_size - logq_ind;
208                 size_t len = strlen (msg);
209
210                 // If we need to enlarge the log queue
211                 if (len > remain)
212                 {
213                         unsigned int factor = ((logq_ind + len) / logq_size) + 1;
214                         qbyte* newqueue;
215
216                         logq_size *= factor;
217                         newqueue = Mem_Alloc (tempmempool, logq_size);
218                         memcpy (newqueue, logqueue, logq_ind);
219                         Mem_Free (logqueue);
220                         logqueue = newqueue;
221                         remain = logq_size - logq_ind;
222                 }
223                 memcpy (&logqueue[logq_ind], msg, len);
224                 logq_ind += len;
225
226                 inprogress = false;
227                 return;
228         }
229
230         // Check if log_file has changed
231         if (strcmp (crt_log_file, log_file.string) != 0)
232         {
233                 Log_Close ();
234                 Log_Open ();
235         }
236
237         // If a log file is available
238         if (logfile != NULL)
239                 FS_Print (logfile, msg);
240         inprogress = false;
241 }
242
243
244 /*
245 ================
246 Log_Printf
247 ================
248 */
249 void Log_Printf (const char *logfilename, const char *fmt, ...)
250 {
251         qfile_t *file;
252
253         file = FS_Open (logfilename, "ab", true, false);
254         if (file != NULL)
255         {
256                 va_list argptr;
257
258                 va_start (argptr, fmt);
259                 FS_VPrintf (file, fmt, argptr);
260                 va_end (argptr);
261
262                 FS_Close (file);
263         }
264 }
265
266
267 /*
268 ==============================================================================
269
270 CONSOLE
271
272 ==============================================================================
273 */
274
275 /*
276 ================
277 Con_ToggleConsole_f
278 ================
279 */
280 void Con_ToggleConsole_f (void)
281 {
282         // toggle the 'user wants console' bit
283         key_consoleactive ^= KEY_CONSOLEACTIVE_USER;
284         memset (con_times, 0, sizeof(con_times));
285 }
286
287 /*
288 ================
289 Con_Clear_f
290 ================
291 */
292 void Con_Clear_f (void)
293 {
294         if (con_text)
295                 memset (con_text, ' ', CON_TEXTSIZE);
296 }
297
298
299 /*
300 ================
301 Con_ClearNotify
302 ================
303 */
304 void Con_ClearNotify (void)
305 {
306         int i;
307
308         for (i=0 ; i<MAX_NOTIFYLINES ; i++)
309                 con_times[i] = 0;
310 }
311
312
313 /*
314 ================
315 Con_MessageMode_f
316 ================
317 */
318 void Con_MessageMode_f (void)
319 {
320         key_dest = key_message;
321         chat_team = false;
322 }
323
324
325 /*
326 ================
327 Con_MessageMode2_f
328 ================
329 */
330 void Con_MessageMode2_f (void)
331 {
332         key_dest = key_message;
333         chat_team = true;
334 }
335
336
337 /*
338 ================
339 Con_CheckResize
340
341 If the line width has changed, reformat the buffer.
342 ================
343 */
344 void Con_CheckResize (void)
345 {
346         int i, j, width, oldwidth, oldtotallines, numlines, numchars;
347         char tbuf[CON_TEXTSIZE];
348
349         width = (vid.conwidth >> 3);
350
351         if (width == con_linewidth)
352                 return;
353
354         if (width < 1)                  // video hasn't been initialized yet
355         {
356                 width = 80;
357                 con_linewidth = width;
358                 con_totallines = CON_TEXTSIZE / con_linewidth;
359                 memset (con_text, ' ', CON_TEXTSIZE);
360         }
361         else
362         {
363                 oldwidth = con_linewidth;
364                 con_linewidth = width;
365                 oldtotallines = con_totallines;
366                 con_totallines = CON_TEXTSIZE / con_linewidth;
367                 numlines = oldtotallines;
368
369                 if (con_totallines < numlines)
370                         numlines = con_totallines;
371
372                 numchars = oldwidth;
373
374                 if (con_linewidth < numchars)
375                         numchars = con_linewidth;
376
377                 memcpy (tbuf, con_text, CON_TEXTSIZE);
378                 memset (con_text, ' ', CON_TEXTSIZE);
379
380                 for (i=0 ; i<numlines ; i++)
381                 {
382                         for (j=0 ; j<numchars ; j++)
383                         {
384                                 con_text[(con_totallines - 1 - i) * con_linewidth + j] =
385                                                 tbuf[((con_current - i + oldtotallines) %
386                                                           oldtotallines) * oldwidth + j];
387                         }
388                 }
389
390                 Con_ClearNotify ();
391         }
392
393         con_backscroll = 0;
394         con_current = con_totallines - 1;
395 }
396
397 /*
398 ================
399 Con_Init
400 ================
401 */
402 void Con_Init (void)
403 {
404         memset (con_text, ' ', CON_TEXTSIZE);
405         con_linewidth = -1;
406         Con_CheckResize ();
407
408         // register our cvars
409         Cvar_RegisterVariable (&con_notifytime);
410         Cvar_RegisterVariable (&con_notify);
411
412         // register our commands
413         Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
414         Cmd_AddCommand ("messagemode", Con_MessageMode_f);
415         Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
416         Cmd_AddCommand ("clear", Con_Clear_f);
417
418         con_initialized = true;
419         Con_Print("Console initialized.\n");
420 }
421
422
423 /*
424 ===============
425 Con_Linefeed
426 ===============
427 */
428 void Con_Linefeed (void)
429 {
430         if (con_backscroll)
431                 con_backscroll++;
432
433         con_x = 0;
434         con_current++;
435         memset (&con_text[(con_current%con_totallines)*con_linewidth], ' ', con_linewidth);
436 }
437
438 /*
439 ================
440 Con_PrintToHistory
441
442 Handles cursor positioning, line wrapping, etc
443 All console printing must go through this in order to be displayed
444 If no console is visible, the notify window will pop up.
445 ================
446 */
447 void Con_PrintToHistory(const char *txt)
448 {
449         int y, c, l, mask;
450         static int cr;
451
452         if (txt[0] == 1 || txt[0] == 2)
453         {
454                 if (gamemode == GAME_NEXUIZ)
455                         mask = 0;
456                 else
457                         mask = 128;             // go to colored text
458                 txt++;
459         }
460         else
461                 mask = 0;
462
463
464         while ( (c = *txt) )
465         {
466         // count word length
467                 for (l=0 ; l< con_linewidth ; l++)
468                         if ( txt[l] <= ' ')
469                                 break;
470
471         // word wrap
472                 if (l != con_linewidth && (con_x + l > con_linewidth) )
473                         con_x = 0;
474
475                 txt++;
476
477                 if (cr)
478                 {
479                         con_current--;
480                         cr = false;
481                 }
482
483
484                 if (!con_x)
485                 {
486                         Con_Linefeed ();
487                 // mark time for transparent overlay
488                         if (con_current >= 0)
489                         {
490                                 if (con_notify.integer < 0)
491                                         Cvar_SetValueQuick(&con_notify, 0);
492                                 if (con_notify.integer > MAX_NOTIFYLINES)
493                                         Cvar_SetValueQuick(&con_notify, MAX_NOTIFYLINES);
494                                 if (con_notify.integer > 0)
495                                         con_times[con_current % con_notify.integer] = cl.time;
496                         }
497                 }
498
499                 switch (c)
500                 {
501                 case '\n':
502                         con_x = 0;
503                         break;
504
505                 case '\r':
506                         con_x = 0;
507                         cr = 1;
508                         break;
509
510                 default:        // display character and advance
511                         y = con_current % con_totallines;
512                         con_text[y*con_linewidth+con_x] = c | mask;
513                         con_x++;
514                         if (con_x >= con_linewidth)
515                                 con_x = 0;
516                         break;
517                 }
518
519         }
520
521         if( txt[0] == 1 ) {
522                 // play talk wav
523                 S_LocalSound ("sound/misc/talk.wav");
524         }
525 }
526
527 /* The translation table between the graphical font and plain ASCII  --KB */
528 static char qfont_table[256] = {
529         '\0', '#',  '#',  '#',  '#',  '.',  '#',  '#',
530         '#',  9,    10,   '#',  ' ',  13,   '.',  '.',
531         '[',  ']',  '0',  '1',  '2',  '3',  '4',  '5',
532         '6',  '7',  '8',  '9',  '.',  '<',  '=',  '>',
533         ' ',  '!',  '"',  '#',  '$',  '%',  '&',  '\'',
534         '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
535         '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
536         '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
537         '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
538         'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
539         'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
540         'X',  'Y',  'Z',  '[',  '\\', ']',  '^',  '_',
541         '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
542         'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
543         'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
544         'x',  'y',  'z',  '{',  '|',  '}',  '~',  '<',
545
546         '<',  '=',  '>',  '#',  '#',  '.',  '#',  '#',
547         '#',  '#',  ' ',  '#',  ' ',  '>',  '.',  '.',
548         '[',  ']',  '0',  '1',  '2',  '3',  '4',  '5',
549         '6',  '7',  '8',  '9',  '.',  '<',  '=',  '>',
550         ' ',  '!',  '"',  '#',  '$',  '%',  '&',  '\'',
551         '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
552         '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
553         '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
554         '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
555         'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
556         'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
557         'X',  'Y',  'Z',  '[',  '\\', ']',  '^',  '_',
558         '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
559         'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
560         'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
561         'x',  'y',  'z',  '{',  '|',  '}',  '~',  '<'
562 };
563
564 /*
565 ================
566 Con_Print
567
568 Prints to all appropriate console targets, and adds timestamps
569 ================
570 */
571 extern cvar_t timestamps;
572 extern cvar_t timeformat;
573 extern qboolean sys_nostdout;
574 void Con_Print(const char *msg)
575 {
576         static int index = 0;
577         static char line[16384];
578
579         for (;*msg;msg++)
580         {
581                 if (index == 0)
582                 {
583                         // if this is the beginning of a new line, print timestamp
584                         char *timestamp = timestamps.integer ? Sys_TimeString(timeformat.string) : "";
585                         // special color codes for chat messages must always come first
586                         // for Con_PrintToHistory to work properly
587                         if (*msg <= 2)
588                         {
589                                 if (gamemode == GAME_NEXUIZ)
590                                 {
591                                         line[index++] = '^';
592                                         line[index++] = '3';
593                                         msg++;
594                                 }
595                                 else
596                                         line[index++] = *msg++;
597                         }
598                         // store timestamp
599                         for (;*timestamp;index++, timestamp++)
600                                 if (index < sizeof(line) - 2)
601                                         line[index] = *timestamp;
602                 }
603                 // append the character
604                 line[index++] = *msg;
605                 // if this is a newline character, we have a complete line to print
606                 if (*msg == '\n' || index >= 16000)
607                 {
608                         // terminate the line
609                         line[index] = 0;
610                         // send to log file
611                         Log_ConPrint(line);
612                         // send to scrollable buffer
613                         if (con_initialized && cls.state != ca_dedicated)
614                                 Con_PrintToHistory(line);
615                         // send to terminal or dedicated server window
616                         if (!sys_nostdout)
617                         {
618                                 unsigned char *p;
619                                 for (p = (unsigned char *) line;*p; p++)
620                                         *p = qfont_table[*p];
621                                 Sys_PrintToTerminal(line);
622                         }
623                         // empty the line buffer
624                         index = 0;
625                 }
626         }
627 }
628
629
630 // LordHavoc: increased from 4096 to 16384
631 #define MAXPRINTMSG     16384
632
633 /*
634 ================
635 Con_Printf
636
637 Prints to all appropriate console targets
638 ================
639 */
640 void Con_Printf(const char *fmt, ...)
641 {
642         va_list argptr;
643         char msg[MAXPRINTMSG];
644
645         va_start(argptr,fmt);
646         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
647         va_end(argptr);
648
649         Con_Print(msg);
650 }
651
652 /*
653 ================
654 Con_DPrint
655
656 A Con_Print that only shows up if the "developer" cvar is set
657 ================
658 */
659 void Con_DPrint(const char *msg)
660 {
661         if (!developer.integer)
662                 return;                 // don't confuse non-developers with techie stuff...
663         Con_Print(msg);
664 }
665
666 /*
667 ================
668 Con_DPrintf
669
670 A Con_Printf that only shows up if the "developer" cvar is set
671 ================
672 */
673 void Con_DPrintf(const char *fmt, ...)
674 {
675         va_list argptr;
676         char msg[MAXPRINTMSG];
677
678         if (!developer.integer)
679                 return;                 // don't confuse non-developers with techie stuff...
680
681         va_start(argptr,fmt);
682         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
683         va_end(argptr);
684
685         Con_Print(msg);
686 }
687
688
689 /*
690 ==============================================================================
691
692 DRAWING
693
694 ==============================================================================
695 */
696
697 static vec4_t _con_colors[] =
698 {
699         // Quake3 colors
700         // LordHavoc: why on earth is cyan before magenta in Quake3?
701         // LordHavoc: note: Doom3 uses white for [0] and [7]
702         {0.0, 0.0, 0.0, 1.0}, // black
703         {1.0, 0.0, 0.0, 1.0}, // red
704         {0.0, 1.0, 0.0, 1.0}, // green
705         {1.0, 1.0, 0.0, 1.0}, // yellow
706         {0.0, 0.0, 1.0, 1.0}, // blue
707         {0.0, 1.0, 1.0, 1.0}, // cyan
708         {1.0, 0.0, 1.0, 1.0}, // magenta
709         {1.0, 1.0, 1.0, 1.0}  // white
710         // Black's color table
711         //{1.0, 1.0, 1.0, 1.0},
712         //{1.0, 0.0, 0.0, 1.0},
713         //{0.0, 1.0, 0.0, 1.0},
714         //{0.0, 0.0, 1.0, 1.0},
715         //{1.0, 1.0, 0.0, 1.0},
716         //{0.0, 1.0, 1.0, 1.0},
717         //{1.0, 0.0, 1.0, 1.0},
718         //{0.1, 0.1, 0.1, 1.0}
719 };
720
721 #define _con_colors_count       (sizeof(_con_colors) / sizeof(vec3_t))
722 #define _con_color_tag          '^'
723
724 // color is read and changed in the end
725 static void _Con_DrawString( float x, float y, const char *text, int maxlen, float scalex, float scaley, int flags )
726 {
727         vec_t *color;
728         const char *first, *last;
729         int len;
730
731         color = _con_colors[7];
732         if( maxlen < 1)
733                 len = strlen( text );
734         else
735                 len = min( maxlen, (signed) strlen( text ));
736
737     first = last = text;
738         while( 1 ) {
739                 // iterate until we get the next color tag or reach the end of the text part to draw
740                 for( ; len && *last != _con_color_tag ; len--, last++ )
741                         ;
742                 // only draw the partial string if we have read anything
743                 if( last != first ) {
744                         // draw the string
745                         DrawQ_String( x, y, first, last - first, scalex, scaley, color[0], color[1], color[2], color[3], flags );
746                         // update x to be at the new start position
747                         x += (last - first) * scalex;
748                         // if we have reached the end, we have finished
749                         if( !len )
750                                 break;
751                 }
752                 first = last;
753                 // jump over the tag
754                 last++;
755                 len--;
756                 if( len && '0' <= *last && *last <= '9' ) {
757                         int index = 0;
758
759                         while( '0' <= *last && *last <= '9' && len ) {
760                                 index = index * 10 + *last - '0';
761                                 if( index < _con_colors_count ) {
762                                         last++;
763                                         len--;
764                                 } else {
765                                         index /= 10;
766                                         break;
767                                 }
768                         }
769
770                         color = _con_colors[index];
771                         // we dont want to display the color tag and the color index
772                         first = last;
773                 }
774         }
775 }
776
777 /*
778 ================
779 Con_DrawInput
780
781 The input line scrolls horizontally if typing goes beyond the right edge
782
783 Modified by EvilTypeGuy eviltypeguy@qeradiant.com
784 ================
785 */
786 void Con_DrawInput (void)
787 {
788         int             y;
789         int             i;
790         char editlinecopy[257], *text;
791
792         if (!key_consoleactive)
793                 return;         // don't draw anything
794
795         text = strcpy(editlinecopy, key_lines[edit_line]);
796
797         // Advanced Console Editing by Radix radix@planetquake.com
798         // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
799         // use strlen of edit_line instead of key_linepos to allow editing
800         // of early characters w/o erasing
801
802         y = strlen(text);
803
804 // fill out remainder with spaces
805         for (i = y; i < 256; i++)
806                 text[i] = ' ';
807
808         // add the cursor frame
809         if ((int)(realtime*con_cursorspeed) & 1)                // cursor is visible
810                 text[key_linepos] = 11 + 130 * key_insert;      // either solid or triangle facing right
811
812 //      text[key_linepos + 1] = 0;
813
814         // prestep if horizontally scrolling
815         if (key_linepos >= con_linewidth)
816                 text += 1 + key_linepos - con_linewidth;
817
818         // draw it
819         _Con_DrawString(0, con_vislines - 16, text, con_linewidth, 8, 8, 0);
820
821         // remove cursor
822 //      key_lines[edit_line][key_linepos] = 0;
823 }
824
825
826 /*
827 ================
828 Con_DrawNotify
829
830 Draws the last few lines of output transparently over the game top
831 ================
832 */
833 void Con_DrawNotify (void)
834 {
835         int             x, v;
836         char    *text;
837         int             i;
838         float   time;
839         extern char chat_buffer[];
840         char    temptext[256];
841
842         if (con_notify.integer < 0)
843                 Cvar_SetValueQuick(&con_notify, 0);
844         if (con_notify.integer > MAX_NOTIFYLINES)
845                 Cvar_SetValueQuick(&con_notify, MAX_NOTIFYLINES);
846         if (gamemode == GAME_TRANSFUSION)
847                 v = 8;
848         else
849                 v = 0;
850         for (i= con_current-con_notify.integer+1 ; i<=con_current ; i++)
851         {
852                 if (i < 0)
853                         continue;
854                 time = con_times[i % con_notify.integer];
855                 if (time == 0)
856                         continue;
857                 time = cl.time - time;
858                 if (time > con_notifytime.value)
859                         continue;
860                 text = con_text + (i % con_totallines)*con_linewidth;
861
862                 if (gamemode == GAME_NEXUIZ) {
863                         int linewidth;
864
865                         for (linewidth = con_linewidth; linewidth && text[linewidth-1] == ' '; linewidth--);
866                         x = (vid.conwidth - linewidth * 8) / 2;
867                 } else
868                         x = 0;
869
870                 _Con_DrawString(x, v, text, con_linewidth, 8, 8, 0);
871
872                 v += 8;
873         }
874
875
876         if (key_dest == key_message)
877         {
878                 x = 0;
879
880                 // LordHavoc: speedup, and other improvements
881                 if (chat_team)
882                         sprintf(temptext, "say_team:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
883                 else
884                         sprintf(temptext, "say:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
885                 while (strlen(temptext) >= (size_t) con_linewidth)
886                 {
887                         _Con_DrawString (0, v, temptext, con_linewidth, 8, 8, 0);
888                         strcpy(temptext, &temptext[con_linewidth]);
889                         v += 8;
890                 }
891                 if (strlen(temptext) > 0)
892                 {
893                         _Con_DrawString (0, v, temptext, 0, 8, 8, 0);
894                         v += 8;
895                 }
896         }
897 }
898
899 /*
900 ================
901 Con_DrawConsole
902
903 Draws the console with the solid background
904 The typing input line at the bottom should only be drawn if typing is allowed
905 ================
906 */
907 extern char engineversion[40];
908 void Con_DrawConsole (int lines)
909 {
910         int i, y, rows, j;
911         char *text;
912
913         if (lines <= 0)
914                 return;
915
916 // draw the background
917         if (scr_conbrightness.value >= 0.01f)
918                 DrawQ_Pic(0, lines - vid.conheight, "gfx/conback", vid.conwidth, vid.conheight, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, scr_conalpha.value, 0);
919         else
920                 DrawQ_Fill(0, lines - vid.conheight, vid.conwidth, vid.conheight, 0, 0, 0, scr_conalpha.value, 0);
921         DrawQ_String(vid.conwidth - strlen(engineversion) * 8 - 8, lines - 8, engineversion, 0, 8, 8, 1, 0, 0, 1, 0);
922
923 // draw the text
924         con_vislines = lines;
925
926         rows = (lines-16)>>3;           // rows of text to draw
927         y = lines - 16 - (rows<<3);     // may start slightly negative
928
929         for (i = con_current - rows + 1;i <= con_current;i++, y += 8)
930         {
931                 j = max(i - con_backscroll, 0);
932                 text = con_text + (j % con_totallines)*con_linewidth;
933
934                 _Con_DrawString(0, y, text, con_linewidth, 8, 8, 0);
935         }
936
937 // draw the input prompt, user text, and cursor if desired
938         Con_DrawInput ();
939 }
940
941 /*
942         Con_DisplayList
943
944         New function for tab-completion system
945         Added by EvilTypeGuy
946         MEGA Thanks to Taniwha
947
948 */
949 void Con_DisplayList(const char **list)
950 {
951         int i = 0, pos = 0, len = 0, maxlen = 0, width = (con_linewidth - 4);
952         const char **walk = list;
953
954         while (*walk) {
955                 len = strlen(*walk);
956                 if (len > maxlen)
957                         maxlen = len;
958                 walk++;
959         }
960         maxlen += 1;
961
962         while (*list) {
963                 len = strlen(*list);
964                 if (pos + maxlen >= width) {
965                         Con_Print("\n");
966                         pos = 0;
967                 }
968
969                 Con_Print(*list);
970                 for (i = 0; i < (maxlen - len); i++)
971                         Con_Print(" ");
972
973                 pos += maxlen;
974                 list++;
975         }
976
977         if (pos)
978                 Con_Print("\n\n");
979 }
980
981 /*
982         Con_CompleteCommandLine
983
984         New function for tab-completion system
985         Added by EvilTypeGuy
986         Thanks to Fett erich@heintz.com
987         Thanks to taniwha
988
989 */
990 void Con_CompleteCommandLine (void)
991 {
992         const char *cmd = "", *s;
993         const char **list[3] = {0, 0, 0};
994         int c, v, a, i, cmd_len;
995
996         s = key_lines[edit_line] + 1;
997         // Count number of possible matches
998         c = Cmd_CompleteCountPossible(s);
999         v = Cvar_CompleteCountPossible(s);
1000         a = Cmd_CompleteAliasCountPossible(s);
1001
1002         if (!(c + v + a))       // No possible matches
1003                 return;
1004
1005         if (c + v + a == 1) {
1006                 if (c)
1007                         list[0] = Cmd_CompleteBuildList(s);
1008                 else if (v)
1009                         list[0] = Cvar_CompleteBuildList(s);
1010                 else
1011                         list[0] = Cmd_CompleteAliasBuildList(s);
1012                 cmd = *list[0];
1013                 cmd_len = strlen (cmd);
1014         } else {
1015                 if (c)
1016                         cmd = *(list[0] = Cmd_CompleteBuildList(s));
1017                 if (v)
1018                         cmd = *(list[1] = Cvar_CompleteBuildList(s));
1019                 if (a)
1020                         cmd = *(list[2] = Cmd_CompleteAliasBuildList(s));
1021
1022                 cmd_len = strlen (s);
1023                 do {
1024                         for (i = 0; i < 3; i++) {
1025                                 char ch = cmd[cmd_len];
1026                                 const char **l = list[i];
1027                                 if (l) {
1028                                         while (*l && (*l)[cmd_len] == ch)
1029                                                 l++;
1030                                         if (*l)
1031                                                 break;
1032                                 }
1033                         }
1034                         if (i == 3)
1035                                 cmd_len++;
1036                 } while (i == 3);
1037                 // 'quakebar'
1038                 Con_Print("\n\35");
1039                 for (i = 0; i < con_linewidth - 4; i++)
1040                         Con_Print("\36");
1041                 Con_Print("\37\n");
1042
1043                 // Print Possible Commands
1044                 if (c) {
1045                         Con_Printf("%i possible command%s\n", c, (c > 1) ? "s: " : ":");
1046                         Con_DisplayList(list[0]);
1047                 }
1048
1049                 if (v) {
1050                         Con_Printf("%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
1051                         Con_DisplayList(list[1]);
1052                 }
1053
1054                 if (a) {
1055                         Con_Printf("%i possible aliases%s\n", a, (a > 1) ? "s: " : ":");
1056                         Con_DisplayList(list[2]);
1057                 }
1058         }
1059
1060         if (cmd) {
1061                 strncpy(key_lines[edit_line] + 1, cmd, cmd_len);
1062                 key_linepos = cmd_len + 1;
1063                 if (c + v + a == 1) {
1064                         key_lines[edit_line][key_linepos] = ' ';
1065                         key_linepos++;
1066                 }
1067                 key_lines[edit_line][key_linepos] = 0;
1068         }
1069         for (i = 0; i < 3; i++)
1070                 if (list[i])
1071                         Mem_Free((void *)list[i]);
1072 }
1073