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