home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / bts314b4 / stvfosil.c < prev    next >
C/C++ Source or Header  |  1994-01-08  |  9KB  |  473 lines
  1. /*
  2.  * stvfosil.c
  3.  *
  4.  * ST implementation of the Video Fossil functions
  5.  *
  6.  * (C) Copyright 1990,1991,1992 STeVeN W Green, All rights reserved
  7.  *     With Modifications from Roland Bohn (UseColor)
  8.  *
  9.  * To be used with BinkleyTerm.  Free Software Foundation licence
  10.  * agreements apply.
  11.  *
  12.  * BinkleyTerm only uses:
  13.  *   VioWrtTTY
  14.  *   VioWrtCellStr
  15.  *
  16.  * So I'm only going to implement those two!
  17.  *
  18.  * Refer to FSC-0021 for more details
  19.  */
  20.  
  21. #include <stdio.h>
  22. #ifdef __TOS__
  23. #include <ext.h>
  24. #else
  25. #include <osbind.h>
  26. #endif
  27. #include <ctype.h>
  28. #include <stdlib.h>
  29.  
  30. #include "bink.h"
  31. #include "com_st.h"
  32. #include "vfossil.h"
  33. #include "keybd.h"
  34.  
  35. #ifdef __TOS__
  36. #define ld_col_bg v_col_bg
  37. #define ld_col_fg v_col_fg
  38. #define ld_cel_mx v_cel_mx
  39. #define ld_cel_my v_cel_my
  40. #define ld_vplanes v_planes
  41. #else
  42. LA_DATA *linea_data;
  43. LA_EXT *linea_ext;
  44. #endif
  45.  
  46. static UBYTE old_conterm;
  47. #define CONTERM (*(UBYTE *)0x484)
  48.  
  49. static short old_back, old_fore;
  50.  
  51. static short oldcol0;
  52.  
  53. BOOLEAN nolinea = FALSE;        /* Set this to use VT52 codes */
  54. #ifdef BIOSDISPLAY
  55. BOOLEAN BIOSdisplay = FALSE;    /* Use BIOS for screen output */
  56. #endif
  57. BOOLEAN UseColors = FALSE;        /* Use fast monochrome output by default */
  58.  
  59.  
  60. /*
  61.  * Function for fiddling with system CONTERM variable
  62.  * so as to allow the shift bits through with Bconin()
  63.  */
  64.  
  65. static void set_conterm(void)
  66. {
  67.     old_conterm = CONTERM;
  68.     CONTERM |= 8;
  69. }
  70.  
  71. static void reset_conterm(void)
  72. {
  73.     CONTERM = old_conterm;
  74. }
  75.  
  76. /*
  77.  * Restore character colours before exitting, clearing screen, etc
  78.  */
  79.  
  80. static void default_colors(void)
  81. {
  82.     if(nolinea)
  83.         cprintf("\033b?\033c0");            /* Back=0, fore=15 */
  84.     else
  85.     {
  86.         linea_ext->ld_col_fg = old_fore;        /* Restore colors */
  87.         linea_ext->ld_col_bg = old_back;
  88.     }
  89. }
  90.  
  91. /*
  92.  * Initialise video Fossil routines
  93.  */
  94.  
  95. void vfossil_init(void)
  96. {
  97.     if(vfossil_installed)
  98.         return;
  99.  
  100.  
  101.     oldcol0 = Setcolor(0,-1)&0xfff;        /* Get color 0 for screen blanking */
  102.  
  103. #ifdef __TOS__
  104.     linea_init();
  105. #else
  106.     linea_data = linea0();
  107.     linea_ext = ((LA_EXT *)linea_data-1);
  108. #endif
  109.  
  110. #if 0
  111.     if(!nolinea)
  112.     {
  113. #endif
  114.         /* Filling these in may make it work on big monitors, etc */
  115.  
  116.         /*
  117.         ** Check if ROWS, COLS are defined then take size from this
  118.         ** variables
  119.         */
  120.         
  121.         if (getenv("BCOLS"))
  122.             SB_COLS = atoi(getenv("BCOLS"));
  123.         else
  124.             SB_COLS = linea_ext->ld_cel_mx + 1;    /* Number of text columns */
  125.             
  126.         if (getenv("BROWS"))
  127.             SB_ROWS = atoi(getenv("BROWS"));
  128.         else
  129.             SB_ROWS = linea_ext->ld_cel_my;        /* Number of text rows */
  130.             
  131.         /*
  132.         if(SB_COLS < 80)
  133.             SB_COLS = 80;
  134.         if(SB_ROWS < 23)
  135.             SB_ROWS = 23;
  136.         */
  137. #if 1
  138.     if(!nolinea)
  139.     {
  140. #endif
  141.         old_fore = linea_ext->ld_col_fg;        /* Get old colors */
  142.         old_back = linea_ext->ld_col_bg;
  143.     }
  144.  
  145.     cprintf("\033f");        /* Enable cursor */
  146.     vfossil_installed = 1;
  147.     Supexec((long(*)(void))set_conterm);
  148.  
  149.     /* Clear the Keyboard buffer */
  150.     
  151.     while(Cconis())
  152.         Crawcin();
  153.  
  154. }
  155.  
  156. void vfossil_close(void)
  157. {
  158.     if(!vfossil_installed)
  159.         return;
  160.  
  161.     default_colors();
  162.     Setcolor(0, oldcol0);
  163.  
  164.     Supexec((long(*)(void))reset_conterm);
  165.     cprintf("\033f");        /* Enable cursor */
  166.     vfossil_installed = 0;
  167.     
  168.     /* Clear the Keyboard buffer */
  169.     
  170.     while(Cconis())
  171.         Crawcin();
  172.  
  173. }
  174.  
  175. /* 
  176.  * Enable or disable cursor
  177.  */
  178.  
  179. void vfossil_cursor (int st)
  180. {
  181.     cputc('\033');
  182.     cputc( st ? 'e' : 'f' );
  183. }
  184.  
  185. /*
  186.  * ST specific key input, to return similar sort of codes to the PC
  187.  *
  188.  * i.e. if it is an ascii character then that is in low 8 bits
  189.  * otherwise a keyscan is in bits 8..15
  190.  */
  191.  
  192. int getkey(void)
  193. {
  194.     union {
  195.         long longkey;
  196.         struct {
  197.                 UBYTE shift;
  198.                 UBYTE scan;
  199.                 UBYTE fill;
  200.                 UBYTE ascii;
  201.         } kb;
  202.     } key;
  203.  
  204. #if 0
  205.     key.longkey = Bconin(2);
  206. #else
  207.     key.longkey = Crawcin();        /* See comment in com_st.h */
  208. #endif    
  209.  
  210.     /* Alt-Function keys */
  211.     
  212.     if( (key.kb.shift & 8) && (key.kb.scan >= 0x3b) && (key.kb.scan <= 0x44) )
  213.         return (int)(key.kb.scan + 45) << 8;
  214.  
  215.     /* Page Down = Shift Down arrow */
  216.     
  217.     if( (key.kb.shift & 3) && (key.kb.scan == 0x50) )
  218.         return 0x5100;
  219.     
  220.     /* Page up = Shift Up arrow */
  221.     
  222.     if( (key.kb.shift & 3) && (key.kb.scan == 0x48) )
  223.         return 0x4900;
  224.  
  225.     /*
  226.      * Process Alt/Ctrl-Keys... try to be keyboard independant by looking up the
  227.      * ascii value.
  228.      *
  229.      * Alt-Keys are only looked up if they don't have an ascii value, because
  230.      * on German keyboards some normal characters are accessed with Alt.
  231.      */
  232.  
  233.     if(!key.kb.ascii && (key.kb.shift & 8))
  234.     {
  235.         struct s_keytab {
  236.             char *unshift;
  237.             char *shift;
  238.             char *capslock;
  239.         } *bioskeys = (struct s_keytab *)Keytbl((char *)-1, (char *)-1, (char *)-1);
  240.  
  241.         if(key.kb.shift & 3)    /* Shift key */
  242.             key.kb.ascii = bioskeys->shift[key.kb.scan];
  243.         else
  244.             key.kb.ascii = bioskeys->unshift[key.kb.scan];
  245.  
  246.         if(key.kb.ascii)
  247.             return (int)key.kb.ascii + ALT_OFFSET;
  248.     }
  249.  
  250.     /* Control keys... add an offset to distinguish <Return> from Ctrl-M */
  251.  
  252.  
  253.     if(key.kb.ascii && (key.kb.shift & 4))        /* Control Key? */
  254.         return key.kb.ascii + CTRL_OFFSET;
  255.  
  256.  
  257.     /*
  258.      * Otherwise its just a plain ordinary key
  259.      */
  260.  
  261.     if(key.kb.ascii)
  262.         return (int)key.kb.ascii;
  263.     else
  264.         return (int)key.kb.scan << 8;
  265. }
  266.  
  267. #if 0    /* This is Stevens Routine */
  268.  
  269. /*
  270.  * Write a Cell string
  271.  *
  272.  * Note that the string is in Character/Attribute pairs
  273.  *
  274.  * Map the Attribute to Atari colours.  Of course this isnt going to
  275.  * work very well in mono is it!
  276.  */
  277.  
  278. void VioWrtCellStr(BYTEBUFP s, size_t len, int row, int column, int vhandle)
  279. {
  280.     char oldback = -1;
  281.     char oldfore = -1;
  282.  
  283. #if 0
  284.     if(nolinea)
  285.         oldback = oldfore = (char) -1;
  286. #endif
  287.  
  288.     /* Move cursor to col,row */
  289.     
  290.     cprintf("\033Y%c%c", (char)row+' ', (char)column+' ');
  291.  
  292.     /* Print message */
  293.  
  294.     len >>= 1;        /* length is actually byte length */
  295.     
  296.     while(len--)
  297.     {
  298.         char fore = (s->attr & 15);
  299.         char back = (s->attr >> 4) & 7;
  300.  
  301.         /*
  302.          * Send back/foreground colours... maybe ought to check for
  303.          * monitors and things tomake sure background and foreground
  304.          * are different.  Or maybe even ignore it completely!
  305.          */
  306.  
  307.  
  308.  
  309.         if(nolinea)
  310.         {
  311.             if(fore != oldfore)
  312.                 cprintf("\033b%c", (oldfore = fore) + '0');
  313.             if(back != oldback)
  314.                 cprintf("\033c%c", (oldback = back) + '0');
  315.         }
  316.         else
  317.         {
  318.             /* Set the colours quickly with linea variables */
  319.             /* Its possible that linea_data->text[fg|bg] should be used */
  320.  
  321.             linea_ext->ld_col_fg = fore;
  322.             linea_ext->ld_col_bg = back;
  323.         }
  324.  
  325.         if(BIOSdisplay)
  326.         {
  327.             if(s->ch)
  328.                 Bconout(5,s->ch);        /* Raw output */
  329.             else
  330.                 Bconout(5,' ');
  331.         }
  332.         else    /* GEMdos */
  333.         {
  334.             if(s->ch)
  335.                 Cconout(iscntrl(s->ch) ? ' ' : s->ch);
  336.             else
  337.                 Cconout(' ');
  338.         }            
  339.         s++;
  340.     }
  341. }
  342.  
  343. #else    /* And here are my changes [Roland Bohn] */
  344.  
  345. /*
  346.  * Write a Cell string
  347.  *
  348.  * Note that the string is in Character/Attribute pairs
  349.  *
  350.  * Map the Attribute to Atari colours.  Of course this isnt going to
  351.  * work very well in mono is it!
  352.  */
  353.  
  354. void VioWrtCellStr(BYTEBUFP s, size_t len, int row, int column, int vhandle)
  355. {
  356.     char c;
  357.     char oldback = -1;
  358.     char oldfore = -1;
  359.     char tmpstr[256];
  360.     char *ptr;
  361.     
  362. #if 0
  363.     if(nolinea)
  364.         oldback = oldfore = (char) -1;
  365. #endif
  366.     
  367.     /* Move cursor to col,row */
  368.     
  369.     if ( vhandle )
  370.     {
  371.     }
  372.  
  373.     Cconout(27);
  374.     Cconout('Y');
  375.     Cconout(row + ' ');
  376.     Cconout(column + ' ');
  377.     
  378.     /* Print message */
  379.     
  380.     len >>= 1;        /* length is actually byte length */
  381.     
  382.     *tmpstr = '\0';    /* Init the temporary string */
  383.     ptr = tmpstr;
  384.     
  385.     while(len--)
  386.     {
  387.         if (UseColors)        /* To write things faster, no colors */
  388.         {
  389.             char fore = (s->attr & 15);
  390.             char back = (s->attr >> 4) & 7;
  391.             
  392.             /* If color has changed then print the string at the old color */
  393.             
  394.             if(ptr > tmpstr && (fore != oldfore || back != oldback))
  395.             {
  396.                 *ptr = '\0';
  397.                 Cconws(tmpstr);
  398.                 *tmpstr = '\0';
  399.                 ptr = tmpstr;
  400.             }
  401.             
  402.             /*
  403.              * Send back/foreground colours... maybe ought to check for
  404.              * monitors and things to make sure background and foreground
  405.              * are different.  Or maybe even ignore it completely!
  406.              */
  407.             
  408.             if(nolinea)
  409.             {
  410.                 if(fore != oldfore)
  411.                 {
  412.                     Cconout(27);        /* Cconout is faster than cprintf */
  413.                     Cconout('b');
  414.                     Cconout(fore + '0');
  415.                 }
  416.                 if(back != oldback)
  417.                 {
  418.                     Cconout(27);
  419.                     Cconout('c');
  420.                     Cconout(back + '0');
  421.                 }
  422.             }
  423.             else
  424.             {
  425.                 /* Set the colours quickly with linea variables */
  426.                 /* Its possible that linea_data->text[fg|bg] should be used */
  427.                 
  428.                 linea_ext->ld_col_fg = fore;
  429.                 linea_ext->ld_col_bg = back;
  430.             }
  431.             
  432.             oldfore = fore;
  433.             oldback = back;
  434.         }
  435.         
  436.         c = s->ch;
  437.         if(c && !iscntrl(c))
  438.             *ptr++ = c;
  439.         else
  440.             *ptr++ = ' ';
  441.         
  442.         s++;            /* Next Character */
  443.     }
  444.     *ptr = '\0';        /* Make shure the String is null terminated */
  445.     
  446.     Cconws(tmpstr);        /* Print the String on the Screen */
  447. }
  448. #endif
  449.  
  450. void blank_screen(void)
  451. {
  452.     Setcolor(0,0);                    /* Color 0 = Black */
  453.     cprintf("\033c0\033E");            /* Clear screen to color 0 */
  454. }
  455.  
  456. void unblank_screen( void )
  457. {
  458.     Setcolor(0,oldcol0);
  459. }
  460.  
  461.  
  462. void screen_clear( void )
  463. {
  464.     default_colors();
  465.     cprintf("\033E");
  466. }
  467.  
  468. void clear_eol( void )
  469. {
  470.     default_colors();
  471.     cprintf("\033K");        /* Clear to end of line */
  472. }
  473.