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 #include <unistd.h>
  27 #endif
  28 #include <fcntl.h>
  29 #include "quakedef.h"
  30
  31 int             con_linewidth;
  32
  33 float           con_cursorspeed = 4;
  34
  35 #define         CON_TEXTSIZE    16384
  36
  37 qboolean        con_forcedup;           // because no entities to refresh
  38
  39 int                     con_totallines;         // total lines in console scrollback
  40 int                     con_backscroll;         // lines up from bottom to display
  41 int                     con_current;            // where next message will be printed
  42 int                     con_x;                          // offset in current line for next print
  43 char            *con_text=0;
  44
  45 cvar_t          con_notifytime = {"con_notifytime","3"};                //seconds
  46
  47 #define NUM_CON_TIMES 4
  48 float           con_times[NUM_CON_TIMES];       // realtime time the line was generated
  49                                                                 // for transparent notify lines
  50
  51 int                     con_vislines;
  52
  53 qboolean        con_debuglog;
  54
  55 #define         MAXCMDLINE      256
  56 extern  char    key_lines[32][MAXCMDLINE];
  57 extern  int             edit_line;
  58 extern  int             key_linepos;
  59
  60
  61 qboolean        con_initialized;
  62
  63 int                     con_notifylines;                // scan lines to clear for notify lines
  64
  65 extern void M_Menu_Main_f (void);
  66
  67 void M_OSK_Draw (void);
  68 void Con_OSK_f (char *input, char *output, int outlen);
  69 void Con_OSK_Key(int key);
  70 void Con_DrawOSK(void);
  71
  72 /*
  73 ================
  74 Con_ToggleConsole_f
  75 ================
  76 */
  77 void Con_ToggleConsole_f (void)
  78 {
  79         if (key_dest == key_console)
  80         {
  81                 if (cls.state == ca_connected)
  82                 {
  83                         key_dest = key_game;
  84                         key_lines[edit_line][1] = 0;    // clear any typing
  85                         key_linepos = 1;
  86                 }
  87                 else
  88                 {
  89                         M_Menu_Main_f ();
  90                 }
  91         }
  92         else
  93                 key_dest = key_console;
  94
  95         SCR_EndLoadingPlaque ();
  96         memset (con_times, 0, sizeof(con_times));
  97 }
  98
  99 /*
 100 ================
 101 Con_Clear_f
 102 ================
 103 */
 104 void Con_Clear_f (void)
 105 {
 106         if (con_text)
 107                 Q_memset (con_text, ' ', CON_TEXTSIZE);
 108 }
 109
 110
 111 /*
 112 ================
 113 Con_ClearNotify
 114 ================
 115 */
 116 void Con_ClearNotify (void)
 117 {
 118         int             i;
 119
 120         for (i=0 ; i<NUM_CON_TIMES ; i++)
 121                 con_times[i] = 0;
 122 }
 123
 124
 125 /*
 126 ================
 127 Con_MessageMode_f
 128 ================
 129 */
 130 extern qboolean team_message;
 131
 132 void Con_MessageMode_f (void)
 133 {
 134         key_dest = key_message;
 135         team_message = false;
 136 }
 137
 138
 139 /*
 140 ================
 141 Con_MessageMode2_f
 142 ================
 143 */
 144 void Con_MessageMode2_f (void)
 145 {
 146         key_dest = key_message;
 147         team_message = true;
 148 }
 149
 150
 151 /*
 152 ================
 153 Con_CheckResize
 154
 155 If the line width has changed, reformat the buffer.
 156 ================
 157 */
 158 void Con_CheckResize (void)
 159 {
 160         int             i, j, width, oldwidth, oldtotallines, numlines, numchars;
 161         char    tbuf[CON_TEXTSIZE];
 162
 163         width = (vid.width >> 3) - 2;
 164
 165         if (width == con_linewidth)
 166                 return;
 167
 168         if (width < 1)                  // video hasn't been initialized yet
 169         {
 170                 width = 38;
 171                 con_linewidth = width;
 172                 con_totallines = CON_TEXTSIZE / con_linewidth;
 173                 Q_memset (con_text, ' ', CON_TEXTSIZE);
 174         }
 175         else
 176         {
 177                 oldwidth = con_linewidth;
 178                 con_linewidth = width;
 179                 oldtotallines = con_totallines;
 180                 con_totallines = CON_TEXTSIZE / con_linewidth;
 181                 numlines = oldtotallines;
 182
 183                 if (con_totallines < numlines)
 184                         numlines = con_totallines;
 185
 186                 numchars = oldwidth;
 187
 188                 if (con_linewidth < numchars)
 189                         numchars = con_linewidth;
 190
 191                 Q_memcpy (tbuf, con_text, CON_TEXTSIZE);
 192                 Q_memset (con_text, ' ', CON_TEXTSIZE);
 193
 194                 for (i=0 ; i<numlines ; i++)
 195                 {
 196                         for (j=0 ; j<numchars ; j++)
 197                         {
 198                                 con_text[(con_totallines - 1 - i) * con_linewidth + j] =
 199                                                 tbuf[((con_current - i + oldtotallines) %
 200                                                           oldtotallines) * oldwidth + j];
 201                         }
 202                 }
 203
 204                 Con_ClearNotify ();
 205         }
 206
 207         con_backscroll = 0;
 208         con_current = con_totallines - 1;
 209 }
 210
 211
 212 /*
 213 ================
 214 Con_Init
 215 ================
 216 */
 217 void Con_Init (void)
 218 {
 219 #define MAXGAMEDIRLEN   1000
 220         char    temp[MAXGAMEDIRLEN+1];
 221         char    *t2 = "/qconsole.log";
 222
 223         con_debuglog = COM_CheckParm("-condebug");
 224
 225         if (con_debuglog)
 226         {
 227                 if (strlen (com_gamedir) < (MAXGAMEDIRLEN - strlen (t2)))
 228                 {
 229                         sprintf (temp, "%s%s", com_gamedir, t2);
 230                         unlink (temp);
 231                 }
 232         }
 233
 234         con_text = Hunk_AllocName (CON_TEXTSIZE, "context");
 235         Q_memset (con_text, ' ', CON_TEXTSIZE);
 236         con_linewidth = -1;
 237         Con_CheckResize ();
 238
 239         Con_Printf ("Console initialized.\n");
 240
 241 //
 242 // register our commands
 243 //
 244         Cvar_RegisterVariable (&con_notifytime);
 245
 246         Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
 247         Cmd_AddCommand ("messagemode", Con_MessageMode_f);
 248         Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
 249         Cmd_AddCommand ("clear", Con_Clear_f);
 250         con_initialized = true;
 251 }
 252
 253
 254 /*
 255 ===============
 256 Con_Linefeed
 257 ===============
 258 */
 259 void Con_Linefeed (void)
 260 {
 261         con_x = 0;
 262         con_current++;
 263         Q_memset (&con_text[(con_current%con_totallines)*con_linewidth]
 264         , ' ', con_linewidth);
 265 }
 266
 267 /*
 268 ================
 269 Con_Print
 270
 271 Handles cursor positioning, line wrapping, etc
 272 All console printing must go through this in order to be logged to disk
 273 If no console is visible, the notify window will pop up.
 274 ================
 275 */
 276 void Con_Print (char *txt)
 277 {
 278         int             y;
 279         int             c, l;
 280         static int      cr;
 281         int             mask;
 282
 283         con_backscroll = 0;
 284
 285         if (txt[0] == 1)
 286         {
 287                 mask = 128;             // go to colored text
 288                 S_LocalSound ("misc/talk.wav");
 289         // play talk wav
 290                 txt++;
 291         }
 292         else if (txt[0] == 2)
 293         {
 294                 mask = 128;             // go to colored text
 295                 txt++;
 296         }
 297         else
 298                 mask = 0;
 299
 300
 301         while ( (c = *txt) )
 302         {
 303         // count word length
 304                 for (l=0 ; l< con_linewidth ; l++)
 305                         if ( txt[l] <= ' ')
 306                                 break;
 307
 308         // word wrap
 309                 if (l != con_linewidth && (con_x + l > con_linewidth) )
 310                         con_x = 0;
 311
 312                 txt++;
 313
 314                 if (cr)
 315                 {
 316                         con_current--;
 317                         cr = false;
 318                 }
 319
 320
 321                 if (!con_x)
 322                 {
 323                         Con_Linefeed ();
 324                 // mark time for transparent overlay
 325                         if (con_current >= 0)
 326                                 con_times[con_current % NUM_CON_TIMES] = realtime;
 327                 }
 328
 329                 switch (c)
 330                 {
 331                 case '\n':
 332                         con_x = 0;
 333                         break;
 334
 335                 case '\r':
 336                         con_x = 0;
 337                         cr = 1;
 338                         break;
 339
 340                 default:        // display character and advance
 341                         y = con_current % con_totallines;
 342                         con_text[y*con_linewidth+con_x] = c | mask;
 343                         con_x++;
 344                         if (con_x >= con_linewidth)
 345                                 con_x = 0;
 346                         break;
 347                 }
 348
 349         }
 350 }
 351
 352
 353 /*
 354 ================
 355 Con_DebugLog
 356 ================
 357 */
 358 void Con_DebugLog(char *file, char *fmt, ...)
 359 {
 360     va_list argptr;
 361     static char data[1024];
 362     int fd;
 363
 364     va_start(argptr, fmt);
 365     vsprintf(data, fmt, argptr);
 366     va_end(argptr);
 367     fd = open(file, O_WRONLY | O_CREAT | O_APPEND, 0666);
 368     write(fd, data, strlen(data));
 369     close(fd);
 370 }
 371
 372
 373 /*
 374 ================
 375 Con_Printf
 376
 377 Handles cursor positioning, line wrapping, etc
 378 ================
 379 */
 380 #define MAXPRINTMSG     4096
 381 // FIXME: make a buffer size safe vsprintf?
 382 void Con_Printf (char *fmt, ...)
 383 {
 384         va_list         argptr;
 385         char            msg[MAXPRINTMSG];
 386         static qboolean inupdate;
 387
 388         va_start (argptr,fmt);
 389         vsprintf (msg,fmt,argptr);
 390         va_end (argptr);
 391
 392 // also echo to debugging console
 393         Sys_Printf ("%s", msg); // also echo to debugging console
 394
 395 // log all messages to file
 396         if (con_debuglog)
 397                 Con_DebugLog(va("%s/qconsole.log",com_gamedir), "%s", msg);
 398
 399         if (!con_initialized)
 400                 return;
 401
 402         if (cls.state == ca_dedicated)
 403                 return;         // no graphics mode
 404
 405 // write it to the scrollable buffer
 406         Con_Print (msg);
 407
 408 // update the screen if the console is displayed
 409         if (cls.signon != SIGNONS && !scr_disabled_for_loading )
 410         {
 411         // protect against infinite loop if something in SCR_UpdateScreen calls
 412         // Con_Printd
 413                 if (!inupdate)
 414                 {
 415                         inupdate = true;
 416                         SCR_UpdateScreen ();
 417                         inupdate = false;
 418                 }
 419         }
 420 }
 421
 422 /*
 423 ================
 424 Con_DPrintf
 425
 426 A Con_Printf that only shows up if the "developer" cvar is set
 427 ================
 428 */
 429 void Con_DPrintf (char *fmt, ...)
 430 {
 431         va_list         argptr;
 432         char            msg[MAXPRINTMSG];
 433
 434         if (!developer.value)
 435                 return;                 // don't confuse non-developers with techie stuff...
 436
 437         va_start (argptr,fmt);
 438         vsprintf (msg,fmt,argptr);
 439         va_end (argptr);
 440
 441         Con_Printf ("%s", msg);
 442 }
 443
 444
 445 /*
 446 ==================
 447 Con_SafePrintf
 448
 449 Okay to call even when the screen can't be updated
 450 ==================
 451 */
 452 void Con_SafePrintf (char *fmt, ...)
 453 {
 454         va_list         argptr;
 455         char            msg[1024];
 456         int                     temp;
 457
 458         va_start (argptr,fmt);
 459         vsprintf (msg,fmt,argptr);
 460         va_end (argptr);
 461
 462         temp = scr_disabled_for_loading;
 463         scr_disabled_for_loading = true;
 464         Con_Printf ("%s", msg);
 465         scr_disabled_for_loading = temp;
 466 }
 467
 468
 469 /*
 470 ==============================================================================
 471
 472 DRAWING
 473
 474 ==============================================================================
 475 */
 476
 477
 478 /*
 479 ================
 480 Con_DrawInput
 481
 482 The input line scrolls horizontally if typing goes beyond the right edge
 483 ================
 484 */
 485 void Con_DrawInput (void)
 486 {
 487         int             y;
 488         int             i;
 489         char    *text;
 490
 491         if (key_dest != key_console && !con_forcedup)
 492                 return;         // don't draw anything
 493
 494         text = key_lines[edit_line];
 495
 496 // add the cursor frame
 497         text[key_linepos] = 10+((int)(realtime*con_cursorspeed)&1);
 498
 499 // fill out remainder with spaces
 500         for (i=key_linepos+1 ; i< con_linewidth ; i++)
 501                 text[i] = ' ';
 502
 503 //      prestep if horizontally scrolling
 504         if (key_linepos >= con_linewidth)
 505                 text += 1 + key_linepos - con_linewidth;
 506
 507 // draw it
 508         y = con_vislines-16;
 509
 510         for (i=0 ; i<con_linewidth ; i++)
 511                 Draw_Character ( (i+1)<<3, con_vislines - 16, text[i]);
 512
 513 // remove cursor
 514         key_lines[edit_line][key_linepos] = 0;
 515 }
 516
 517
 518 /*
 519 ================
 520 Con_DrawNotify
 521
 522 Draws the last few lines of output transparently over the game top
 523 ================
 524 */
 525 void Con_DrawNotify (void)
 526 {
 527         int             x, v;
 528         char    *text;
 529         int             i;
 530         float   time;
 531         extern char chat_buffer[];
 532
 533         v = 0;
 534         for (i= con_current-NUM_CON_TIMES+1 ; i<=con_current ; i++)
 535         {
 536                 if (i < 0)
 537                         continue;
 538                 time = con_times[i % NUM_CON_TIMES];
 539                 if (time == 0)
 540                         continue;
 541                 time = realtime - time;
 542                 if (time > con_notifytime.value)
 543                         continue;
 544                 text = con_text + (i % con_totallines)*con_linewidth;
 545
 546                 clearnotify = 0;
 547                 scr_copytop = 1;
 548
 549                 for (x = 0 ; x < con_linewidth ; x++)
 550                         Draw_Character ( (x+1)<<3, v, text[x]);
 551
 552                 v += 8;
 553         }
 554
 555
 556         if (key_dest == key_message)
 557         {
 558                 clearnotify = 0;
 559                 scr_copytop = 1;
 560
 561                 x = 0;
 562
 563                 Draw_String (8, v, "say:");
 564                 while(chat_buffer[x])
 565                 {
 566                         Draw_Character ( (x+5)<<3, v, chat_buffer[x]);
 567                         x++;
 568                 }
 569                 Draw_Character ( (x+5)<<3, v, 10+((int)(realtime*con_cursorspeed)&1));
 570                 v += 8;
 571         }
 572
 573         if (v > con_notifylines)
 574                 con_notifylines = v;
 575 }
 576
 577 /*
 578 ================
 579 Con_DrawConsole
 580
 581 Draws the console with the solid background
 582 The typing input line at the bottom should only be drawn if typing is allowed
 583 ================
 584 */
 585 void Con_DrawConsole (int lines, qboolean drawinput)
 586 {
 587         int                             i, x, y;
 588         int                             rows;
 589         char                    *text;
 590         int                             j;
 591
 592         if (lines <= 0)
 593                 return;
 594
 595 // draw the background
 596         Draw_ConsoleBackground (lines);
 597
 598 // draw the text
 599         con_vislines = lines;
 600
 601         rows = (lines-16)>>3;           // rows of text to draw
 602         y = lines - 16 - (rows<<3);     // may start slightly negative
 603
 604         for (i= con_current - rows + 1 ; i<=con_current ; i++, y+=8 )
 605         {
 606                 j = i - con_backscroll;
 607                 if (j<0)
 608                         j = 0;
 609                 text = con_text + (j % con_totallines)*con_linewidth;
 610
 611                 for (x=0 ; x<con_linewidth ; x++)
 612                         Draw_Character ( (x+1)<<3, y, text[x]);
 613         }
 614
 615 // draw the input prompt, user text, and cursor if desired
 616         if (drawinput)
 617                 Con_DrawInput ();
 618
 619         Con_DrawOSK();
 620 }
 621
 622 static qboolean scr_osk_active = false;
 623
 624
 625 void Con_SetOSKActive(qboolean active) {
 626         scr_osk_active = active;
 627 }
 628
 629 qboolean Con_isSetOSKActive(void) {
 630         return scr_osk_active;
 631 }
 632
 633 void Con_DrawOSK(void) {
 634         if (scr_osk_active) {
 635                 M_OSK_Draw();
 636         }
 637 }
 638
 639 /*
 640 ==================
 641 Con_NotifyBox
 642 ==================
 643 */
 644 void Con_NotifyBox (char *text)
 645 {
 646         double          t1, t2;
 647
 648 // during startup for sound / cd warnings
 649         Con_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n");
 650
 651         Con_Printf (text);
 652
 653         Con_Printf ("Press a key.\n");
 654         Con_Printf("\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n");
 655
 656         key_count = -2;         // wait for a key down and up
 657         key_dest = key_console;
 658
 659         do
 660         {
 661                 t1 = Sys_FloatTime ();
 662                 SCR_UpdateScreen ();
 663                 Sys_SendKeyEvents ();
 664                 t2 = Sys_FloatTime ();
 665                 realtime += t2-t1;              // make the cursor blink
 666         } while (key_count < 0);
 667
 668         Con_Printf ("\n");
 669         key_dest = key_game;
 670         realtime = 0;                           // put the cursor back to invisible
 671 }
 672