Cygwin support, using SDL.
[btb/d2x.git] / 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