![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dispatch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os2sdk / demos / apps / sse|
Return to dispatch.c CVS log | Up to [OS/2 SDKs] / os2sdk / demos / apps / sse |
1.1 root 1: /*** dispatch() - accepts keyboard input and dispatches control to
2: * the appropriate function.
3: *
4: * Wait in a loop for keyboard input, then dispatch to any of several
5: * functions based on what the character code was. Default is insert()
6: * after validating, otherwise it is one of our control keys. There is
7: * a second dispatch function for special keys - those with zero for a
8: * character value. special_dispatch() works based on the scan code.
9: *
10: * EFFECTS: No global variables are directly effected by this function
11: */
12:
13:
14: #include <ctype.h>
15: #include <dos.h>
16: #include <doscalls.h>
17: #include <subcalls.h>
18: #include "ssedefs.h"
19: #include "keydefs.h"
20:
21:
22: void dispatch()
23: {
24:
25: struct KeyData keydata; /* data structure from subcalls.h */
26: struct KbdStatus kbdstatus; /* data structure from subcalls.h */
27:
28: kbdstatus.length = sizeof( kbdstatus );
29: KBDGETSTATUS( &kbdstatus, 0 ); /* set keyboard mode */
30: kbdstatus.bit_mask |= 4;
31: KBDSETSTATUS( &kbdstatus, 0 );
32:
33:
34: /* the following section waits for keyboard input */
35: /* then examines the key received and dispatches us */
36: /* to the appropriate function for the key pressed. */
37:
38:
39: while(1) {
40:
41:
42: KBDCHARIN( &keydata, 0, 0 ); /* get a character from KBD */
43:
44:
45: switch( keydata.char_code ) {
46:
47: default: /* default is not */
48: if ( isprint( keydata.char_code ) ) /* a control key. */
49: insert( keydata.char_code ); /* check validity */
50: else badkey(); /* and if good, */
51: break; /* call insert() */
52:
53: /* "special keys", those with character codes of 00, must */
54: /* be sent to another dispatcher that checks scan codes. */
55:
56: case SPECIAL_KEYS_CHAR:
57: special_dispatch( keydata.scan_code,
58: keydata.shift_state );
59: break;
60:
61: /* all others keys we can dispatch from here. some */
62: /* are easy, just dispatch based on char code... */
63:
64: case CTRL_B_CHAR:
65: ctrl_b();
66: break;
67:
68: case BKSP_CHAR:
69: bksp();
70: break;
71:
72: case TAB_CHAR:
73: tab();
74: break;
75:
76: case CRETURN_CHAR:
77: creturn();
78: break;
79:
80: case CTRL_N_CHAR:
81: ctrl_n();
82: break;
83:
84: case CTRL_Y_CHAR:
85: ctrl_y();
86: break;
87:
88:
89: /* ...for others, we must check the scan code and shift */
90: /* also as the char code may be shared with another key. */
91:
92: case SHIFT_END_CHAR:
93: if ( keydata.scan_code == END_SCAN &&
94: keydata.shift_state < 3 )
95: shift_end();
96: else insert( keydata.char_code );
97: break;
98:
99: case SHIFT_DOWN_CHAR:
100: if ( keydata.scan_code == DOWN_SCAN &&
101: keydata.shift_state < 3 )
102: shift_down();
103: else insert( keydata.char_code );
104: break;
105:
106: case SHIFT_LEFT_CHAR:
107: if ( keydata.scan_code == LEFT_SCAN &&
108: keydata.shift_state < 3 )
109: shift_left();
110: else insert( keydata.char_code );
111: break;
112:
113: case SHIFT_RIGHT_CHAR:
114: if ( keydata.scan_code == RIGHT_SCAN &&
115: keydata.shift_state < 3 )
116: shift_right();
117: else insert( keydata.char_code );
118: break;
119:
120: case SHIFT_HOME_CHAR:
121: if ( keydata.scan_code == HOME_SCAN &&
122: keydata.shift_state < 3 )
123: shift_home();
124: else insert( keydata.char_code );
125: break;
126:
127: case SHIFT_UP_CHAR:
128: if ( keydata.scan_code == UP_SCAN &&
129: keydata.shift_state < 3 )
130: shift_up();
131: else insert( keydata.char_code );
132: break;
133:
134: /* There's one other possibility, that the char code is 0xE0 */
135: /* which indicates an arrow key on the new AT03 keyboard. */
136: /* We will treat these in the same manner as special keys. */
137:
138: case ARROW_CHAR:
139: special_dispatch( keydata.scan_code,
140: keydata.shift_state );
141: break;
142:
143:
144: }
145:
146: }
147:
148: }
149:
150:
151: /*** special_dispatch(c,s) - dispatches control to the appropriate function
152: * based on character and scan codes received
153: *
154: * Characters with zero character codes or character code 0xE0 are sent
155: * here to be dispatched based on their scan code and shift status. These
156: * values are passed to special_dispatch as parameters.
157: *
158: * The left and right arrow keys are handled in this routine rather than
159: * dispatched to their own functions in an attempt to gain some speed.
160: *
161: * ENTRY: scan - scan code of the key press
162: * shift - shift state of the key press
163: *
164: * EFFECTS: No global variables are directly effected by this function
165: * unless the key is an unshifted right or left arrow.
166: * In that case, effects are:
167: *
168: * LinesMarked - this flag is cleared
169: * MarkedLine[] - all cleared
170: * CharsMarked - this flag is cleared
171: * MarkedChar[] - all cleared
172: * EditBuff[] - may be flushed if above were set
173: * EditBuffDirty - cleared if EditBuff[] flushed
174: * CurCol - incremented or decremented
175: */
176:
177: special_dispatch(scan,shift) /* dispatcher for "special keys" based on */
178: /* the scan code and shift code from KBD */
179:
180: unsigned char scan; /* scan code - must be unsigned */
181: unsigned shift; /* shift code */
182:
183: {
184:
185: register short i; /* indexing variable */
186:
187: switch( scan ) { /* dispatch based on what scan code was */
188: /* - check the shift state if necessary */
189: case LEFT_SCAN:
190: if( shift == 0 ) { /* left arrow handled here for speed */
191:
192: if ( LinesMarked || CharsMarked ) {
193: LinesMarked = 0; /* if there's marked */
194: CharsMarked = 0; /* text, clear it */
195: for ( i = 0; i < MAXLINES; i++ )
196: MarkedLine[i] = 0;
197: for ( i = 0; i < LINESIZE; i++ )
198: MarkedChar[i] = 0;
199: if (EditBuffDirty) { /* flush EditBuff before redraw */
200: EditBuffDirty = 0;
201: flushline((TopRow + CurRow), EditBuff);
202: }
203: drawscr(TopRow); /* redraw the screen */
204: }
205:
206: if ( CurCol > 0 ) {
207: CurCol -= 1; /* move cursor left 1 */
208: VIOSETCURPOS( CurRow, CurCol, 0 ); /* if there's room */
209: }
210:
211: }
212:
213: else
214: shift_left();
215: break;
216:
217: case RIGHT_SCAN:
218: if( shift == 0 ) { /* right arrow handled here for speed */
219:
220: if ( LinesMarked || CharsMarked ) {
221: LinesMarked = 0; /* if there's marked */
222: CharsMarked = 0; /* text, clear it */
223: for ( i = 0; i < MAXLINES; i++ )
224: MarkedLine[i] = 0;
225: for ( i = 0; i < LINESIZE; i++ )
226: MarkedChar[i] = 0;
227: if (EditBuffDirty) { /* flush EditBuff before redraw */
228: EditBuffDirty = 0;
229: flushline((TopRow + CurRow), EditBuff);
230: }
231: drawscr(TopRow); /* redraw the screen */
232: }
233:
234: if (CurCol < (LINESIZE -1)) { /* move cursor right one */
235: CurCol += 1; /* column if there's room */
236: VIOSETCURPOS( CurRow, CurCol, 0 );
237: }
238:
239: }
240:
241: else
242: shift_right();
243: break;
244:
245: case UP_SCAN:
246: if( shift == 0 )
247: up();
248: else
249: shift_up();
250: break;
251:
252: case DOWN_SCAN:
253: if( shift == 0 )
254: down();
255: else
256: shift_down();
257: break;
258:
259: case HOME_SCAN:
260: if( shift == 0 )
261: home();
262: else
263: shift_home();
264: break;
265:
266: case END_SCAN:
267: if( shift == 0 )
268: end_();
269: else
270: shift_end();
271: break;
272:
273: case PGUP_SCAN:
274: pgup();
275: break;
276:
277: case PGDN_SCAN:
278: pgdn();
279: break;
280:
281: case CTRL_HOME_SCAN:
282: ctrl_home();
283: break;
284:
285: case CTRL_END_SCAN:
286: ctrl_end();
287: break;
288:
289: case CTRL_PGUP_SCAN:
290: ctrl_pgup();
291: break;
292:
293: case CTRL_PGDN_SCAN:
294: ctrl_pgdn();
295: break;
296:
297: case DEL_SCAN:
298: del();
299: break;
300:
301: case F9_SCAN:
302: F9();
303: break;
304:
305: case F10_SCAN:
306: F10();
307: break;
308:
309: default:
310: badkey();
311:
312: }
313:
314: }
315:
316:
317: /*** badkey() - sounds a beep when an invalid or inappropriate key is hit
318: *
319: * EFFECTS: None
320: */
321:
322: badkey()
323: {
324: DOSBEEP (500, 50); /* frequency = 500 Hertz */
325: } /* duration = 50 milliseconds */
326:
327:
328: /*** clearscr() - clears the screen by writing blanks over entire screen
329: *
330: * clearscr() writes blanks with normal attributes over the entire screen,
331: * effectively clearing it.
332: *
333: * EFFECTS: None
334: */
335:
336: void clearscr()
337: {
338: char buff[2]; /* local buffer for filling cell value */
339:
340: buff[0] = ' '; /* cell to replicate is a blank */
341: buff[1] = BackNorm + ForeNorm; /* with normal attributes */
342:
343: VIOSCROLLUP(0, 0, -1, -1, -1, (char far *)buff, 0);
344:
345: /* when the first 5 parameters are */
346: /* set as above, the entire screen */
347: /* is filled with the cell in buff */
348: }
349:
350:
351: /*** drawscr(startline) - redraws the screen starting at the specified line
352: *
353: * drawscr() redraws the screen starting at the line specified in the
354: * parameter it is passed, startline. The screen is drawn with normal
355: * attributes, since this call will never be made with lines marked.
356: * Nothing is done with EditBuff[], that is left to the caller, as is
357: * the value of TopRow.
358: *
359: * ENTRY: startline - the line in the file which will be at the top of
360: * the screen when redrawn.
361: *
362: * EFFECTS: ScrBuff[][] - gets reloaded
363: */
364:
365: void drawscr(startline)
366:
367: unsigned short startline;
368: {
369:
370: register unsigned short i, j; /* indexing variables */
371:
372: char normal = BackNorm + ForeNorm; /* normal attributes */
373:
374: for ( i = startline, j = 0 ; j < PageSize ; i++, j++)
375: getline( i, &ScrBuff[j][0] ); /* load ScrBuff[][] with the */
376: /* part of the screen we want */
377:
378: VIOWRTCHARSTRATT ( (char far *)ScrBuff, ( PageSize * LINESIZE ), 0, 0,
379: &normal, 0 );
380: /* write it out to the screen */
381: }
382:
383:
384: /*** drawline() - redraws the current line
385: *
386: * drawline() redraws the line the cursor is currently on, using the
387: * contents of EditBuff[]. All marked characters will be drawn with the
388: * appropriate attributes. If the line is marked, all characters are
389: * drawn as marked; if the line is not marked, then the characters marked
390: * flag is checked. If characters are marked, the line is drawn in three
391: * sections - unmarked characters at the front of the line (may be 0),
392: * marked characters in the middle of the line (at least 1), and unmarked
393: * characters at the end of the line (may be 0). If no characters are marked
394: * either, then the line is drawn with all normal attributes.
395: *
396: * EFFECTS: None
397: */
398:
399: drawline()
400: {
401: unsigned short i; /* indexing variables */
402: unsigned short j;
403:
404: char hilite = BackHilite + ForeHilite; /* attributes for marked */
405: char normal = BackNorm + ForeNorm; /* attributes for not marked */
406:
407: if( MarkedLine[TopRow+CurRow] )
408: VIOWRTCHARSTRATT( EditBuff, LINESIZE, CurRow, 0, &hilite, 0);
409: /* if line is marked, do this */
410: else if (CharsMarked) {
411: for( i = 0; !MarkedChar[i] & (i < LINESIZE); i++ );
412: for( j = i; MarkedChar[j] & (j < LINESIZE); j++ );
413: VIOWRTCHARSTRATT( &EditBuff[0], i, CurRow, 0, &normal, 0);
414: VIOWRTCHARSTRATT( &EditBuff[i], (j - i), CurRow, i, &hilite, 0);
415: VIOWRTCHARSTRATT( &EditBuff[j], (LINESIZE - j), CurRow, j,
416: &normal, 0);
417: } /* else if characters marked, do this */
418:
419: else VIOWRTCHARSTRATT( EditBuff, LINESIZE, CurRow, 0, &normal, 0);
420: } /* else if neither marked, do this */
421:
422:
423: /*** line25() - updates line number information on last line
424: *
425: * line25() updates the line numbers maintained in the lower right hand
426: * corner of the screen - current line of cursor and total lines in file.
427: * These numbers are first converted from their zero-based internal values
428: * to a more friendly one-based number. Lots of standing on our heads is
429: * done to get the numbers into decimal characters without using C runtime
430: * routines or doing divisions.
431: *
432: * Note that while the names of these routines refer to the 25th line,
433: * the pagesize is not hardcoded - if we are in 43 line mode, this
434: * information will appear on the 43rd line. However, the spacing within
435: * the line is hardcoded for an 80-column display.
436: *
437: * EFFECTS - None
438: */
439:
440: void line25()
441: {
442:
443: int flag0 = 0; /* flag to aid in supressing leading 0's */
444: int col = 67; /* starting column for this info */
445: int i, n; /* indexing variables */
446: char buff[LINESIZE]; /* buffer to build output string */
447: char attrib = Back25 + Fore25; /* attributes for output string */
448:
449: n = (TopRow + CurRow + 1); /* set n to line number cursor is on */
450:
451: for( i = 0; n > 9999; n -= 10000, i++ );
452: if( i > 0 ) {
453: flag0 = 1; /* 10,000's place of current line */
454: buff[0] = i + 0x30;
455: }
456: else buff[0] = ' ';
457: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
458: col += 1;
459:
460: for( i = 0; n > 999; n -= 1000, i++ );
461: if( i > 0 ) {
462: flag0 = 1; /* 1,000's place of current line */
463: buff[0] = i + 0x30;
464: }
465: else if( flag0 ) buff[0] = '0';
466: else buff[0] = ' ';
467: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
468: col += 1;
469:
470: for( i = 0; n > 99; n -= 100, i++ );
471: if( i > 0 ) {
472: flag0 = 1; /* 100's place of current line */
473: buff[0] = i + 0x30;
474: }
475: else if( flag0 ) buff[0] = '0';
476: else buff[0] = ' ';
477: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
478: col += 1;
479:
480: for( i = 0; n > 9; n -= 10, i++ );
481: if( i > 0 ) {
482: flag0 = 1; /* 10's place of current line */
483: buff[0] = i + 0x30;
484: }
485: else if( flag0 ) buff[0] = '0';
486: else buff[0] = ' ';
487: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
488: col += 1;
489:
490: buff[0] = n + 0x30; /* 1's place of current line */
491: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
492: col += 1;
493:
494: buff[0] = ' ';
495: buff[1] = '/'; /* delimiting characters */
496: buff[2] = ' ';
497: VIOWRTCHARSTRATT( buff, 3, PageSize, col, &attrib, 0 );
498: col += 3;
499:
500: flag0 = 0;
501: n = TotalLines; /* n is total lines in file */
502:
503: for( i = 0; n > 9999; n -= 10000, i++ );
504: if( i > 0 ) {
505: flag0 = 1; /* 10,000's place of total lines */
506: buff[0] = i + 0x30;
507: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
508: col += 1;
509: }
510:
511: for( i = 0; n > 999; n -= 1000, i++ );
512: if( i > 0 ) {
513: flag0 = 1; /* 1,000's place of total lines */
514: buff[0] = i + 0x30;
515: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
516: col += 1;
517: }
518: else if( flag0 ) {
519: buff[0] = '0';
520: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
521: col += 1;
522: }
523:
524: for( i = 0; n > 99; n -= 100, i++ );
525: if( i > 0 ) {
526: flag0 = 1; /* 100's place of total lines */
527: buff[0] = i + 0x30;
528: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
529: col += 1;
530: }
531: else if( flag0 ) {
532: buff[0] = '0';
533: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
534: col += 1;
535: }
536:
537: for( i = 0; n > 9; n -= 10, i++ );
538: if( i > 0 ) {
539: flag0 = 1; /* 10's place of total lines */
540: buff[0] = i + 0x30;
541: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
542: col += 1;
543: }
544: else if( flag0 ) {
545: buff[0] = '0';
546: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
547: col += 1;
548: }
549:
550: buff[0] = n + 0x30; /* 1's place of total lines */
551: VIOWRTCHARSTRATT( buff, 1, PageSize, col, &attrib, 0 );
552:
553: col +=1;
554: n = LINESIZE - col; /* fill rest of line with blanks; n is how many */
555: for( i = 0; i < LINESIZE; buff[i] = ' ', i++ );
556: VIOWRTCHARSTRATT( buff, n, PageSize, col, &attrib, 0 );
557:
558: }
559:
560: /*** name25() - draws prompt and displays filename on 25th line
561: *
562: * This routine draws a prompt line with usage information about some
563: * of the less obvious function keys, and the name of the file currently
564: * being edited. Will be called at the start of execution, and whenever
565: * an error message has been displayed on the 25th line so that we need
566: * to re-draw the usage message after the error is responded to. The
567: * line25() routine takes care of the line numbers at the far right end
568: * of the line.
569: *
570: * Note that while the names of these routines refer to the 25th line,
571: * the pagesize is not hardcoded - if we are in 43 line mode, this
572: * information will appear on the 43rd line. Spacing within the line
573: * is hardcoded for an 80-column display.
574: *
575: * EFFECTS - None
576: */
577:
578: void name25()
579: {
580:
581: static char message[51] = "^N/^B=insert above/below ^Y=delete F9=save F10=quit";
582: char name[16]; /* for holding name of file */
583: char attrib = Back25 + Fore25; /* attributes for message */
584: int i, j, k; /* indexing variables */
585:
586:
587: /* first, print usage message */
588: VIOWRTCHARSTRATT( message, 51, PageSize, 0, &attrib, 0 );
589:
590:
591: /* build filename string */
592:
593: name[0] = ' ';
594: name[1] = ' '; /* some blanks at start and end */
595: name[2] = ' ';
596: name[15] = ' ';
597:
598: for( i = 0; fname[i] != 0; i++); /* find null terminator for fname */
599:
600: if( i > 0 ) i--; /* point i to last letter in fname */
601:
602: for( j = i, k = 14;
603: (fname[j] != '\\') && (fname[j] != ':') && (j >= 0) && (k >= 0);
604: name[k] = fname[j], j--, k-- );
605: /* move the file name into name[] backwards until */
606: /* we hit a backslash, colon or start of the name */
607:
608: for( ; k >= 0; name[k] = ' ', k-- ); /* if any room left, blank fill */
609:
610: VIOWRTCHARSTRATT( name, 16, PageSize, 51, &attrib, 0 ); /* write it */
611:
612: line25(); /* call the line number routine */
613:
614: }
615:
616:
617: /*** error25(error) - displays error messages on 25th line, accepts responses
618: *
619: * error25() displays an error message on the 25th line when any of several
620: * error conditions are encountered, the type of error being passed as a
621: * parameter. In some cases we just abort; in others we accept input from
622: * the user to determine what to do next.
623: *
624: * Note that while the names of these routines refer to the 25th line,
625: * the pagesize is not hardcoded - if we are in 43 line mode, this
626: * information will appear on the 43rd line. Spacing within the line
627: * is hardcoded for an 80-column display.
628: *
629: * ENTRY - Error - an arbitrary number identifying the error encountered
630: *
631: * EFFECTS - May cause us to end execution; otherwise, none
632: */
633:
634: void error25(error)
635: unsigned short error;
636: {
637: static char message1[51] = "ERROR: Out of memory or can't read file ";
638: static char message2[51] = "ERROR: Unable to create backup. Continue? (y/n) ";
639: static char message3[51] = "File not found. Create? (y/n) ";
640: static char message4[51] = "ERROR: Unable to create file ";
641: static char message5[51] = "ERROR: Unable to open file - denied write access ";
642: static char message6[51] = "ERROR: Unable to open file ";
643: static char message7[51] = "ERROR: Out of memory. S = save Q = quit ";
644: static char message8[51] = "ERROR: No filename given on command line ";
645: static char message9[51] = "ERROR: Invalid argument on command line ";
646: static char message10[51] = "ERROR: Too many parameters on command line ";
647: static char message11[51] = "ERROR: Unable to save file. C = continue ";
648: static char message99[51] = "ERROR: Unknown error. Continue? (y/n) ";
649: struct KeyData keydata;
650: char attrib = Back25 + Fore25; /* attributes for our messages */
651:
652:
653: switch( error ) { /* take the appropriate action for the error */
654:
655: case 1:
656: VIOWRTCHARSTRATT( message1, 51, PageSize, 0, &attrib, 0 );
657: quit(1);
658: break; /* 1 -> print message and quit */
659:
660: case 2:
661: VIOWRTCHARSTRATT( message2, 51, PageSize, 0, &attrib, 0 );
662: VIOSETCURPOS( PageSize, 50, 0 );
663:
664: while( 1 ) { /* 2 -> get a character from KBD */
665:
666: KBDCHARIN( &keydata, 0, 0 );
667:
668: if( (keydata.char_code == 'y') || (keydata.char_code == 'Y') ) {
669: name25();
670: break; /* if Y, go ahead */
671: }
672:
673: else if( (keydata.char_code == 'n') || (keydata.char_code == 'N') ) {
674: VIOWRTCHARSTRATT( &keydata.char_code, 1, PageSize, 50, &attrib, 0 );
675: quit(1); /* if N, quit with error */
676: break;
677: }
678:
679: else badkey(); /* otherwise wait for another key */
680:
681: }
682: break;
683:
684: case 3:
685: VIOWRTCHARSTRATT( message3, 51, PageSize, 0, &attrib, 0 );
686: VIOSETCURPOS( PageSize, 32, 0 );
687:
688: while( 1 ) { /* 3 -> get a character from KBD */
689:
690: KBDCHARIN( &keydata, 0, 0 );
691:
692: if( (keydata.char_code == 'y') || (keydata.char_code == 'Y') ) {
693: name25();
694: break; /* if Y, go ahead */
695: }
696:
697: else if( (keydata.char_code == 'n') || (keydata.char_code == 'N') ) {
698: VIOWRTCHARSTRATT( &keydata.char_code, 1, PageSize, 50, &attrib, 0 );
699: quit(1); /* if N, quit with error */
700: break;
701: }
702:
703: else badkey(); /* otherwise wait for another key */
704:
705: }
706: break;
707:
708: case 4:
709: VIOWRTCHARSTRATT( message4, 51, PageSize, 0, &attrib, 0 );
710: quit(1);
711: break; /* 4 -> print message and quit */
712:
713: case 5:
714: VIOWRTCHARSTRATT( message5, 51, PageSize, 0, &attrib, 0 );
715: quit(1);
716: break; /* 5 -> print message and quit */
717:
718: case 6:
719: VIOWRTCHARSTRATT( message6, 51, PageSize, 0, &attrib, 0 );
720: quit(1);
721: break; /* 6 -> print message and quit */
722:
723: case 7:
724: VIOWRTCHARSTRATT( message7, 51, PageSize, 0, &attrib, 0 );
725: VIOSETCURPOS( PageSize, 44, 0 );
726:
727: while( 1 ) { /* 7 -> get a character from KBD */
728:
729: KBDCHARIN( &keydata, 0, 0 );
730:
731: if( (keydata.char_code == 's') || (keydata.char_code == 'S') ) {
732: VIOWRTCHARSTRATT( &keydata.char_code, 1, PageSize, 50, &attrib, 0 );
733: if ( !savefile(fhandle)) { /* if S, save file and quit */
734: freesegs();
735: VIOSETCURPOS( PageSize, 0, 0 );
736: quit(1);
737: }
738: else
739: error25(11); /* call error 11 if can't save */
740: }
741:
742: else if( (keydata.char_code == 'q') || (keydata.char_code == 'Q') ) {
743: VIOWRTCHARSTRATT( &keydata.char_code, 1, PageSize, 50, &attrib, 0 );
744: quit(1); /* if Q, quit with error */
745: break;
746: }
747:
748: else badkey(); /* otherwise wait for another key */
749:
750: }
751: break;
752:
753: case 8:
754: VIOWRTCHARSTRATT( message8, 51, PageSize, 0, &attrib, 0 );
755: quit(1);
756: break; /* 8 -> print message and quit */
757:
758: case 9:
759: VIOWRTCHARSTRATT( message9, 51, PageSize, 0, &attrib, 0 );
760: quit(1);
761: break; /* 9 -> print message and quit */
762:
763: case 10:
764: VIOWRTCHARSTRATT( message10, 51, PageSize, 0, &attrib, 0 );
765: quit(1);
766: break; /* 10 -> print message and quit */
767:
768: case 11:
769: VIOWRTCHARSTRATT( message11, 51, PageSize, 0, &attrib, 0 );
770: VIOSETCURPOS( PageSize, 45, 0 );
771:
772: while( 1 ) { /* 11 -> get a character from KBD */
773:
774: KBDCHARIN( &keydata, 0, 0 );
775:
776: if( (keydata.char_code == 'c') || (keydata.char_code == 'C') ) {
777: name25();
778: break; /* C means continue */
779: }
780: else badkey(); /* otherwise wait for another key */
781:
782: }
783: break;
784:
785: default:
786: VIOWRTCHARSTRATT( message99, 51, PageSize, 0, &attrib, 0 );
787: VIOSETCURPOS( PageSize, 40, 0 );
788:
789: while( 1 ) { /* UNKNOWN error number! */
790: /* get a character from KBD */
791: KBDCHARIN( &keydata, 0, 0 );
792:
793: if( (keydata.char_code == 'y') || (keydata.char_code == 'Y') ) {
794: name25();
795: break; /* if Y, go ahead */
796: }
797:
798: else if( (keydata.char_code == 'n') || (keydata.char_code == 'N') ) {
799: VIOWRTCHARSTRATT( &keydata.char_code, 1, PageSize, 50, &attrib, 0 );
800: quit(1); /* if N, quit with error */
801: break;
802: }
803:
804: else badkey(); /* otherwise wait for another key */
805:
806: }
807: break;
808:
809: }
810:
811: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.