unused/bios/mono.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 #pragma off (unreferenced)
  15 static char rcsid[] = "$Id: mono.c,v 1.1.1.1 2001-01-19 03:30:14 bradleyb Exp $";
  16 #pragma on (unreferenced)
  17
  18 // Library functions for printing to mono card.
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24 #include <dos.h>
  25 #include <conio.h>
  26
  27 #include "key.h"
  28
  29 void mono_int_3();
  30 #pragma aux mono_int_3 = "int 3";
  31
  32 #define MAX_NUM_WINDOWS 2
  33
  34 struct mono_element {
  35         unsigned char character;
  36         unsigned char attribute;
  37 };
  38
  39 typedef struct  {
  40         short   first_row;
  41         short   height;
  42         short   first_col;
  43         short   width;
  44         short   cursor_row;
  45         short   cursor_col;
  46         short   open;
  47         struct  mono_element save_buf[25][80];
  48         struct  mono_element text[25][80];
  49 } WINDOW;
  50
  51
  52 void scroll( short n );
  53 void drawbox( short n );
  54
  55 #define ROW             Window[n].first_row
  56 #define HEIGHT          Window[n].height
  57 #define COL             Window[n].first_col
  58 #define WIDTH           Window[n].width
  59 #define CROW            Window[n].cursor_row
  60 #define CCOL            Window[n].cursor_col
  61 #define OPEN            Window[n].open
  62 #define CHAR(r,c)       (*monoscreen)[ROW+(r)][COL+(c)].character
  63 #define ATTR(r,c)       (*monoscreen)[ROW+(r)][COL+(c)].attribute
  64 #define XCHAR(r,c)      Window[n].text[ROW+(r)][COL+(c)].character
  65 #define XATTR(r,c)      Window[n].text[ROW+(r)][COL+(c)].attribute
  66
  67 static WINDOW Window[MAX_NUM_WINDOWS];
  68
  69 struct mono_element (*monoscreen)[25][80];
  70
  71 void mputc( short n, char c )
  72 {
  73         if (!OPEN) return;
  74
  75 //      if (keyd_pressed[KEY_BACKSP])
  76 //              mono_int_3();
  77
  78         switch (c)
  79         {
  80         case 8:
  81                 if (CCOL > 0) CCOL--;
  82                 break;
  83         case 9:
  84                 CHAR( CROW, CCOL ) = ' ';
  85                 ATTR( CROW, CCOL ) = XATTR( CROW, CCOL );
  86                 XCHAR( CROW, CCOL ) = ' ';
  87                 CCOL++;
  88                 while (CCOL % 4) {
  89                         CHAR( CROW, CCOL ) = ' ';
  90                         ATTR( CROW, CCOL ) = XATTR( CROW, CCOL );
  91                         XCHAR( CROW, CCOL ) = ' ';
  92                         CCOL++;
  93                 }
  94                 break;
  95         case 10:
  96         case 13:
  97                 CCOL = 0;
  98                 CROW++;
  99                 break;
 100         default:
 101                 CHAR( CROW, CCOL ) = c;
 102                 ATTR( CROW, CCOL ) = XATTR( CROW, CCOL );
 103                 XCHAR( CROW, CCOL ) = c;
 104                 CCOL++;
 105         }
 106
 107         if ( CCOL >= WIDTH )    {
 108                 CCOL = 0;
 109                 CROW++;
 110         }
 111         if ( CROW >= HEIGHT )   {
 112                 CROW--;
 113                 scroll(n);
 114         }
 115
 116         msetcursor( ROW+CROW, COL+CCOL );
 117
 118 }
 119
 120 void mputc_at( short n, short row, short col, char c )
 121 {
 122         CROW = row;
 123         CCOL = col;
 124
 125         if (!OPEN) return;
 126
 127         mputc( n, c );
 128
 129 }
 130
 131
 132 void copy_row(int nwords,short *src, short *dest1, short *dest2 );
 133 #pragma aux copy_row parm [ecx] [esi] [ebx] [edx] modify exact [eax ebx ecx edx esi] = \
 134 "                               shr             ecx, 1"                         \
 135 "                               jnc             even_num"                       \
 136 "                               mov             ax, [esi]"                      \
 137 "                               add             esi, 2"                         \
 138 "                               mov             [ebx], ax"                      \
 139 "                               add             ebx, 2"                         \
 140 "                               mov             [edx], ax"                      \
 141 "                               add             edx, 2"                         \
 142 "even_num:      cmp             ecx, 0"                         \
 143 "                               je                      done"                                   \
 144 "rowloop:       mov             eax, [esi]"                     \
 145 "                               add             esi, 4"                         \
 146 "                               mov             [edx], eax"                     \
 147 "                               add             edx, 4"                         \
 148 "                               mov             [ebx], eax"                     \
 149 "                               add             ebx, 4"                         \
 150 "                               loop            rowloop"                                \
 151 "done:  "
 152
 153
 154 void scroll( short n )
 155 {
 156         register row, col;
 157
 158         if (!OPEN) return;
 159
 160         col = 0;
 161         for ( row = 0; row < (HEIGHT-1); row++ )
 162                 copy_row( WIDTH, (short *)&XCHAR(row+1,col), (short *)&CHAR(row,col), (short *)&XCHAR(row,col) );
 163
 164 //              for ( col = 0; col < WIDTH; col++ )
 165 //              {
 166 //                      CHAR( row, col ) = XCHAR( row+1, col );
 167 //                      ATTR( row, col ) = XATTR( row+1, col );
 168 //                      XCHAR( row, col ) = XCHAR( row+1, col );
 169 //                      XATTR( row, col ) = XATTR( row+1, col );
 170 //              }
 171
 172         for ( col = 0; col < WIDTH; col++ )
 173         {
 174                 CHAR( HEIGHT-1, col ) = ' ';
 175                 ATTR( HEIGHT-1, col ) = XATTR( HEIGHT-1, col );
 176                 XCHAR( HEIGHT-1, col ) = ' ';
 177         }
 178
 179 }
 180
 181 void msetcursor(short row, short col)
 182 {
 183         int pos = row*80+col;
 184
 185         outp( 0x3b4, 15 );
 186         outp( 0x3b5, pos & 0xFF );
 187         outp( 0x3b4, 14 );
 188         outp( 0x3b5, (pos >> 8) & 0xff );
 189 }
 190
 191 static char temp_m_buffer[1000];
 192 void mprintf( short n, char * format, ... )
 193 {
 194         char *ptr=temp_m_buffer;
 195         va_list args;
 196
 197         if (!OPEN) return;
 198
 199         va_start(args, format );
 200         vsprintf(temp_m_buffer,format,args);
 201         while( *ptr )
 202                 mputc( n, *ptr++ );
 203
 204 }
 205
 206 void mprintf_at( short n, short row, short col, char * format, ... )
 207 {
 208         int r,c;
 209         char buffer[1000], *ptr=buffer;
 210         va_list args;
 211
 212         if (!OPEN) return;
 213
 214         r = CROW; c = CCOL;
 215
 216         CROW = row;
 217         CCOL = col;
 218
 219         va_start(args, format );
 220         vsprintf(buffer,format,args);
 221         while( *ptr )
 222                 mputc( n, *ptr++ );
 223
 224
 225         CROW = r; CCOL = c;
 226
 227         msetcursor( ROW+CROW, COL+CCOL );
 228
 229 }
 230
 231
 232 void drawbox(short n)
 233 {
 234         short row, col;
 235
 236         if (!OPEN) return;
 237
 238         for (row=0; row <HEIGHT; row++ )    {
 239                 CHAR( row, -1 ) = 179;
 240                 CHAR( row, WIDTH ) = 179;
 241                 XCHAR( row, -1 ) = 179;
 242                 XCHAR( row, WIDTH ) = 179;
 243         }
 244
 245         for (col=0; col < WIDTH; col++ )  {
 246                 CHAR( -1, col ) = 196;
 247                 CHAR( HEIGHT, col ) = 196;
 248                 XCHAR( -1, col ) = 196;
 249                 XCHAR( HEIGHT, col ) = 196;
 250         }
 251
 252         CHAR( -1,-1 ) = 218;
 253         CHAR( -1, WIDTH ) = 191;
 254         CHAR( HEIGHT, -1 ) = 192;
 255         CHAR( HEIGHT, WIDTH ) = 217;
 256         XCHAR( -1,-1 ) = 218;
 257         XCHAR( -1, WIDTH ) = 191;
 258         XCHAR( HEIGHT, -1 ) = 192;
 259         XCHAR( HEIGHT, WIDTH ) = 217;
 260
 261 }
 262
 263 void mclear( short n )
 264 {
 265         short row, col;
 266
 267         if (!OPEN) return;
 268
 269         for (row=0; row<HEIGHT; row++ )
 270                 for (col=0; col<WIDTH; col++ )  {
 271                         CHAR(row,col) = 32;
 272                         ATTR(row,col) = 7;
 273                         XCHAR(row,col) = 32;
 274                         XATTR(row,col) = 7;
 275                 }
 276         CCOL = 0;
 277         CROW = 0;
 278 }
 279
 280 void mclose(short n)
 281 {
 282         short row, col;
 283
 284         if (!OPEN) return;
 285
 286         for (row=-1; row<HEIGHT+1; row++ )
 287                 for (col=-1; col<WIDTH+1; col++ )  {
 288                         CHAR(row,col) = 32;
 289                         ATTR(row,col) = 7;
 290                 }
 291         OPEN = 0;
 292         CCOL = 0;
 293         CROW = 0;
 294
 295         msetcursor(0,0);
 296
 297 }
 298
 299 void mrefresh(short n)
 300 {
 301         short row, col;
 302
 303         if (!OPEN) return;
 304
 305         for (row=-1; row<HEIGHT+1; row++ )
 306                 for (col=-1; col<WIDTH+1; col++ )  {
 307                         CHAR(row,col) = XCHAR(row,col);
 308                         ATTR(row,col) = XATTR(row,col);
 309                 }
 310
 311         msetcursor( ROW+CROW, COL+CCOL );
 312
 313 }
 314
 315
 316 int mono_present();             //return true if mono monitor in system
 317
 318
 319 void mopen( short n, short row, short col, short width, short height, char * title )
 320 {
 321 //      if (n==0) return;
 322
 323         if (! mono_present()) return;   //error! no mono card
 324
 325         if (OPEN) mclose(n);
 326
 327         OPEN = 1;
 328         ROW = row;
 329         COL = col;
 330         WIDTH = width;
 331         HEIGHT = height;
 332
 333         for (row=-1; row<HEIGHT+1; row++ )
 334                 for (col=-1; col<WIDTH+1; col++ )  {
 335                         CHAR(row,col) = 32;
 336                         ATTR(row,col) = 7;
 337                         XCHAR(row,col) = 32;
 338                         XATTR(row,col) = 7;
 339                 }
 340
 341         drawbox(n);
 342         CROW=-1; CCOL=0;
 343         mprintf( n, title );
 344         CROW=0; CCOL=0;
 345         msetcursor( ROW+CROW, COL+CCOL );
 346
 347 }
 348
 349 #pragma aux mono_present value [eax] modify [bx] = \
 350         "mov    ax,1a00h"       \
 351         "int    10h"                    \
 352         "mov    eax,-1"         \
 353         "cmp    bl,1"                   \
 354         "je     got_it"         \
 355         "cmp    bh,1"                   \
 356         "je     got_it"         \
 357         "xor    eax,eax"                \
 358 "got_it:";
 359
 360
 361 int minit()
 362 {
 363         short n;
 364         static initialized=0;
 365         //short col, row;
 366
 367         if (! mono_present()) return 0; //error! no mono card
 368
 369         if (initialized)
 370                 return 1;
 371
 372         initialized=1;
 373
 374         monoscreen = (struct mono_element (*)[25][80])0xB0000;
 375
 376         n=0;
 377         OPEN=1;
 378         ROW=2;
 379         COL=0;
 380         WIDTH=80;
 381         HEIGHT=24;
 382         CCOL=0;
 383         CROW=0;
 384
 385         mclear(0);
 386
 387         for (n=1; n<MAX_NUM_WINDOWS; n++ )  {
 388                 OPEN = 0;
 389                 ROW = 2;
 390                 COL = 1;
 391                 WIDTH=78;
 392                 HEIGHT=23;
 393                 CROW=0;
 394                 CCOL=0;
 395         }
 396
 397         return -1;      //everything ok
 398 }
 399