home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / bts314b4 / conio.c < prev    next >
Text File  |  1990-06-14  |  13KB  |  407 lines
  1. /* CONIO.C
  2.    Source File for porting applications using character oriented
  3.    windows from TC on MSDOS to TC on Atari ST
  4.  
  5.    Copyright (c)  Heimsoeth & Borland  1988
  6.  
  7. */
  8.  
  9. #define __CONIO
  10.  
  11. #pragma warn -par /* Warnung bei unbenutztem Parameter ausschalten */
  12.  
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  16. #include <stdarg.h>
  17. #include <ctype.h>
  18. #include <vdi.h>
  19. #include <aes.h>
  20. #include <ext.h>
  21. #include <tos.h>
  22. #include "conio.h"
  23.  
  24. #define charxrast(x) ((x)*wchar) /* Zeichen -> x-Raster */
  25. #define charyrast(y) ((y)*hchar) /* Zeichen -> y-Raster */
  26. #define VT52(a) {putchar(0x1B); putchar(a);} /* Zeichen ausgeben */
  27. #define FALSE 0
  28. #define TRUE !FALSE
  29.  
  30. int directvideo = FALSE;
  31.  
  32. /**** Prototypes ****/
  33. int _cont(int, char **, char *);
  34. static void main(int, char **, char *), quit(void), failure(void);
  35. static int  appl_open(int *),   vwork_open(int);
  36. static void init(int *, int *), vwork_close(int);
  37. static void cwindcopy(int, int, int, int, int, int, int);
  38. static void right(void);
  39. static void mouseon(void), mouseoff(void), curxy(int, int);
  40. static int  wchar, hchar; /* Zeichen-Ausmaße */
  41.  
  42. static struct text_info textinfo;
  43.  
  44. /**** Initialisierung ****/
  45.  
  46. void main(int argc, char **argv, char *envp) /* Programm initialisieren */
  47. {       int rows, columns, gem_handle;
  48.         atexit(quit);
  49.         textinfo.app_handle = appl_open(&gem_handle);
  50.         textinfo.vdi_handle = vwork_open(gem_handle);
  51.         if(textinfo.vdi_handle >= 0)
  52.         {       init(&rows, &columns);
  53.                 winstyle(0, 0);
  54.                 textinfo.xmax = columns;
  55.                 textinfo.ymax = rows;
  56.                 textinfo.attribute = textinfo.normattr = 0;
  57.                 textinfo.currmode = MONO; /* ... */
  58.                 window(1,1,columns,rows);
  59.                 exit(_cont(argc, argv, envp));
  60.         }
  61.         failure();
  62. }
  63.  
  64. /**** Funktionen ****/
  65.  
  66. int movetext(int left, int top, int right, int bottom, int newleft, int newtop)
  67. {       if(left    < 1 || left    > textinfo.xmax ||
  68.            right   < 1 || right   > textinfo.xmax ||
  69.            newleft < 1 || newleft > textinfo.xmax ||
  70.            top     < 1 || top     > textinfo.ymax ||
  71.            bottom  < 1 || bottom  > textinfo.ymax ||
  72.            newtop  < 1 || newtop  > textinfo.ymax)
  73.                 return(FALSE);
  74.         cwindcopy(left, top, right, bottom, newleft, newtop, S_ONLY);
  75.         return(TRUE);
  76. }
  77.  
  78. int window(int left, int top, int right, int bottom)
  79. {       if(left   >= 1 && left   <= textinfo.xmax &&
  80.            top    >= 1 && top    <= textinfo.ymax &&
  81.            right  >= 1 && right  <= textinfo.xmax &&
  82.            bottom >= 1 && bottom <= textinfo.ymax)
  83.         {       textinfo.winleft  = left; textinfo.wintop     = top;
  84.                 textinfo.winright = right; textinfo.winbottom = bottom;
  85.                 textinfo.screenwidth  = right - left;
  86.                 textinfo.screenheight = bottom - top;
  87.                 curhome();
  88.                 return(TRUE);
  89.         }
  90.         return(FALSE);
  91. }
  92.  
  93. void clrscr(void) /* Fenster löschen */
  94. {       cwindfill(textinfo.winleft, textinfo.wintop, textinfo.winright,
  95.                   textinfo.winbottom);
  96.         curhome();
  97. }
  98.  
  99. void clreol(void) /* Bis Zeilenende löschen */
  100. {       cwindfill(textinfo.winleft+textinfo.curx, textinfo.wintop+textinfo.cury,
  101.                   textinfo.winright, textinfo.wintop+textinfo.cury);
  102. }
  103.  
  104. void insline(void) /* Zeile einfügen */
  105. {       cwindcopy(textinfo.winleft, textinfo.wintop+textinfo.cury,
  106.                   textinfo.winright, textinfo.winbottom-1, textinfo.winleft,
  107.                   textinfo.wintop+textinfo.cury+1, S_ONLY);
  108.         cwindfill(textinfo.winleft, textinfo.wintop+textinfo.cury,
  109.                   textinfo.winright, textinfo.wintop+textinfo.cury);
  110. }
  111.  
  112. void delline(void) /* Aktuelle Zeile löschen */
  113. {       cwindcopy(textinfo.winleft, textinfo.wintop+textinfo.cury,
  114.                   textinfo.winright, textinfo.winbottom, textinfo.winleft,
  115.                   textinfo.wintop+textinfo.cury-1, S_ONLY);
  116.         cwindfill(textinfo.winleft, textinfo.wintop+textinfo.screenheight,
  117.                   textinfo.winright, textinfo.wintop+textinfo.screenheight);
  118. }
  119.  
  120. int cprintf(const char *format, ...) /* printf(...) */
  121. {       va_list arg_ptr;
  122.         char s[81];
  123.         va_start(arg_ptr, format);
  124.         vsprintf(s, format, arg_ptr);
  125.         va_end(arg_ptr);
  126.         return(couts(s));
  127. }
  128.  
  129. int cputs(const char *string) /* puts(...) */
  130. {       couts(string);
  131.         newline();
  132.         return('\n');
  133. }
  134.  
  135. int couts(const char *string) /* String ausgeben */
  136. {       const char *s;
  137.         if(directvideo)
  138.                 return(Cconws((char *) string));
  139.         curoff();
  140.         s = string;
  141.         while(putch(*s++))
  142.                  ;
  143.         curon();
  144.         return((int) (s - string - 1)); /* Anzahl der ausgegebenen Zeichen */
  145. }
  146.  
  147. int putch(int c) /* putchar(...) */
  148. {       int x;
  149.         if(!isprint(c) && !directvideo)
  150.         {       switch(c)
  151.                 {       case '\n': /* CRLF */
  152.                                 newline();
  153.                                 break;
  154.                         case '\r': /* CR */
  155.                                 textinfo.curx = 1;
  156.                                 curxy(textinfo.curx, textinfo.cury);
  157.                                 break;
  158.                         case '\a': /* Bell */
  159.                                 putchar('\a');
  160.                                 break;
  161.                         case '\b': /* Backspace */
  162.                                 putch(' '); curleft();
  163.                                 curleft(); putch(' ');
  164.                                 curleft();
  165.                                 break;
  166.                         case '\t': /* Tabulator */
  167.                                 x = (textinfo.curx / 8 + 1) * 8;
  168.                                 gotoxy(x, textinfo.cury);
  169.                                 break;
  170.                 }
  171.         }
  172.         else
  173.         {       Cconout(c);
  174.                 right();
  175.         }
  176.         return(c);
  177. }
  178.  
  179. int getche(void) /* getchar(...) */
  180. {       int c;
  181.         c = getch();
  182.         putch(c);
  183.         return(c);
  184. }
  185.  
  186. void gettextinfo(struct text_info *inforec) /* Textinfo-Struktur kopieren (!) */
  187. {       memcpy(inforec, &textinfo, sizeof(textinfo));
  188. }
  189.  
  190. int wherex(void) /* Cursor-Spalte zurückgeben */
  191. {       return(textinfo.curx);
  192. }
  193.  
  194. int wherey(void) /* Cursor-Zeile zurückgeben */
  195. {       return(textinfo.cury);
  196. }
  197.  
  198. int gettext(int left, int top, int right, int bottom, void *destin)
  199. {       return(FALSE); /* Wird nicht unterstützt */
  200. }
  201.  
  202. int puttext(int left, int top, int right, int bottom, void *source)
  203. {       return(FALSE); /* wird nicht unterstützt */
  204. }
  205.  
  206. int winstyle(int style, int frame) /* Fensterhintergrund setzen */
  207. {       textinfo.winstyle = style;
  208.         vsf_perimeter(textinfo.vdi_handle, frame);
  209.         return(vsf_interior(textinfo.vdi_handle, style));
  210. }
  211.  
  212. /**** Nur aus Kompatibilitätsgründen vorhanden ****/
  213.  
  214. void highvideo(void)    {};
  215. void normvideo(void)    {};
  216. void lowvideo(void)             {};
  217. void textattr(int attribute)            {};
  218. void textcolor(int color)       {};
  219. void textbackground(int color)          {};
  220.  
  221. void textmode(int mode)
  222. {       int xmax;
  223.         if(mode == LAST)
  224.                 return;
  225.         if(mode == BW40 || mode == C40)
  226.                 xmax = 40;
  227.         else
  228.                 xmax = 80;
  229.         textinfo.xmax = xmax;
  230.         window(1,1,textinfo.xmax,textinfo.ymax);
  231.         textinfo.currmode = mode;
  232.         normvideo();
  233. };
  234.  
  235.  
  236. /**** Cursor bewegen ****/
  237.  
  238. void curleft(void) /* Cursor links */
  239. {       if(textinfo.curx > 1) /* Linker Rand erreicht? */
  240.                 textinfo.curx--; /* Nein, dann links */
  241.         else if(textinfo.cury > 1) /* Ja: Erste Zeile? */
  242.         {       textinfo.curx = textinfo.screenwidth+1; /* Nein: rauf */
  243.                 textinfo.cury--;
  244.         }
  245.         curxy(textinfo.curx, textinfo.cury);
  246. }
  247.  
  248. void curright(void) /* Cursor rechts */
  249. {       if(textinfo.curx <= textinfo.screenwidth) /* Rechter Rand erreicht? */
  250.                 textinfo.curx++; /* Nein, dann rechts */
  251.         else if(textinfo.cury <= textinfo.screenheight) /* Ja: Letzte Zeile? */
  252.         {       textinfo.curx = 1; /* Nein: runter */
  253.                 textinfo.cury++;
  254.         }
  255.         curxy(textinfo.curx, textinfo.cury);
  256. }
  257.  
  258. void curup(void) /* Cursor rauf */
  259. {       if(textinfo.cury > 1) /* Erste Zeile? */
  260.                 curxy(textinfo.curx, --textinfo.cury); /* Nein: rauf */
  261. }
  262.  
  263. void curdown(void) /* Cursor runter */
  264. {       if(textinfo.cury <= textinfo.screenheight) /* Letzte Zeile? */
  265.                 curxy(textinfo.curx, ++textinfo.cury); /* Nein: runter */
  266. }
  267.  
  268. void curhome(void) /* Cursor home */
  269. {       textinfo.curx = textinfo.cury = 1;
  270.         curxy(textinfo.curx, textinfo.cury);
  271. }
  272.  
  273. void newline(void) /* Cursor CRLF */
  274. {       if(textinfo.cury <= textinfo.screenheight) /* Letzte Zeile? */
  275.                 textinfo.cury++; /* Nein: CRLF */
  276.         textinfo.curx = 1;
  277.         curxy(textinfo.curx, textinfo.cury);
  278. }
  279.  
  280. void gotoxy(int x, int y) /* Cursor positionieren */
  281. {       if(x >= 1 && x <= textinfo.screenwidth+1 &&
  282.            y >= 1 && y <= textinfo.screenheight+1)
  283.                 textinfo.curx = x; textinfo.cury = y;
  284.         curxy(textinfo.curx, textinfo.cury);
  285. }
  286.  
  287. /**** Allgemeine Funktionen ****/
  288.  
  289. static void curon(void) /* Cursor einschalten */
  290. {       VT52('e');
  291. }
  292.  
  293. static void curoff(void) /* Cursor ausschalten */
  294. {       VT52('f');
  295. }
  296.  
  297. void revon(void) /* Revers einschalten */
  298. {       v_rvon(textinfo.vdi_handle);
  299. }
  300.  
  301. void revoff(void) /* Revers ausschalten */
  302. {       v_rvoff(textinfo.vdi_handle);
  303. }
  304.  
  305. /**** Interne Funktionen ****/
  306.  
  307. static int appl_open(int *gem_hndl) /* Application anmelden */
  308. {       int q, app_hndl = appl_init();
  309.         *gem_hndl = graf_handle(&wchar, &hchar, &q, &q);
  310.         return(app_hndl);
  311. }
  312.  
  313. static int vwork_open(int gem_hndl) /* Virtuelle Workstation öffnen */
  314. {       int i, vdi_hndl;
  315.         int work_in[11];
  316.         for(i = 1; i < 10; work_in[i++] = 1)
  317.                 ;
  318.         work_in[ 0] = Getrez() + 2;
  319.         work_in[10] = 2; /* Raster-Koordinaten */
  320.         vdi_hndl = gem_hndl;
  321.         v_opnvwk(work_in, &vdi_hndl, _GemParBlk.intout);
  322.         return(vdi_hndl); /* Virtual Workstation Handle */
  323. }
  324.  
  325. static void init(int *rows, int *columns)
  326. {       mouseoff();
  327.         v_enter_cur(textinfo.vdi_handle);
  328.         vq_chcells(textinfo.vdi_handle, rows, columns);
  329. }
  330.  
  331. static void quit(void) /* Quit Program */
  332. {       v_exit_cur(textinfo.vdi_handle);
  333.         mouseon();
  334.         vwork_close(textinfo.vdi_handle);
  335.         appl_exit();
  336. }
  337.  
  338. static void vwork_close(vdi_hndl) /* Virtuelle Arbeitsstation schließen */
  339. {       v_clsvwk(vdi_hndl);
  340. }
  341.  
  342. static void failure(void) /* Fatal Error */
  343. {       fprintf(stdout, "CONIO: Fatal Error: Cannot install CharacterWindows.");
  344.         fprintf(stdout, "CONIO: Shutting down....");
  345.         abort();
  346. }
  347.  
  348. static void mouseon(void) /* Maus einschalten */
  349. {       v_show_c(textinfo.vdi_handle, 0);
  350. }
  351.  
  352. static void mouseoff(void) /* Maus ausschalten */
  353. {       v_hide_c(textinfo.vdi_handle);
  354. }
  355.  
  356. static void curxy(int x, int y) /* Cursor positionieren */
  357. {       vs_curaddress(textinfo.vdi_handle, textinfo.wintop+y-1, textinfo.winleft+x-1);
  358. }
  359.  
  360. static void right(void) /* Cursor schnell rechts */
  361. {       if(textinfo.curx <= textinfo.screenwidth) /* Rechter Rand erreicht? */
  362.         {       textinfo.curx++; /* Nein, dann rechts */
  363.                 return;
  364.         }
  365.         if(textinfo.cury <= textinfo.screenheight) /* Ja: Letzte Zeile? */
  366.         {       textinfo.curx = 1; /* Nein: runter */
  367.                 textinfo.cury++;
  368.                 curxy(textinfo.curx, textinfo.cury);
  369.         }
  370.         else
  371.                 curxy(textinfo.curx, textinfo.cury);
  372. }
  373.  
  374. static void /* Bildschirmausschnitt kopieren */
  375. cwindcopy(int sx1, int sy1, int sx2, int sy2, int dx1, int dy1, int mode)
  376. {       MFDB fdb = { 0L }; /* Wird vom VDI initialisiert */
  377.         int p[8];
  378.         p[0] = charxrast(sx1-1); p[1] = charyrast(sy1-1);
  379.         p[2] = charxrast(sx2)-1; p[3] = charyrast(sy2)-1;
  380.         p[4] = charxrast(dx1-1); p[5] = charyrast(dy1-1);
  381.         p[6] = charxrast(dx1+sx2-sx1)-1;
  382.         p[7] = charyrast(dy1+sy2-sy1)-1;
  383.         curoff();
  384.         vro_cpyfm(textinfo.vdi_handle, mode, p, &fdb, &fdb);
  385.         curon();
  386. }
  387.  
  388. void /* Fensterhintergrund */
  389. cwindfill(int x1, int y1, int x2, int y2)
  390. {       int p[4];
  391.         p[0] = charxrast(x1-1)-1; p[1] = charyrast(y2);
  392.         p[2] = charxrast(x2); p[3] = charyrast(y1-1)-1;
  393.         if(p[0] < 0)
  394.                p[0] = 0;
  395.         if(p[1] >= charyrast(textinfo.ymax))
  396.                p[1] = charyrast(textinfo.ymax);
  397.         if(p[2] >= charxrast(textinfo.xmax))
  398.                p[2] = charxrast(textinfo.xmax);
  399.         if(p[3] < 0)
  400.                p[3] = 0;
  401.         curoff();
  402.         v_bar(textinfo.vdi_handle, p);
  403.         curon();
  404. }
  405.  
  406. #pragma warn .par
  407. ə