sys/msdos/video.c

   1 /*   SCCS Id: @(#)video.c   3.4     2001/04/07                      */
   2 /*   Copyright (c) NetHack PC Development Team 1993, 1994, 2001     */
   3 /*   NetHack may be freely redistributed.  See license for details. */
   4 /*                                                                  */
   5 /*
   6  * video.c - Hardware video support front-ends
   7  *
   8  *Edit History:
   9  *     Initial Creation              M. Allison      1993/04/04
  10  *     Add djgpp support             K. Smolkowski   1993/04/26
  11  *     Add txt/graphics mode support M. Allison      1993/10/30
  12  *     Add graphics mode cursor sim. M. Allison      1994/02/19
  13  *     Add hooks for decals on vga   M. Allison      2001/04/07
  14  */
  15
  16 #include "hack.h"
  17
  18 #ifndef STUBVIDEO
  19 #include "pcvideo.h"
  20 #include "pctiles.h"
  21
  22 #if defined(_MSC_VER)
  23 # if _MSC_VER >= 700
  24 #pragma warning(disable:4018)   /* signed/unsigned mismatch */
  25 #pragma warning(disable:4127)   /* conditional expression is constant */
  26 #pragma warning(disable:4131)   /* old style declarator */
  27 #pragma warning(disable:4305)   /* prevents complaints with MK_FP */
  28 #pragma warning(disable:4309)   /* initializing */
  29 #pragma warning(disable:4759)   /* prevents complaints with MK_FP */
  30 # endif
  31 #endif
  32 /*=========================================================================
  33  * General PC Video routines.
  34  *
  35  * The following routines are the video interfacing functions.
  36  * In general these make calls to more hardware specific
  37  * routines in other source files.
  38  *
  39  * Assumptions (94/04/23):
  40  *
  41  *   - Supported defaults.nh file video options:
  42  *
  43  *          If OPTIONS=video:autodetect is defined in defaults.nh then
  44  *          check for a VGA video adapter.  If one is detected, then
  45  *          use the VGA code, otherwise resort to using the 'standard'
  46  *          video BIOS routines.
  47  *
  48  *          If OPTIONS=video:vga is defined in defaults.nh, then use
  49  *          the VGA code.
  50  *
  51  *          If OPTIONS=video:default is defined in defaults.nh use the
  52  *          'standard' video BIOS routines (in the overlaid version),
  53  *          or DJGPPFAST routines (under djgpp). This is equivalent to
  54  *          having no OPTIONS=video:xxxx entry at all.
  55  *
  56  * Notes (94/04/23):
  57  *
  58  *   - The handler for defaults.nh file entry:
  59  *
  60  *           OPTIONS=video:xxxxx
  61  *
  62  *     has now been added.  The handler is in video.c and is called
  63  *     from options.c.
  64  *
  65  *   - Handling of videocolors and videoshades are now done with
  66  *     OPTIONS= statements.  The new syntax separates the colour
  67  *     values with dashes ('-') rather than spaces (' ').
  68  *
  69  * To Do (94/04/23):
  70  *
  71  *
  72  *=========================================================================
  73  */
  74
  75
  76 #ifdef OVLB
  77 void
  78 get_scr_size()
  79 {
  80 #  ifdef SCREEN_VGA
  81         if (iflags.usevga) {
  82                 vga_get_scr_size();
  83         } else
  84 #  endif
  85                 txt_get_scr_size();
  86 }
  87 #endif /*OVLB*/
  88
  89 /*
  90  * --------------------------------------------------------------
  91  * The rest of this file is only compiled if NO_TERMS is defined.
  92  * --------------------------------------------------------------
  93  */
  94
  95 #ifdef NO_TERMS
  96
  97 #include <ctype.h>
  98 #include "wintty.h"
  99
 100 # ifdef __GO32__
 101 #include <pc.h>
 102 #include <unistd.h>
 103 #if !(__DJGPP__ >= 2)
 104 typedef long clock_t;
 105 #endif
 106 # endif
 107
 108 # ifdef __BORLANDC__
 109 #include <dos.h>                /* needed for delay() */
 110 # endif
 111
 112 # ifdef SCREEN_DJGPPFAST        /* parts of this block may be unecessary now */
 113 #define get_cursor(x,y) ScreenGetCursor(y,x)
 114 # endif
 115
 116 # ifdef SCREEN_BIOS
 117 void FDECL(get_cursor, (int *, int *));
 118 # endif
 119
 120 void FDECL(adjust_cursor_flags, (struct WinDesc *));
 121 void FDECL(cmov, (int, int));
 122 void FDECL(nocmov, (int, int));
 123 STATIC_DCL void NDECL(init_ttycolor);
 124
 125 # ifdef OVLB
 126 int savevmode;            /* store the original video mode in here */
 127 int curcol,currow;        /* graphics mode current cursor locations */
 128 int g_attribute;          /* Current attribute to use */
 129 int monoflag;             /* 0 = not monochrome, else monochrome */
 130 int attrib_text_normal;   /* text mode normal attribute */
 131 int attrib_gr_normal;     /* graphics mode normal attribute */
 132 int attrib_text_intense;  /* text mode intense attribute */
 133 int attrib_gr_intense;    /* graphics mode intense attribute */
 134 boolean traditional = FALSE; /* traditonal TTY character mode */
 135 boolean inmap = FALSE;    /* in the map window */
 136 #  ifdef TEXTCOLOR
 137 char ttycolors[CLR_MAX];        /* also used/set in options.c */
 138 #  endif /* TEXTCOLOR */
 139 # else
 140 extern int savevmode;
 141 extern int curcol,currow;
 142 extern int g_attribute;
 143 extern int monoflag;
 144 extern int attrib_text_normal;
 145 extern int attrib_gr_normal;
 146 extern int attrib_text_intense;
 147 extern int attrib_gr_intense;
 148 extern boolean traditonal;
 149 extern boolean inmap;
 150 #  ifdef TEXTCOLOR
 151 extern char ttycolors[CLR_MAX]; /* also used/set in options.c */
 152 #  endif /* TEXTCOLOR */
 153 # endif /* OVLB */
 154
 155 # ifdef OVLB
 156 void
 157 backsp()
 158 {
 159         if (!iflags.grmode) {
 160                 txt_backsp();
 161 #  ifdef SCREEN_VGA
 162         } else if (iflags.usevga) {
 163                 vga_backsp();
 164 #  endif
 165         }
 166 }
 167 # endif /* OVLB */
 168
 169 # ifdef OVL0
 170 void
 171 clear_screen()
 172 {
 173         if (!iflags.grmode) {
 174                 txt_clear_screen();
 175 #  ifdef SCREEN_VGA
 176         } else if (iflags.usevga) {
 177                 vga_clear_screen(BACKGROUND_VGA_COLOR);
 178 #  endif
 179         }
 180 }
 181
 182 void
 183 cl_end()        /* clear to end of line */
 184 {
 185         int col,row;
 186
 187         col = (int)ttyDisplay->curx;
 188         row = (int)ttyDisplay->cury;
 189         if (!iflags.grmode) {
 190                 txt_cl_end(col,row);
 191 #  ifdef SCREEN_VGA
 192         } else if (iflags.usevga) {
 193                 vga_cl_end(col,row);
 194 #  endif
 195         }
 196         tty_curs(BASE_WINDOW, (int)ttyDisplay->curx+1,
 197                                                 (int)ttyDisplay->cury);
 198 }
 199
 200 void
 201 cl_eos()        /* clear to end of screen */
 202 {
 203         int cy = (int)ttyDisplay->cury+1;
 204
 205         if (!iflags.grmode) {
 206                 txt_cl_eos();
 207 #  ifdef SCREEN_VGA
 208         } else if (iflags.usevga) {
 209                 vga_cl_eos(cy);
 210 #  endif
 211         }
 212         tty_curs(BASE_WINDOW, (int)ttyDisplay->curx+1,
 213                                                 (int)ttyDisplay->cury);
 214 }
 215
 216 void
 217 cmov(col, row)
 218 register int col, row;
 219 {
 220         ttyDisplay->cury = (uchar)row;
 221         ttyDisplay->curx = (uchar)col;
 222         if (!iflags.grmode) {
 223                 txt_gotoxy(col,row);
 224 #  ifdef SCREEN_VGA
 225         } else if (iflags.usevga) {
 226                 vga_gotoloc(col,row);
 227 #  endif
 228         }
 229 }
 230 # endif /* OVL0 */
 231
 232 # ifdef OVLB
 233 int
 234 has_color(int color)
 235 {
 236         ++color;                /* prevents compiler warning (unref. param) */
 237 #  ifdef TEXTCOLOR
 238         return  (monoflag) ? 0 : 1;
 239 #  else
 240         return 0;
 241 #  endif
 242 }
 243 # endif /* OVLB */
 244
 245 # ifdef OVL0
 246 void
 247 home()
 248 {
 249         tty_curs(BASE_WINDOW, 1, 0);
 250         ttyDisplay->curx = ttyDisplay->cury = (uchar)0;
 251         if (!iflags.grmode) {
 252                 txt_gotoxy(0,0);
 253 #  ifdef SCREEN_VGA
 254         } else if (iflags.usevga) {
 255                 vga_gotoloc(0,0);
 256 #  endif
 257         }
 258 }
 259
 260 void
 261 nocmov(col, row)
 262 int col,row;
 263 {
 264         if (!iflags.grmode) {
 265                 txt_gotoxy(col,row);
 266 #  ifdef SCREEN_VGA
 267         } else if (iflags.usevga) {
 268                 vga_gotoloc(col,row);
 269 #  endif
 270         }
 271 }
 272
 273 void
 274 standoutbeg()
 275 {
 276         g_attribute = iflags.grmode ? attrib_gr_intense
 277                                    : attrib_text_intense;
 278 }
 279
 280 void
 281 standoutend()
 282 {
 283         g_attribute = iflags.grmode ? attrib_gr_normal
 284                                    : attrib_text_normal;
 285 }
 286 # endif /* OVL0 */
 287
 288
 289 # ifdef OVLB
 290 void
 291 term_end_attr(int attr)
 292 {
 293         switch(attr) {
 294                 case ATR_ULINE:
 295                 case ATR_BOLD:
 296                 case ATR_BLINK:
 297                 case ATR_INVERSE:
 298                 default:
 299                 g_attribute = iflags.grmode ? attrib_gr_normal
 300                                            : attrib_text_normal;
 301         }
 302 }
 303
 304 void
 305 term_end_color(void)
 306 {
 307         g_attribute = iflags.grmode ? attrib_gr_normal
 308                                    : attrib_text_normal;
 309 }
 310
 311 void
 312 term_end_raw_bold(void)
 313 {
 314     standoutend();
 315 }
 316
 317
 318 void
 319 term_start_attr(int attr)
 320 {
 321     switch(attr){
 322
 323         case ATR_ULINE:
 324                 if (monoflag) {
 325                         g_attribute = ATTRIB_MONO_UNDERLINE;
 326                 } else {
 327                         g_attribute = iflags.grmode ? attrib_gr_intense
 328                                                    : attrib_text_intense;
 329                 }
 330                 break;
 331         case ATR_BOLD:
 332                 g_attribute = iflags.grmode ? attrib_gr_intense
 333                                            : attrib_text_intense;
 334                 break;
 335         case ATR_BLINK:
 336                 if (monoflag) {
 337                         g_attribute = ATTRIB_MONO_BLINK;
 338                 } else {
 339                         g_attribute = iflags.grmode ? attrib_gr_intense
 340                                                    : attrib_text_intense;
 341                 }
 342                 break;
 343         case ATR_INVERSE:
 344                 if (monoflag) {
 345                         g_attribute = ATTRIB_MONO_REVERSE;
 346                 } else {
 347                         g_attribute = iflags.grmode ? attrib_gr_intense
 348                                                    : attrib_text_intense;
 349                 }
 350                 break;
 351         default:
 352                 g_attribute = iflags.grmode ? attrib_gr_normal
 353                                            : attrib_text_normal;
 354                 break;
 355     }
 356 }
 357
 358
 359 void
 360 term_start_color(int color)
 361 {
 362 #  ifdef TEXTCOLOR
 363         if (monoflag) {
 364                         g_attribute = attrib_text_normal;
 365         } else {
 366                 if (color >= 0 && color < CLR_MAX) {
 367                         if (iflags.grmode)
 368                                 g_attribute = color;
 369                         else
 370                                 g_attribute = ttycolors[color];
 371                 }
 372         }
 373 #  endif
 374 }
 375
 376 void
 377 term_start_raw_bold(void)
 378 {
 379     standoutbeg();
 380 }
 381 # endif /* OVLB */
 382
 383 # ifdef OVL0
 384 void
 385 tty_delay_output()
 386 {
 387 #ifdef TIMED_DELAY
 388         if (flags.nap) {
 389             (void) fflush(stdout);
 390             msleep(50);         /* sleep for 50 milliseconds */
 391             return;
 392         }
 393 #endif
 394 }
 395
 396 # endif /* OVL0 */
 397
 398 # ifdef OVLB
 399 void
 400 tty_end_screen()
 401 {
 402
 403         if (!iflags.grmode) {
 404                 txt_clear_screen();
 405 #  ifdef PC9800
 406                 fputs("\033[>1l", stdout);
 407 #  endif
 408 #  ifdef SCREEN_VGA
 409         } else if (iflags.usevga) {
 410                 vga_tty_end_screen();
 411 #  endif
 412         }
 413 }
 414
 415 void
 416 tty_nhbell()
 417 {
 418         txt_nhbell();
 419 }
 420
 421
 422 void
 423 tty_number_pad(state)
 424 int state;
 425 {
 426         ++state;                /* prevents compiler warning (unref. param) */
 427 }
 428
 429 void
 430 tty_startup(wid, hgt)
 431 int *wid, *hgt;
 432 {
 433
 434         /* code to sense display adapter is required here - MJA */
 435
 436         attrib_text_normal  = ATTRIB_NORMAL;
 437         attrib_text_intense = ATTRIB_INTENSE;
 438
 439         /* These are defaults and may get overridden */
 440         attrib_gr_normal    = attrib_text_normal;
 441         attrib_gr_intense   = attrib_text_intense;
 442         g_attribute = attrib_text_normal;       /* Give it a starting value */
 443
 444 #  ifdef SCREEN_VGA
 445         if (iflags.usevga) {
 446                 vga_tty_startup(wid, hgt);
 447         } else
 448 #  endif
 449         txt_startup(wid, hgt);
 450
 451         *wid = CO;
 452         *hgt = LI;
 453
 454 #  ifdef CLIPPING
 455         if (CO < COLNO || LI < ROWNO+3) setclipped();
 456 #  endif
 457
 458 #  ifdef TEXTCOLOR
 459         init_ttycolor();
 460 #  endif
 461
 462 #  ifdef MONO_CHECK
 463         monoflag = txt_monoadapt_check();
 464 #  else
 465         monoflag = 0;
 466 #  endif
 467
 468 }
 469
 470 void
 471 tty_start_screen()
 472 {
 473 #  ifdef PC9800
 474         fputs("\033[>1h", stdout);
 475 #  endif
 476         if (iflags.num_pad) tty_number_pad(1);  /* make keypad send digits */
 477 }
 478
 479 void
 480 gr_init(){
 481         if (iflags.usevga)      {
 482 # ifdef SCREEN_VGA
 483                 vga_Init();
 484 # endif
 485 # ifdef SCREEN_VESA
 486         } else if (iflags.usevesa) {
 487                 vesa_Init();
 488
 489 # endif
 490 # ifdef SCREEN_8514
 491         } else if (iflags.use8514) {
 492                 v8514_Init();
 493 # endif
 494         }
 495 }
 496
 497 void
 498 gr_finish()
 499 {
 500         if (iflags.grmode) {
 501            if (iflags.usevga) {
 502 # ifdef SCREEN_VGA
 503                 vga_Finish();
 504 # endif
 505 # ifdef SCREEN_VESA
 506            } else if (iflags.usevesa) {
 507                 vesa_Finish();
 508 # endif
 509 # ifdef SCREEN_8514
 510            } else if (iflags.use8514) {
 511                 v8514_Finish();
 512 # endif
 513            }
 514         }
 515 }
 516
 517 # endif /* OVLB */
 518
 519 /*
 520  * Screen output routines (these are heavily used).
 521  *
 522  * These are the 3 routines used to place information on the screen
 523  * in the NO_TERMS PC tty port of NetHack.  These are the routines
 524  * that get called by routines in other NetHack source files (such
 525  * as those in win/tty).
 526  *
 527  * xputs - Writes a c null terminated string at the current location.
 528  *         Depending on compile options, this could just be a series
 529  *         of repeated calls to xputc() for each character.
 530  *
 531  * xputc - Writes a single character at the current location. Since
 532  *         various places in the code assume that control characters
 533  *         can be used to control, we are forced to interpret some of
 534  *         the more common ones, in order to keep things looking correct.
 535  *
 536  * xputg - If using a graphics mode display mechanism (such as VGA, this
 537  *         routine is used to display a graphical representation of a
 538  *         NetHack glyph at the current location.  For more information on
 539  *         NetHack glyphs refer to the comments in include/display.h.
 540  *
 541  * NOTES:
 542  *         wintty.h uses macros to redefine common output functions
 543  *         such as puts, putc, putchar, so that they get steered into
 544  *         either xputs (for strings) or xputc (for single characters).
 545  *         References to puts, putc, and putchar in other source files
 546  *         (that include wintty.h) are actually using these routines.
 547  */
 548
 549 # ifdef OVL0
 550 void
 551 xputs(s)
 552 const char *s;
 553 {
 554         int col,row;
 555
 556         col = (int)ttyDisplay->curx;
 557         row = (int)ttyDisplay->cury;
 558
 559         if (!iflags.grmode) {
 560                 txt_xputs(s,col,row);
 561 #  ifdef SCREEN_VGA
 562         } else if (iflags.usevga) {
 563                 vga_xputs(s,col,row);
 564 #  endif
 565         }
 566 }
 567
 568 void
 569 xputc(ch)       /* write out character (and attribute) */
 570 char ch;
 571 {
 572         int i;
 573         char attribute;
 574
 575         i = iflags.grmode ? attrib_gr_normal
 576                          : attrib_text_normal;
 577
 578         attribute = (char)((g_attribute == 0) ? i : g_attribute);
 579         if (!iflags.grmode) {
 580                 txt_xputc(ch,attribute);
 581 #  ifdef SCREEN_VGA
 582         } else if (iflags.usevga) {
 583                 vga_xputc(ch,attribute);
 584 #  endif /*SCREEN_VGA*/
 585         }
 586 }
 587
 588 void
 589 xputg(glyphnum,ch,special)      /* write out a glyph picture at current location */
 590 int glyphnum;
 591 int ch;
 592 unsigned special;
 593 {
 594         if (!iflags.grmode || !iflags.tile_view) {
 595                 xputc((char)ch);
 596 #  ifdef SCREEN_VGA
 597         } else {
 598                 vga_xputg(glyphnum, ch, special);
 599 #  endif
 600         }
 601 }
 602
 603 #  ifdef POSITIONBAR
 604 void
 605 video_update_positionbar(posbar)
 606 char *posbar;
 607 {
 608         if (!iflags.grmode)
 609                 return;
 610 #   ifdef SCREEN_VGA
 611         else
 612                 vga_update_positionbar(posbar);
 613 #   endif
 614 }
 615 #  endif
 616
 617 void
 618 adjust_cursor_flags(cw)
 619 struct WinDesc *cw;
 620 {
 621 #  ifdef SIMULATE_CURSOR
 622 #   if 0
 623     if (cw->type == NHW_MAP) cursor_flag = 1;
 624     else cursor_flag = 0;
 625 #   else
 626     if (cw->type == NHW_MAP) {
 627         inmap = 1;
 628         cursor_flag = 1;
 629     } else {
 630         inmap = 0;
 631         cursor_flag = 1;
 632     }
 633 #   endif /* 0 */
 634 #  endif /* SIMULATE_CURSOR */
 635 }
 636
 637 #  ifdef SIMULATE_CURSOR
 638
 639 /* change the defaults in pcvideo.h, not here */
 640 int cursor_type  = CURSOR_DEFAULT_STYLE;
 641 int cursor_color = CURSOR_DEFAULT_COLOR;
 642 int cursor_flag;
 643
 644 /* The check for iflags.grmode is made BEFORE calling these. */
 645 void
 646 DrawCursor()
 647 {
 648 #  ifdef SCREEN_VGA
 649         vga_DrawCursor();
 650 #  endif
 651 }
 652
 653 void
 654 HideCursor()
 655 {
 656 #  ifdef SCREEN_VGA
 657         vga_HideCursor();
 658 #  endif
 659 }
 660
 661 #  endif /* SIMULATE_CURSOR */
 662 # endif /* OVL0 */
 663
 664 # ifdef TEXTCOLOR
 665 /*
 666  * CLR_BLACK            0
 667  * CLR_RED              1
 668  * CLR_GREEN            2
 669  * CLR_BROWN            3       low-intensity yellow
 670  * CLR_BLUE             4
 671  * CLR_MAGENTA          5
 672  * CLR_CYAN             6
 673  * CLR_GRAY             7       low-intensity white
 674  * NO_COLOR             8
 675  * CLR_ORANGE           9
 676  * CLR_BRIGHT_GREEN     10
 677  * CLR_YELLOW           11
 678  * CLR_BRIGHT_BLUE      12
 679  * CLR_BRIGHT_MAGENTA   13
 680  * CLR_BRIGHT_CYAN      14
 681  * CLR_WHITE            15
 682  * CLR_MAX              16
 683  * BRIGHT               8
 684  */
 685
 686 #  ifdef VIDEOSHADES
 687 /* assign_videoshades() is prototyped in extern.h */
 688 /* assign_videocolors() is prototyped in extern.h */
 689 /* assign_video()       is prototyped in extern.h */
 690
 691 #   ifdef OVLB
 692 int shadeflag;                                  /* shades are initialized */
 693 int colorflag;                                  /* colors are initialized */
 694 char *schoice[3] = {"dark","normal","light"};
 695 char *shade[3];
 696 #   else
 697 extern int shadeflag;
 698 extern int colorflag;
 699 extern char *schoice[3];
 700 extern char *shade[3];
 701 #   endif /* OVLB */
 702
 703 #  endif /* VIDEOSHADES */
 704
 705 #  ifdef OVLB
 706 STATIC_OVL void
 707 init_ttycolor()
 708 {
 709 #   ifdef VIDEOSHADES
 710         if (!shadeflag) {
 711                 ttycolors[CLR_BLACK] = M_BLACK; /*  8 = dark gray */
 712                 ttycolors[CLR_WHITE] = M_WHITE; /* 15 = bright white */
 713                 ttycolors[CLR_GRAY]  = M_GRAY;  /*  7 = normal white */
 714                 shade[0] = schoice[0];
 715                 shade[1] = schoice[1];
 716                 shade[2] = schoice[2];
 717         }
 718 #   else
 719         ttycolors[CLR_BLACK] = M_GRAY;          /*  mapped to white */
 720         ttycolors[CLR_WHITE] = M_GRAY;          /*  mapped to white */
 721         ttycolors[CLR_GRAY]  = M_GRAY;          /*  mapped to white */
 722 #   endif
 723
 724 #   ifdef VIDEOSHADES
 725         if (!colorflag) {
 726 #   endif
 727                 ttycolors[CLR_RED]            = M_RED;
 728                 ttycolors[CLR_GREEN]          = M_GREEN;
 729                 ttycolors[CLR_BROWN]          = M_BROWN;
 730                 ttycolors[CLR_BLUE]           = M_BLUE;
 731                 ttycolors[CLR_MAGENTA]        = M_MAGENTA;
 732                 ttycolors[CLR_CYAN]           = M_CYAN;
 733                 ttycolors[BRIGHT]             = M_WHITE;
 734                 ttycolors[CLR_ORANGE]         = M_ORANGE;
 735                 ttycolors[CLR_BRIGHT_GREEN]   = M_BRIGHTGREEN;
 736                 ttycolors[CLR_YELLOW]         = M_YELLOW;
 737                 ttycolors[CLR_BRIGHT_BLUE]    = M_BRIGHTBLUE;
 738                 ttycolors[CLR_BRIGHT_MAGENTA] = M_BRIGHTMAGENTA;
 739                 ttycolors[CLR_BRIGHT_CYAN]    = M_BRIGHTCYAN;
 740 #   ifdef VIDEOSHADES
 741         }
 742 #   endif
 743 }
 744 #  endif /* OVLB */
 745
 746 #  ifdef OVL1
 747         static int FDECL(convert_uchars,(char *, uchar *, int));
 748 #   ifdef VIDEOSHADES
 749 int assign_videoshades(char *choiceptr)
 750 {
 751         char choices[120];
 752         char *cptr, *cvalue[3];
 753         int i,icolor = CLR_WHITE;
 754
 755         strcpy(choices,choiceptr);
 756         cvalue[0] = choices;
 757
 758         /* find the next ' ' or tab */
 759         cptr = index(cvalue[0], '-');
 760         if (!cptr) cptr = index(cvalue[0], ' ');
 761         if (!cptr) cptr = index(cvalue[0], '\t');
 762         if (!cptr) return 0;
 763         *cptr = '\0';
 764         /* skip  whitespace between '=' and value */
 765         do { ++cptr; } while (isspace(*cptr) || (*cptr == '-'));
 766         cvalue[1] = cptr;
 767
 768         cptr = index(cvalue[1], '-');
 769         if (!cptr) cptr = index(cvalue[0], ' ');
 770         if (!cptr) cptr = index(cvalue[0], '\t');
 771         if (!cptr) return 0;
 772         *cptr = '\0';
 773         do { ++cptr; } while (isspace(*cptr) || (*cptr == '-'));
 774         cvalue[2] = cptr;
 775
 776         for (i=0; i < 3; ++i) {
 777                 switch(i) {
 778                         case 0: icolor = CLR_BLACK;
 779                                 break;
 780                         case 1: icolor = CLR_GRAY;
 781                                 break;
 782                         case 2: icolor = CLR_WHITE;
 783                                 break;
 784                 }
 785
 786                 shadeflag = 1;
 787                 if ((strncmpi(cvalue[i],"black",5) == 0) ||
 788                     (strncmpi(cvalue[i],"dark",4) == 0)) {
 789                         shade[i] = schoice[0];
 790                         ttycolors[icolor] = M_BLACK;    /* dark gray */
 791                 } else if ((strncmpi(cvalue[i],"gray",4) == 0) ||
 792                            (strncmpi(cvalue[i],"grey",4) == 0) ||
 793                            (strncmpi(cvalue[i],"medium",6) == 0) ||
 794                            (strncmpi(cvalue[i],"normal",6) == 0)) {
 795                         shade[i] = schoice[1];
 796                         ttycolors[icolor] = M_GRAY;     /* regular gray */
 797                 } else if ((strncmpi(cvalue[i],"white",5) == 0) ||
 798                            (strncmpi(cvalue[i],"light",5) == 0)) {
 799                         shade[i] = schoice[2];
 800                         ttycolors[icolor] = M_WHITE;  /* bright white */
 801                 } else {
 802                         shadeflag = 0;
 803                         return 0;
 804                 }
 805         }
 806         return 1;
 807 }
 808
 809 /*
 810  * Process defaults.nh OPTIONS=videocolors:xxx
 811  * Left to right assignments for:
 812  *      red green brown blue magenta cyan orange br.green yellow
 813  *      br.blue br.mag br.cyan
 814  *
 815  * Default Mapping (BIOS): 4-2-6-1-5-3-12-10-14-9-13-11
 816  */
 817 int assign_videocolors(char *colorvals)
 818 {
 819         int i,icolor;
 820         uchar *tmpcolor;
 821
 822         init_ttycolor();        /* in case defaults.nh entry wasn't complete */
 823         i = strlen(colorvals);
 824         tmpcolor = (uchar *)alloc(i);
 825         (void)convert_uchars(colorvals,tmpcolor,i);
 826         icolor = CLR_RED;
 827         for( i = 0; tmpcolor[i] != 0; ++i) {
 828                 if (icolor < (CLR_WHITE)) {
 829                         ttycolors[icolor++] = tmpcolor[i];
 830                         if ((icolor > CLR_CYAN) && (icolor < CLR_ORANGE)) {
 831                                  icolor = CLR_ORANGE;
 832                         }
 833                 }
 834         }
 835         colorflag = 1;
 836         free((genericptr_t)tmpcolor);
 837         return 1;
 838 }
 839
 840 static int
 841 convert_uchars(bufp,list,size)
 842     char *bufp;         /* current pointer */
 843     uchar *list;        /* return list */
 844     int size;
 845 {
 846     unsigned int num = 0;
 847     int count = 0;
 848
 849     while (1) {
 850         switch(*bufp) {
 851             case ' ':  case '\0':
 852             case '\t': case '-':
 853             case '\n':
 854                 if (num) {
 855                     list[count++] =  num;
 856                     num = 0;
 857                 }
 858                 if ((count==size) || !*bufp) return count;
 859                 bufp++;
 860                 break;
 861
 862             case '0': case '1': case '2': case '3':
 863             case '4': case '5': case '6': case '7':
 864             case '8': case '9':
 865                 num = num*10 + (*bufp-'0');
 866                 bufp++;
 867                 break;
 868                 return count;
 869         }
 870     }
 871     /*NOTREACHED*/
 872 }
 873
 874 #   endif /* VIDEOSHADES */
 875 #  endif /* OVL1 */
 876 # endif /* TEXTCOLOR */
 877
 878 /*
 879  * Process defaults.nh OPTIONS=video:xxxx
 880  *
 881  *    where (current) legitimate values are:
 882  *
 883  *    autodetect (attempt to determine the adapter type)
 884  *    default    (force use of the default video method for environment)
 885  *    vga        (use vga adapter code)
 886  */
 887 # ifdef OVL1
 888 int
 889 assign_video(sopt)
 890 char *sopt;
 891 {
 892
 893 /*
 894  * debug
 895  *
 896  *      printf("video is %s",sopt);
 897  *      getch();
 898  */
 899         iflags.grmode  = 0;
 900         iflags.hasvga  = 0;
 901         iflags.usevga  = 0;
 902
 903         if (strncmpi(sopt,"def",3) == 0) {              /* default */
 904                 /* do nothing - default */
 905 #  ifdef SCREEN_VGA
 906         } else if (strncmpi(sopt,"vga",3) == 0) {       /* vga */
 907                 iflags.usevga  = 1;
 908                 iflags.hasvga  = 1;
 909 #  endif
 910 #  ifdef SCREEN_VESA
 911         } else if (strncmpi(sopt,"vesa",4) == 0) {      /* vesa */
 912                 iflags.hasvesa = 1;
 913                 iflags.usevesa = 1;
 914 #  endif
 915 #  ifdef SCREEN_8514
 916         } else if (strncmpi(sopt,"8514",4) == 0) {      /* 8514/A */
 917                 iflags.use8514 = 1;
 918                 iflags.has8514 = 1;
 919 #  endif
 920         } else if (strncmpi(sopt,"auto",4) == 0) {      /* autodetect */
 921 #  ifdef SCREEN_VESA
 922                 if (vesa_detect()) {
 923                         iflags.hasvesa = 1;
 924                 }
 925 #  endif
 926 #  ifdef SCREEN_8514
 927                 if (v8514_detect()) {
 928                         iflags.has8514 = 1;
 929                 }
 930 #  endif
 931 #  ifdef SCREEN_VGA
 932                 if (vga_detect()) {
 933                         iflags.hasvga  = 1;
 934                 }
 935 #  endif
 936         /*
 937          * Auto-detect Priorities (arbitrary for now):
 938          *      VGA
 939          */
 940                 if (iflags.hasvga)      {
 941                         iflags.usevga  = 1;
 942                         /* VGA depends on BIOS to enable function keys*/
 943                         iflags.BIOS = 1;
 944                         iflags.rawio = 1;
 945                 }
 946         } else {
 947                 return 0;
 948         }
 949         return 1;
 950 }
 951 # endif /* OVL1 */
 952 # ifdef OVL0
 953
 954 void tileview(enable)
 955 boolean enable;
 956 {
 957 #ifdef SCREEN_VGA
 958         if (iflags.grmode) vga_traditional(enable ? FALSE : TRUE);
 959 #endif
 960 }
 961 # endif /* OVL0 */
 962 #endif /* NO_TERMS  */
 963 #else   /* STUBVIDEO */
 964 void tileview(enable)
 965 boolean enable;
 966 {
 967 }
 968 #endif /* STUBVIDEO */
 969