This commit was generated by cvs2svn to compensate for changes in r2,
[btb/d2x.git] / 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