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