vertex arrays renamed to varray_ and exposed to rest of engine
[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 #ifdef NeXT
23 #include <libc.h>
24 #endif
25 #ifndef _MSC_VER
26 #ifndef __BORLANDC__
27 #include <unistd.h>
28 #endif
29 #endif
30 #ifdef WIN32
31 #include <io.h>
32 #endif
33 #include <fcntl.h>
34 #include "quakedef.h"
35
36 int             con_linewidth;
37
38 float           con_cursorspeed = 4;
39
40 #define         CON_TEXTSIZE    16384
41
42 int                     con_totallines;         // total lines in console scrollback
43 int                     con_backscroll;         // lines up from bottom to display
44 int                     con_current;            // where next message will be printed
45 int                     con_x;                          // offset in current line for next print
46 char            *con_text = 0;
47
48 cvar_t          con_notifytime = {CVAR_SAVE, "con_notifytime","3"};     //seconds
49 cvar_t          logfile = {0, "logfile","0"};
50
51 #define NUM_CON_TIMES 4
52 float           con_times[NUM_CON_TIMES];       // realtime time the line was generated
53                                                 // for transparent notify lines
54
55 int                     con_vislines;
56
57 qboolean        con_debuglog;
58
59 #define MAXCMDLINE      256
60 extern  char    key_lines[32][MAXCMDLINE];
61 extern  int             edit_line;
62 extern  int             key_linepos;
63 extern  int             key_insert;
64
65
66 qboolean        con_initialized;
67
68 mempool_t       *console_mempool;
69
70 int             con_notifylines;                // scan lines to clear for notify lines
71
72 extern void M_Menu_Main_f (void);
73
74 /*
75 ================
76 Con_ToggleConsole_f
77 ================
78 */
79 void Con_ToggleConsole_f (void)
80 {
81         // toggle the 'user wants console' bit
82         key_consoleactive ^= KEY_CONSOLEACTIVE_USER;
83         memset (con_times, 0, sizeof(con_times));
84 }
85
86 /*
87 ================
88 Con_Clear_f
89 ================
90 */
91 void Con_Clear_f (void)
92 {
93         if (con_text)
94                 memset (con_text, ' ', CON_TEXTSIZE);
95 }
96
97
98 /*
99 ================
100 Con_ClearNotify
101 ================
102 */
103 void Con_ClearNotify (void)
104 {
105         int             i;
106
107         for (i=0 ; i<NUM_CON_TIMES ; i++)
108                 con_times[i] = 0;
109 }
110
111
112 /*
113 ================
114 Con_MessageMode_f
115 ================
116 */
117 extern qboolean team_message;
118
119 void Con_MessageMode_f (void)
120 {
121         key_dest = key_message;
122         team_message = false;
123 }
124
125
126 /*
127 ================
128 Con_MessageMode2_f
129 ================
130 */
131 void Con_MessageMode2_f (void)
132 {
133         key_dest = key_message;
134         team_message = true;
135 }
136
137
138 /*
139 ================
140 Con_CheckResize
141
142 If the line width has changed, reformat the buffer.
143 ================
144 */
145 void Con_CheckResize (void)
146 {
147         int             i, j, width, oldwidth, oldtotallines, numlines, numchars;
148         char    tbuf[CON_TEXTSIZE];
149
150         width = (vid.conwidth >> 3);
151
152         if (width == con_linewidth)
153                 return;
154
155         if (width < 1)                  // video hasn't been initialized yet
156         {
157                 width = 80;
158                 con_linewidth = width;
159                 con_totallines = CON_TEXTSIZE / con_linewidth;
160                 memset (con_text, ' ', CON_TEXTSIZE);
161         }
162         else
163         {
164                 oldwidth = con_linewidth;
165                 con_linewidth = width;
166                 oldtotallines = con_totallines;
167                 con_totallines = CON_TEXTSIZE / con_linewidth;
168                 numlines = oldtotallines;
169
170                 if (con_totallines < numlines)
171                         numlines = con_totallines;
172
173                 numchars = oldwidth;
174
175                 if (con_linewidth < numchars)
176                         numchars = con_linewidth;
177
178                 memcpy (tbuf, con_text, CON_TEXTSIZE);
179                 memset (con_text, ' ', CON_TEXTSIZE);
180
181                 for (i=0 ; i<numlines ; i++)
182                 {
183                         for (j=0 ; j<numchars ; j++)
184                         {
185                                 con_text[(con_totallines - 1 - i) * con_linewidth + j] =
186                                                 tbuf[((con_current - i + oldtotallines) %
187                                                           oldtotallines) * oldwidth + j];
188                         }
189                 }
190
191                 Con_ClearNotify ();
192         }
193
194         con_backscroll = 0;
195         con_current = con_totallines - 1;
196 }
197
198
199 /*
200 ================
201 Con_Init
202 ================
203 */
204 void Con_Init (void)
205 {
206 #define MAXGAMEDIRLEN   1000
207         char    temp[MAXGAMEDIRLEN+1];
208         char    *t2 = "/qconsole.log";
209
210         Cvar_RegisterVariable(&logfile);
211         con_debuglog = COM_CheckParm("-condebug");
212
213         if (con_debuglog)
214         {
215                 if (strlen (com_gamedir) < (MAXGAMEDIRLEN - strlen (t2)))
216                 {
217                         sprintf (temp, "%s%s", com_gamedir, t2);
218                         unlink (temp);
219                 }
220                 logfile.integer = 1;
221         }
222
223         console_mempool = Mem_AllocPool("console");
224         con_text = Mem_Alloc(console_mempool, CON_TEXTSIZE);
225         memset (con_text, ' ', CON_TEXTSIZE);
226         con_linewidth = -1;
227         Con_CheckResize ();
228
229         Con_Printf ("Console initialized.\n");
230
231 //
232 // register our commands
233 //
234         Cvar_RegisterVariable (&con_notifytime);
235
236         Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
237         Cmd_AddCommand ("messagemode", Con_MessageMode_f);
238         Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
239         Cmd_AddCommand ("clear", Con_Clear_f);
240         con_initialized = true;
241 }
242
243
244 /*
245 ===============
246 Con_Linefeed
247 ===============
248 */
249 void Con_Linefeed (void)
250 {
251         con_x = 0;
252         con_current++;
253         memset (&con_text[(con_current%con_totallines)*con_linewidth], ' ', con_linewidth);
254 }
255
256 /*
257 ================
258 Con_Print
259
260 Handles cursor positioning, line wrapping, etc
261 All console printing must go through this in order to be logged to disk
262 If no console is visible, the notify window will pop up.
263 ================
264 */
265 void Con_Print (char *txt)
266 {
267         int             y;
268         int             c, l;
269         static int      cr;
270         int             mask;
271
272         con_backscroll = 0;
273
274         if (txt[0] == 1)
275         {
276                 mask = 128;             // go to colored text
277                 S_LocalSound ("misc/talk.wav");
278         // play talk wav
279                 txt++;
280         }
281         else if (txt[0] == 2)
282         {
283                 mask = 128;             // go to colored text
284                 txt++;
285         }
286         else
287                 mask = 0;
288
289
290         while ( (c = *txt) )
291         {
292         // count word length
293                 for (l=0 ; l< con_linewidth ; l++)
294                         if ( txt[l] <= ' ')
295                                 break;
296
297         // word wrap
298                 if (l != con_linewidth && (con_x + l > con_linewidth) )
299                         con_x = 0;
300
301                 txt++;
302
303                 if (cr)
304                 {
305                         con_current--;
306                         cr = false;
307                 }
308
309
310                 if (!con_x)
311                 {
312                         Con_Linefeed ();
313                 // mark time for transparent overlay
314                         if (con_current >= 0)
315                                 con_times[con_current % NUM_CON_TIMES] = realtime;
316                 }
317
318                 switch (c)
319                 {
320                 case '\n':
321                         con_x = 0;
322                         break;
323
324                 case '\r':
325                         con_x = 0;
326                         cr = 1;
327                         break;
328
329                 default:        // display character and advance
330                         y = con_current % con_totallines;
331                         con_text[y*con_linewidth+con_x] = c | mask;
332                         con_x++;
333                         if (con_x >= con_linewidth)
334                                 con_x = 0;
335                         break;
336                 }
337
338         }
339 }
340
341
342 /*
343 ================
344 Con_DebugLog
345 ================
346 */
347 void Con_DebugLog(char *file, char *fmt, ...)
348 {
349     va_list argptr;
350     FILE* fd;
351
352     fd = fopen(file, "at");
353     va_start(argptr, fmt);
354     vfprintf (fd, fmt, argptr);
355     va_end(argptr);
356     fclose(fd);
357 }
358
359
360 /*
361 ================
362 Con_Printf
363
364 Handles cursor positioning, line wrapping, etc
365 ================
366 */
367 // LordHavoc: increased from 4096 to 16384
368 #define MAXPRINTMSG     16384
369 // FIXME: make a buffer size safe vsprintf?
370 void Con_Printf (char *fmt, ...)
371 {
372         va_list         argptr;
373         char            msg[MAXPRINTMSG];
374
375         va_start (argptr,fmt);
376         vsprintf (msg,fmt,argptr);
377         va_end (argptr);
378
379 // also echo to debugging console
380         Sys_Printf ("%s", msg);
381
382 // log all messages to file
383         if (con_debuglog)
384         {
385                 // can't use va() here because it might overwrite other important things
386                 char logname[MAX_OSPATH];
387                 sprintf(logname, "%s/qconsole.log", com_gamedir);
388                 Con_DebugLog(logname, "%s", msg);
389         }
390
391         if (!con_initialized)
392                 return;
393
394         if (cls.state == ca_dedicated)
395                 return;         // no graphics mode
396
397 // write it to the scrollable buffer
398         Con_Print (msg);
399 }
400
401 /*
402 ================
403 Con_DPrintf
404
405 A Con_Printf that only shows up if the "developer" cvar is set
406 ================
407 */
408 void Con_DPrintf (char *fmt, ...)
409 {
410         va_list         argptr;
411         char            msg[MAXPRINTMSG];
412
413         if (!developer.integer)
414                 return;                 // don't confuse non-developers with techie stuff...
415
416         va_start (argptr,fmt);
417         vsprintf (msg,fmt,argptr);
418         va_end (argptr);
419
420         Con_Printf ("%s", msg);
421 }
422
423
424 /*
425 ==================
426 Con_SafePrintf
427
428 Okay to call even when the screen can't be updated
429 ==================
430 */
431 void Con_SafePrintf (char *fmt, ...)
432 {
433         va_list         argptr;
434         char            msg[1024];
435
436         va_start (argptr,fmt);
437         vsprintf (msg,fmt,argptr);
438         va_end (argptr);
439
440         Con_Printf ("%s", msg);
441 }
442
443
444 /*
445 ==============================================================================
446
447 DRAWING
448
449 ==============================================================================
450 */
451
452
453 /*
454 ================
455 Con_DrawInput
456
457 The input line scrolls horizontally if typing goes beyond the right edge
458
459 Modified by EvilTypeGuy eviltypeguy@qeradiant.com
460 ================
461 */
462 void Con_DrawInput (void)
463 {
464         char editlinecopy[256], *text;
465
466         if (!key_consoleactive)
467                 return;         // don't draw anything
468
469         text = strcpy(editlinecopy, key_lines[edit_line]);
470
471         // Advanced Console Editing by Radix radix@planetquake.com
472         // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
473         // use strlen of edit_line instead of key_linepos to allow editing
474         // of early characters w/o erasing
475
476         // add the cursor frame
477         if ((int)(realtime*con_cursorspeed) & 1)                // cursor is visible
478                 text[key_linepos] = 11 + 130 * key_insert;      // either solid or triangle facing right
479
480         text[key_linepos + 1] = 0;
481
482         // prestep if horizontally scrolling
483         if (key_linepos >= con_linewidth)
484                 text += 1 + key_linepos - con_linewidth;
485
486         // draw it
487         DrawQ_String(0, con_vislines - 16, text, con_linewidth, 8, 8, 1, 1, 1, 1, 0);
488
489         // remove cursor
490         key_lines[edit_line][key_linepos] = 0;
491 }
492
493
494 /*
495 ================
496 Con_DrawNotify
497
498 Draws the last few lines of output transparently over the game top
499 ================
500 */
501 void Con_DrawNotify (void)
502 {
503         int             x, v;
504         char    *text;
505         int             i;
506         float   time;
507         extern char chat_buffer[];
508         char    temptext[256];
509
510         v = 0;
511         for (i= con_current-NUM_CON_TIMES+1 ; i<=con_current ; i++)
512         {
513                 if (i < 0)
514                         continue;
515                 time = con_times[i % NUM_CON_TIMES];
516                 if (time == 0)
517                         continue;
518                 time = realtime - time;
519                 if (time > con_notifytime.value)
520                         continue;
521                 text = con_text + (i % con_totallines)*con_linewidth;
522
523                 clearnotify = 0;
524
525                 DrawQ_String(0, v, text, con_linewidth, 8, 8, 1, 1, 1, 1, 0);
526
527                 v += 8;
528         }
529
530
531         if (key_dest == key_message)
532         {
533                 clearnotify = 0;
534
535                 x = 0;
536
537                 // LordHavoc: speedup, and other improvements
538                 if (team_message)
539                         sprintf(temptext, "say_team:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
540                 else
541                         sprintf(temptext, "say:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
542                 while (strlen(temptext) >= con_linewidth)
543                 {
544                         DrawQ_String (0, v, temptext, con_linewidth, 8, 8, 1, 1, 1, 1, 0);
545                         strcpy(temptext, &temptext[con_linewidth]);
546                         v += 8;
547                 }
548                 if (strlen(temptext) > 0)
549                 {
550                         DrawQ_String (0, v, temptext, 0, 8, 8, 1, 1, 1, 1, 0);
551                         v += 8;
552                 }
553         }
554
555         if (v > con_notifylines)
556                 con_notifylines = v;
557 }
558
559 /*
560 ================
561 Con_DrawConsole
562
563 Draws the console with the solid background
564 The typing input line at the bottom should only be drawn if typing is allowed
565 ================
566 */
567 extern cvar_t scr_conalpha;
568 extern char engineversion[40];
569 void Con_DrawConsole (int lines)
570 {
571         int                             i, y;
572         int                             rows;
573         char                    *text;
574         int                             j;
575
576         if (lines <= 0)
577                 return;
578
579 // draw the background
580         DrawQ_Pic(0, lines - vid.conheight, "gfx/conback", vid.conwidth, vid.conheight, 1, 1, 1, scr_conalpha.value * lines / vid.conheight, 0);
581         DrawQ_String(vid.conwidth - strlen(engineversion) * 8 - 8, lines - 8, engineversion, 0, 8, 8, 1, 0, 0, 1, 0);
582
583 // draw the text
584         con_vislines = lines;
585
586         rows = (lines-16)>>3;           // rows of text to draw
587         y = lines - 16 - (rows<<3);     // may start slightly negative
588
589         for (i = con_current - rows + 1;i <= con_current;i++, y += 8)
590         {
591                 j = max(i - con_backscroll, 0);
592                 text = con_text + (j % con_totallines)*con_linewidth;
593
594                 DrawQ_String(0, y, text, con_linewidth, 8, 8, 1, 1, 1, 1, 0);
595         }
596
597 // draw the input prompt, user text, and cursor if desired
598         Con_DrawInput ();
599 }
600
601 /*
602         Con_DisplayList
603
604         New function for tab-completion system
605         Added by EvilTypeGuy
606         MEGA Thanks to Taniwha
607
608 */
609 void
610 Con_DisplayList(char **list)
611 {
612         int     i = 0;
613         int     pos = 0;
614         int     len = 0;
615         int     maxlen = 0;
616         int     width = (con_linewidth - 4);
617         char    **walk = list;
618
619         while (*walk) {
620                 len = strlen(*walk);
621                 if (len > maxlen)
622                         maxlen = len;
623                 walk++;
624         }
625         maxlen += 1;
626
627         while (*list) {
628                 len = strlen(*list);
629                 if (pos + maxlen >= width) {
630                         Con_Printf("\n");
631                         pos = 0;
632                 }
633
634                 Con_Printf("%s", *list);
635                 for (i = 0; i < (maxlen - len); i++)
636                         Con_Printf(" ");
637
638                 pos += maxlen;
639                 list++;
640         }
641
642         if (pos)
643                 Con_Printf("\n\n");
644 }
645
646 /*
647         Con_CompleteCommandLine
648
649         New function for tab-completion system
650         Added by EvilTypeGuy
651         Thanks to Fett erich@heintz.com
652         Thanks to taniwha
653
654 */
655 void
656 Con_CompleteCommandLine (void)
657 {
658         char    *cmd = "";
659         char    *s;
660         int             c, v, a, i;
661         int             cmd_len;
662         char    **list[3] = {0, 0, 0};
663
664         s = key_lines[edit_line] + 1;
665         // Count number of possible matches
666         c = Cmd_CompleteCountPossible(s);
667         v = Cvar_CompleteCountPossible(s);
668         a = Cmd_CompleteAliasCountPossible(s);
669
670         if (!(c + v + a))       // No possible matches
671                 return;
672
673         if (c + v + a == 1) {
674                 if (c)
675                         list[0] = Cmd_CompleteBuildList(s);
676                 else if (v)
677                         list[0] = Cvar_CompleteBuildList(s);
678                 else
679                         list[0] = Cmd_CompleteAliasBuildList(s);
680                 cmd = *list[0];
681                 cmd_len = strlen (cmd);
682         } else {
683                 if (c)
684                         cmd = *(list[0] = Cmd_CompleteBuildList(s));
685                 if (v)
686                         cmd = *(list[1] = Cvar_CompleteBuildList(s));
687                 if (a)
688                         cmd = *(list[2] = Cmd_CompleteAliasBuildList(s));
689
690                 cmd_len = strlen (s);
691                 do {
692                         for (i = 0; i < 3; i++) {
693                                 char ch = cmd[cmd_len];
694                                 char **l = list[i];
695                                 if (l) {
696                                         while (*l && (*l)[cmd_len] == ch)
697                                                 l++;
698                                         if (*l)
699                                                 break;
700                                 }
701                         }
702                         if (i == 3)
703                                 cmd_len++;
704                 } while (i == 3);
705                 // 'quakebar'
706                 Con_Printf("\n\35");
707                 for (i = 0; i < con_linewidth - 4; i++)
708                         Con_Printf("\36");
709                 Con_Printf("\37\n");
710
711                 // Print Possible Commands
712                 if (c) {
713                         Con_Printf("%i possible command%s\n", c, (c > 1) ? "s: " : ":");
714                         Con_DisplayList(list[0]);
715                 }
716
717                 if (v) {
718                         Con_Printf("%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
719                         Con_DisplayList(list[1]);
720                 }
721
722                 if (a) {
723                         Con_Printf("%i possible aliases%s\n", a, (a > 1) ? "s: " : ":");
724                         Con_DisplayList(list[2]);
725                 }
726         }
727
728         if (cmd) {
729                 strncpy(key_lines[edit_line] + 1, cmd, cmd_len);
730                 key_linepos = cmd_len + 1;
731                 if (c + v + a == 1) {
732                         key_lines[edit_line][key_linepos] = ' ';
733                         key_linepos++;
734                 }
735                 key_lines[edit_line][key_linepos] = 0;
736         }
737         for (i = 0; i < 3; i++)
738                 if (list[i])
739                         Mem_Free(list[i]);
740 }
741