home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / itf_src / atari_io.c next >
C/C++ Source or Header  |  1993-09-20  |  7KB  |  383 lines
  1. #ifdef SOZOBON
  2. #ifdef VT52
  3.  
  4. /* Private variables. */
  5.  
  6. int first_line ;    /* First line used for normal text (not statusline). */
  7. int last_line ;     /* Last line used for normal text. */
  8. int cursor_x ;        /* Current row (line) of cursor. */
  9. int cursor_y ;        /* Current column of cursor. */
  10.  
  11. boolean reverse_text = FALSE ;    /* Currently reverse text is off. */
  12.  
  13. #define ESC     (char) 27
  14.  
  15. /*
  16. **    I/O routines for Atari ST, using VT52 codes.
  17. */
  18.  
  19. Void
  20. vt52_init_io ()
  21. {
  22.     extern int        screen_height ;
  23.     extern int        screen_width ;
  24.     extern int        top_screen_line ;
  25.     extern boolean    enhanced ;
  26.  
  27.     int     i;
  28.  
  29.     /*
  30.     **    Initialization.
  31.     */
  32.  
  33.     enhanced = TRUE;    /* Meaning: This is not just a dumb terminal (no auto-
  34.                          * matic echo, <return> can be '\r' not '\n', windowing
  35.                          * is possible).
  36.                          */
  37.  
  38.     default_attrs () ;
  39.     read_rcfile () ;
  40.  
  41.     putchar(ESC); putchar('w');         /* Wrap off. */
  42.     putchar(ESC); putchar('f');         /* Cursor off. */
  43.     putchar(ESC); putchar('E');         /* Clear screen. */
  44.     /* Write a black line (status line) at the top of the screen. */
  45.     GOTO_XY(0,0);
  46.     putchar(ESC); putchar('p');         /* Reverse on. */
  47.     for (i = 0; i < screen_width; i++)
  48.         putchar(' ');
  49.     putchar(ESC); putchar('q');         /* Reverse off. */
  50.  
  51.     first_line = top_screen_line ;
  52.     last_line = screen_height - 1 ;     /* Numbering begins with 0. */
  53.     GOTO_XY ( 0, last_line ) ;
  54. }
  55.  
  56. Void
  57. vt52_exit_io ()
  58. {
  59.     extern boolean    page_out ;
  60.  
  61.     /*
  62.     **    Clean up.
  63.     */
  64.  
  65.     GOTO_XY ( 0, last_line ) ;
  66.     putchar(ESC); putchar('v');     /* Wrap on. */
  67.     putchar(ESC); putchar('e');     /* Cursor on. */
  68.     /* If inverse text is on turn it off. */
  69.     if (reverse_text)
  70.     {
  71.         putchar(ESC); putchar('q');
  72.         reverse_text = TRUE;
  73.     }
  74.  
  75.     if ( !page_out )
  76.     {
  77.         /* Output is formatted with [MORE] after each full page. This shows
  78.          * that the game is run interactively (not with input from a file).
  79.          * It is definitely the possibility that the game is run from the
  80.          * desktop, so many users will be happy that the game waits until
  81.          * it exits.
  82.          */
  83.         printf( "(Press any key to exit)" );
  84.         getch();
  85.         printf( "\n" );
  86.     }
  87. }
  88.  
  89. Void
  90. vt52_putchar ( c )
  91. char    c ;
  92. {
  93.     extern boolean    enable_screen ;
  94.  
  95.     switch ( c )
  96.     {
  97.         case 1:
  98.             /*
  99.             **    Set Normal Text Mode.
  100.             */
  101.  
  102.             /* If inverse text is on turn it off. */
  103.             if (reverse_text)
  104.             {
  105.                 putchar(ESC); putchar('q');
  106.                 reverse_text = TRUE;
  107.             }
  108.             break;
  109.  
  110.         case 2:
  111.             /*
  112.             **    Set Inverse Text Mode.
  113.             */
  114.  
  115.             putchar(ESC); putchar('p');
  116.             reverse_text = TRUE;
  117.             break;
  118.  
  119.         case 3:
  120.             /*
  121.             **    Set Bold Text Mode.
  122.             */
  123.  
  124.             /* Unfortunately, I don't know how... */
  125.             break;
  126.  
  127.         case 4:
  128.             /*
  129.             **    Unused.
  130.             */
  131.  
  132.             break;
  133.  
  134.         case 5:
  135.             /*
  136.             **    Set Underline Text Mode.
  137.             */
  138.  
  139.             /* Unfortunately, I don't know how... */
  140.             break;
  141.  
  142.         case '\n':
  143.             /*
  144.             **    Newline.
  145.             */
  146.  
  147.             if ( !enable_screen )
  148.                 break;
  149.  
  150.             /* If current line is the last used, scroll text but not
  151.                status line.
  152.             */
  153.             if (cursor_y == last_line)
  154.             {
  155.                 GOTO_XY(0, first_line);
  156.                 putchar(ESC); putchar('M');     /* Delete line. */
  157.                 GOTO_XY(0, last_line);
  158.                 putchar(ESC); putchar('L');     /* Insert line. */
  159.             }
  160.             else
  161.             {
  162.                 putchar(c);
  163.                 cursor_y++ ;
  164.                 cursor_x = 0;
  165.             }
  166.             break;
  167.  
  168.         case '\b':
  169.             /*
  170.             **    Backspace
  171.             */
  172.  
  173.             if ( enable_screen && (cursor_x > 0) )
  174.             {
  175.                 /* Go back, delete the letter, and go back again. */
  176.                 printf("\b \b");
  177.                 cursor_x-- ;
  178.             }
  179.             break;
  180.  
  181.         case '\t':
  182.             /*
  183.             **    Tab
  184.             */
  185.  
  186.             if ( enable_screen )
  187.             {
  188.                 int     n;
  189.                 int     i;
  190.  
  191.                 n = 8 - (GET_X() % 8);
  192.                 for ( i = 0 ; i < n ; i++ )
  193.                     putchar(' ');
  194.                 cursor_x = cursor_x + n;
  195.             }
  196.             break;
  197.  
  198.         case 0:
  199.             c = ' ';
  200.  
  201.             /*
  202.             **    Fall through ...
  203.             */
  204.  
  205.         default:
  206.             if ( enable_screen )
  207.             {
  208.                 putchar ( c ) ;
  209.                 cursor_x++ ;
  210.             }
  211.             break;
  212.     }
  213. }
  214.  
  215. Void
  216. vt52_goto_xy ( x,y )
  217. int     x,y ;
  218. {
  219.     /*
  220.     **    Move the cursor to (x,y) ...
  221.     **    The top-left corner of the screen has coordinates (0,0).
  222.     */
  223.  
  224.     putchar(ESC);
  225.     putchar('Y');
  226.     putchar( (char)(y+32) );
  227.     putchar( (char)(x+32) );
  228.     cursor_x = x;
  229.     cursor_y = y;
  230. }
  231.  
  232. int
  233. vt52_get_x ()
  234. {
  235.     /*
  236.     **    The left-most character position is position 0.
  237.     */
  238.  
  239.     return (cursor_x);
  240. }
  241.  
  242. int
  243. vt52_get_y ()
  244. {
  245.     /*
  246.     **    The top screen line is 0.
  247.     */
  248.  
  249.     return (cursor_y);
  250. }
  251.  
  252. /*
  253. **    The Enhanced Windowing I/O Functions.
  254. */
  255.  
  256. Void
  257. vt52_use_window ( the_window )
  258. word    the_window;
  259. {
  260.     extern int    screen_height;
  261.     extern int    window_height;
  262.     extern int    top_screen_line;
  263.  
  264.     /* There is no description of the variable 'window_height', but it
  265.     ** it seems that 'top_screen_line + window_height' gives the first
  266.     ** line of the lower window. The upper window must then be from
  267.     ** 'top_screen_line' to 'top_screen_line + window_height - 1'.
  268.     */
  269.  
  270.     switch ( the_window )
  271.     {
  272.         case WINDOW_0:
  273.             /*
  274.             **    Use the Lower Window ...
  275.             */
  276.  
  277.             first_line = top_screen_line + window_height;
  278.             last_line = screen_height - 1;
  279.  
  280.             break;
  281.         case WINDOW_1:
  282.             /*
  283.             **    Use the Upper Window ...
  284.             */
  285.  
  286.             first_line = top_screen_line;
  287.             last_line = top_screen_line + window_height - 1;
  288.  
  289.             break;
  290.         case FULL_SCREEN:
  291.             /*
  292.             **    Use the entire screen ...
  293.             */
  294.  
  295.             first_line = top_screen_line;
  296.             last_line = screen_height - 1;
  297.  
  298.             break;
  299.     }
  300. }
  301.  
  302. Void
  303. vt52_erase_window ( top_of_window, bottom_of_window )
  304. word    top_of_window;
  305. word    bottom_of_window;
  306. {
  307.     /*
  308.     **    Erase screen from the line specified by "top_of_window"
  309.     **    to the line ABOVE that specified by "bottom_of_window".
  310.     **    Leave cursor at the top, left-hand corner of the erased window.
  311.     **    The top screen line is line 0.
  312.     */
  313.  
  314.     word    i;
  315.  
  316.     for ( i = bottom_of_window ; i > top_of_window ; i-- )
  317.     {
  318.         GOTO_XY (0, i-1);
  319.         putchar(ESC); putchar('l');     /* Clear line. */
  320.     }
  321.     GOTO_XY (0, top_of_window);
  322. }
  323.  
  324. /*
  325. **    The Plus Series I/O Functions.
  326. */
  327.  
  328. Void
  329. vt52_erase_to_eoln ()
  330. {
  331.     /*
  332.     **    The characters at the cursor and to the right are erased.
  333.     **    The cursor itself is not moved.
  334.     */
  335.  
  336.     putchar(ESC); putchar('K');     /* Clear to EOL. */
  337. }
  338.  
  339. int
  340. vt52_kbd_hit ()
  341. {
  342.     return ( kbhit() );
  343. }
  344.  
  345. int
  346. vt52_get_ch ()
  347. {
  348.     int c;
  349.  
  350.     putchar(ESC); putchar('e');         /* Cursor on. */
  351.     c = getch();
  352.     putchar(ESC); putchar('f');         /* Cursor off. */
  353.  
  354.     /* Conversion of special characters as suggested in read_the_key() */
  355.     switch( c )
  356.     {
  357.         case 127:
  358.             c = '\b';        /* Delete  ->  backspace */
  359.             break;
  360.         case 200:
  361.             c = 0x08;        /* Up-arrow  ->  tab */
  362.             break;
  363.         case 203:
  364.             c = '\b';        /* Left-arrow  ->  backspace */
  365.             break;
  366.         case 205:
  367.             c = 0x07;        /* Right-arrow    ->    bell */
  368.             break;
  369.         case 208:
  370.             c = '\r';        /* Down-arrow  ->  return */
  371.             break;
  372.         default:
  373.             /* No change. */
  374.             break;
  375.     }
  376.  
  377.     return ( c );
  378. }
  379.  
  380. #endif VT52
  381. #endif SOZOBON
  382.  
  383.