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