home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / dos_txl / source / windows.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-18  |  10.3 KB  |  478 lines
  1. /* WINDOWS.C */
  2. /* (c) 1991 Elmar Warken */
  3.  
  4. #include <stdlib.h>
  5. #include <dos.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <conio.h>
  9. #include "interp.h"
  10. #include "macros.c"
  11. #include "windows.h"
  12.  
  13. /* Benötigte Globalvariablen */
  14. extern    PRGZEILE    *FirstLine;        /* erste Interpreterzeile */
  15. extern    PRGZEILE    *ActLine;        /* aktuelle interpretierte Zeile */
  16. extern    char        *LinePos;        /* Zeilenposition der aktuellen Zeile*/
  17. extern    int        Steuer;                /* der aufrufenden Routine wird mit-    */
  18. extern    TOKBEF        TokBefDesc[];
  19.                                     /* geteilt, um was es sich handelt.         */
  20. extern    char    ScanBuffer[ZEILENLAENGE]; /* Ergebnisbuffer des Scanners */
  21.  
  22. struct windowdata *FirstWindow;
  23. int WindowCounter;
  24.  
  25. char far *SCRSEG=(char far*)0xB8000000;
  26.  
  27. /*** Von Makros verwendeter Zeiger in den Bildschirmspeicher ***/
  28. char far *SCRPTR;
  29.  
  30. void InitWindowSystem()
  31. {
  32.   FirstWindow=NULL;
  33.   WindowCounter=0;
  34. }
  35.  
  36. char *SaveBGround(int x1,int y1,int x2,int y2)
  37. {
  38.   char *Save,*SavePos;
  39.   int i,breite=x2-x1+1;
  40.   unsigned scr;
  41.  
  42.   SavePos=Save=malloc( breite*(y2-y1+1)*2 );
  43.   if (!SavePos)
  44.   {  
  45.     perror(" Speicherplatz voll. "); abort();
  46.   }
  47.  
  48.   scr=(y1-1)*160+(x1-1)*2;
  49.   for (i=y1; i<=y2; i++, SavePos+=breite*2, scr+=160) 
  50.     movedata(0xB800, scr, FP_SEG(SavePos), FP_OFF(SavePos), (x2-x1+1)*2 );
  51.   return(Save);
  52. }
  53.  
  54. void RestoreBGround(int x1,int y1,int x2,int y2, char *BG)
  55. {
  56.   char *SavePos;
  57.   int i,breite=x2-x1+1;
  58.   unsigned scr;
  59.  
  60.   SavePos=BG;
  61.  
  62.   scr=(y1-1)*160+(x1-1)*2;
  63.   for (i=y1; i<=y2; i++, SavePos+=breite*2, scr+=160) 
  64.     movedata( FP_SEG(SavePos),FP_OFF(SavePos), 0xB800, scr, (x2-x1+1)*2 );
  65. }
  66.  
  67. void WriteFirstWin(int x, int y,char a, char *string)
  68. {
  69.   if (FirstWindow==NULL) return;
  70.   SET_POS(FirstWindow->x1+x-1,FirstWindow->y1+y-1);
  71.   WR_STR(string,a);
  72. } 
  73.  
  74. void ClearFirstWin()
  75. {
  76.   int i;
  77.  
  78.   for (i=FirstWindow->y1; i<=FirstWindow->y2; i++)
  79.   { 
  80.     SET_POS(FirstWindow->x1,i); 
  81.     CLEAR_LINE(FirstWindow->Breite,FirstWindow->BackCol);   
  82.   }
  83. }
  84.  
  85. void FrameFirstWin()
  86. {
  87.   UChar col,i;
  88.  
  89.   col=FirstWindow->FrameCol;
  90.  
  91.   SET_POS(FirstWindow->x1,FirstWindow->y1);  WR_SCR('╔',col);
  92.   for (i=1; i<=FirstWindow->Breite-2;i++) WR_SCR('═',col);
  93.   WR_SCR('╗',col);
  94.  
  95.   SET_POS(FirstWindow->x1,FirstWindow->y2);  WR_SCR('╚',col);
  96.   for (i=1; i<=FirstWindow->Breite-2;i++) WR_SCR('═',col);
  97.   WR_SCR('╝',col);
  98.  
  99.   for (i=1; i<=FirstWindow->Hoehe-2; i++)
  100.   {
  101.     SET_POS(FirstWindow->x1,FirstWindow->y1+i); WR_SCR('║',col); /*** OPT! **/
  102.     SET_POS(FirstWindow->x2,FirstWindow->y1+i); WR_SCR('║',col);
  103.   }
  104. }
  105.  
  106. void TopBottomFirstWin(char *top,char *bottom)
  107. {
  108.   FirstWindow->TopL=top;
  109.   FirstWindow->BottomL=bottom;
  110.  
  111.   SET_POS(FirstWindow->x1+2,FirstWindow->y1);
  112.   WR_STR(top,FirstWindow->TopCol);
  113.   SET_POS(FirstWindow->x1+2,FirstWindow->y2);
  114.   WR_STR(bottom,FirstWindow->BottomCol);
  115. }
  116.  
  117. int OpenWindow(char nx1,char ny1,char nx2,char ny2,
  118.            UChar c1,UChar c2,UChar c3,UChar c4)
  119. {
  120.   struct windowdata *Win;
  121.  
  122.   MAX(nx2,80);  /** Bereichsüberprüfung und eventuelle Korrektur **/
  123.   MIN(nx2,1);
  124.   MAX(nx1,nx2);
  125.   MIN(nx1,1);
  126.   MAX(ny2,25);   MIN(ny2,1);
  127.   MAX(ny1,ny2);  MIN(ny1,1);
  128.  
  129.   Win=malloc(sizeof(*Win));
  130.   Win->handle=++WindowCounter;
  131.   Win->x1=nx1; Win->x2=nx2; Win->y1=ny1; Win->y2=ny2;
  132.   Win->FrameCol=c1; Win->BackCol=c2; Win->TopCol=c3; Win->BottomCol=c4;
  133.   Win->BottomL=Win->TopL=NULL; Win->FrameType=1;
  134.   Win->BackGround=SaveBGround(nx1,ny1,nx2,ny2);
  135.   Win->NextWindow=FirstWindow;
  136.   Win->Breite=nx2-nx1+1;
  137.   Win->Hoehe=ny2-ny1+1;
  138.   Win->HelpSave=NULL;
  139.   FirstWindow=Win;
  140.  
  141.   ClearFirstWin();
  142.   FrameFirstWin();
  143.   return(WindowCounter);
  144. }
  145.  
  146. void CloseFirstWindow()
  147. {
  148.   struct windowdata *Win;
  149.  
  150.   if (!WindowCounter) return;
  151.  
  152.   Win=FirstWindow;
  153.   RestoreBGround(Win->x1,Win->y1,Win->x2,Win->y2,Win->BackGround);
  154.   free(Win->BackGround);
  155.   FirstWindow=FirstWindow->NextWindow;
  156.   WindowCounter--;
  157.  
  158.   free(Win);
  159. }
  160.  
  161. void HideWindow(struct windowdata *Win)
  162. {
  163.   Win->HelpSave=SaveBGround(Win->x1,Win->y1,Win->x2,Win->y2);
  164.   RestoreBGround(Win->x1,Win->y1,Win->x2,Win->y2,Win->BackGround);
  165.   free(Win->BackGround);
  166. }
  167.  
  168. void ShowHiddenWindow(struct windowdata *Win)
  169. {
  170.   if (Win->HelpSave) /*** nur möglich, wenn HideFirstWindow */
  171.              /*** aufgerufen wurde ***/
  172.   {
  173.     Win->BackGround=SaveBGround(Win->x1,Win->y1,Win->x2,Win->y2);
  174.     RestoreBGround(Win->x1,Win->y1,Win->x2,Win->y2,Win->HelpSave);
  175.     free(Win->HelpSave);
  176.     Win->HelpSave=NULL;
  177.   }
  178. }
  179.  
  180. void NewKoorWindow(char nx1,char ny1,char nx2,char ny2)
  181. {
  182.   HideWindow(FirstWindow);
  183.  
  184.   MAX(nx2,80);  /** Bereichsüberprüfung und eventuelle Korrektur **/
  185.   MIN(nx2,1);
  186.   MAX(nx1,nx2);  MIN(nx1,1);
  187.   MAX(ny2,25);   MIN(ny2,1);
  188.   MAX(ny1,ny2);  MIN(ny1,1);
  189.  
  190.   FirstWindow->x1=nx1;
  191.   FirstWindow->y1=ny1;
  192.   FirstWindow->x2=nx2;
  193.   FirstWindow->y2=ny2;
  194.   FirstWindow->Breite=nx2-nx1+1;
  195.   FirstWindow->Hoehe=ny2-ny1+1;
  196.  
  197.   FirstWindow->BackGround=
  198.     SaveBGround(FirstWindow->x1,FirstWindow->y1,
  199.         FirstWindow->x2,FirstWindow->y2);
  200.  
  201.   free(FirstWindow->HelpSave);
  202.   FirstWindow->HelpSave=NULL;
  203.   ClearFirstWin();
  204.   FrameFirstWin();
  205. }
  206.  
  207. void ResizeWindow(int relx,int rely)
  208. {
  209.   NewKoorWindow(FirstWindow->x1,FirstWindow->y1,
  210.         FirstWindow->x2+relx,FirstWindow->y2+rely);
  211. }
  212.  
  213. void MoveWindow(int relx,int rely)
  214. {
  215.   NewKoorWindow(FirstWindow->x1+relx,FirstWindow->y1+rely,
  216.         FirstWindow->x2+relx,FirstWindow->y2+rely);
  217. }
  218.  
  219. struct windowdata *GetFirstWindow
  220.      (int number, struct windowdata *Win, struct windowdata *Prev)
  221.  
  222. /**** nur als Hilfsprozedur für NewfirstWindow ****/
  223.  
  224. {
  225.   struct windowdata *ret;
  226.  
  227.   if ((Win->handle != number) && Win->NextWindow)
  228.   {
  229.     HideWindow(Win);
  230.     ret=GetFirstWindow(number,Win->NextWindow,Win);
  231.     ShowHiddenWindow(Win);
  232.     return(ret);
  233.   }
  234.   else if (Win->handle==number)
  235.   {
  236.     HideWindow(Win);
  237.     if (Prev) Prev->NextWindow=Win->NextWindow;
  238.     return(Win);
  239.   }
  240.   else return(NULL);
  241. }
  242.  
  243. void NewFirstWindow(int number)
  244. {
  245.   struct windowdata *Win;
  246.  
  247.   if (FirstWindow->handle != number) 
  248.     if ((Win=GetFirstWindow(number,FirstWindow,NULL))!=NULL)
  249.     {
  250.       ShowHiddenWindow(Win);
  251.       Win->NextWindow=FirstWindow;
  252.       FirstWindow=Win;
  253.     }
  254. }
  255.  
  256. int cwindow(void)    
  257. {
  258.   long x1,y1,x2,y2,c1,c2,c3,c4;
  259.   char *error=" Parameterfehler bei OpenWindow! ";
  260.   char VarName[50];
  261.  
  262.   if ( GetIntegerParam(&x1) && GetIntegerParam(&y1) &&
  263.        GetIntegerParam(&x2) && GetIntegerParam(&y2) &&
  264.        GetIntegerParam(&c1) && GetIntegerParam(&c2) &&
  265.        GetIntegerParam(&c3) && GetIntegerParam(&c4)
  266.      ) OpenWindow(x1,y1,x2,y2,c1,c2,c3,c4);
  267.   else { serror(error); return(FALSE); }
  268.  
  269.   Scan();
  270.   if (Steuer==ALPHA)
  271.   {
  272.     strcpy(VarName,ScanBuffer);
  273.     SetVarInt(VarName,WindowCounter);
  274.   }
  275.   return(OK);
  276. }
  277.  
  278. int cclosewindow(void)    
  279. {
  280.   CloseFirstWindow();
  281.  
  282.   return(OK);
  283. }
  284.  
  285. void WR_STRMAX(char *str,unsigned char a,char max)  
  286. {    
  287.   int i,ii; 
  288.   char *ptr=(str);
  289.  
  290.   i=0;
  291.   while (*ptr!=0 && i++<max)       
  292.   { 
  293.     WR_SCR(*ptr,(a)); 
  294.     ptr++; 
  295.   } 
  296.   for (ii=i; ii<max; ii++)
  297.     WR_SCR(' ',a);     
  298. }
  299.  
  300. void WinReadStr(char *frage, char *ergebnis, int laenge)
  301. {
  302.   int breite,x1;
  303.   breite=laenge;
  304.  
  305.   if (strlen(frage)>breite) breite=strlen(frage);
  306.   x1=40-breite/2-1;
  307.   OpenWindow(x1,10,x1+breite+1,13, 22,24,26,28);
  308.   SET_POS(x1+1,11);
  309.   WR_STR(frage, 30);
  310.   gotoxy(x1+1,12);
  311.   gets(ergebnis);
  312.  
  313.   CloseFirstWindow();
  314. }
  315.  
  316. void Message(char *str)
  317. {
  318.   int breite,x1;
  319.   char c;
  320.  
  321.   breite=30;
  322.   if (strlen(str)>breite) breite=strlen(str);
  323.   x1=40-breite/2-1;
  324.   OpenWindow(x1,10,x1+breite+1,13, 22,24,26,28);
  325.   SET_POS(x1+1,11);
  326.   WR_STR(str, 30);
  327.   SET_POS(x1+1,12);
  328.   WR_STR(" Taste drücken für weiter... ",30);
  329.   c=getch();
  330.  
  331.   CloseFirstWindow();
  332. }
  333.  
  334. int cwindowfirst(void)
  335. {
  336.   long nummer;
  337.   if (GetIntegerParam(&nummer))
  338.     NewFirstWindow(nummer);
  339.   else { serror(" Fensternummer erwartet! "); return(FALSE); }
  340.  
  341.   return(OK);
  342. }
  343.  
  344. /* WinReadStr <frage> <lese-string> <laenge> */
  345. int cWinReadStr(void)
  346. {
  347.   long len;
  348.   char frage[80],*strp,varname[VNLAENGE],antwort[78];
  349.  
  350.   if ( GetStringParam(&strp) && strcpy(frage,strp) &&
  351.        GetStrVarParam(&strp) && strcpy(varname,ScanBuffer) &&
  352.        GetIntegerParam(&len) )
  353.   {
  354.     MAX(len,78);
  355.     WinReadStr(frage,antwort,len);
  356.     SetVarStr(varname,antwort);
  357.     return(OK);
  358.   }
  359.   else 
  360.   {
  361.     serror(" Falscher Parameter in WinReadStr. ");
  362.     return(FALSE);      
  363.   }     
  364. }
  365.  
  366. /* WinMessage <message> */
  367. int cWinMessage(void)
  368. {
  369.   long len;
  370.   char msg[80],*strp;
  371.  
  372.   if ( GetStringParam(&strp) && strcpy(msg,strp))
  373.   {
  374.     Message(msg);
  375.     return(OK);
  376.   }
  377.   else 
  378.   {
  379.     serror(" Falscher Parameter in WinMessage. ");
  380.     return(FALSE);      
  381.   }     
  382. }
  383.  
  384. /* MoveWin  <relx> <rely> */
  385. int cMoveWin(void)
  386. {
  387.   long x,y;
  388.  
  389.   if ( GetIntegerParam(&x) && GetIntegerParam(&y) )
  390.   {
  391.     MoveWindow(x,y);
  392.     return(OK);
  393.   }
  394.   else 
  395.   {
  396.     serror(" Falscher Parameter in MoveWin. ");
  397.     return(FALSE);      
  398.   }     
  399. }
  400.  
  401. /* ResizeWin  <relx> <rely> */
  402. int cResizeWin(void)
  403. {
  404.   long x,y;
  405.  
  406.   if ( GetIntegerParam(&x) && GetIntegerParam(&y) )
  407.   {
  408.     ResizeWindow(x,y);
  409.     return(OK);
  410.   }
  411.   else 
  412.   {
  413.     serror(" Falscher Parameter in ResizeWin. ");
  414.     return(FALSE);      
  415.   }     
  416. }
  417.  
  418. /* NewWinKoor  <relx> <rely> */
  419. int cNewWinKoor(void)
  420. {
  421.   long x1,y1,x2,y2;
  422.  
  423.   if ( GetIntegerParam(&x1) && GetIntegerParam(&y1) &&
  424.        GetIntegerParam(&x2) && GetIntegerParam(&y2) )    
  425.   {
  426.     NewKoorWindow(x1,y1,x2,y2);
  427.     return(OK);
  428.   }
  429.   else 
  430.   {
  431.     serror(" Falscher Parameter in NewWinKoor. ");
  432.     return(FALSE);      
  433.   }     
  434. }
  435.  
  436. int csetcursor(void)    
  437. {
  438.   long x,y;
  439.  
  440.  
  441.   if (GetIntegerParam(&x) && GetIntegerParam(&y))
  442.   {
  443.     if (FirstWindow!=NULL)
  444.       gotoxy(FirstWindow->x1+x,FirstWindow->y1+y);
  445.     else gotoxy(x,y);
  446.   } 
  447.   else  { 
  448.     serror(" Parameterfehler in SetCursor! "); 
  449.     return(FALSE); 
  450.   }
  451.  
  452.   return(OK);
  453. }
  454.  
  455. int cWinWrite(void)
  456. {
  457.   long x,y,a;
  458.   int x1,y1;
  459.   char *str;
  460.  
  461.   if (GetIntegerParam(&x) && GetIntegerParam(&y) &&
  462.       GetIntegerParam(&a) && GetStringParam(&str) )
  463.   {
  464.     if (FirstWindow!=NULL)
  465.     {
  466.       x1=FirstWindow->x1;
  467.       y1=FirstWindow->y1;
  468.     } else { x1=y1=0; }
  469.     SET_POS(x1+x,y1+y);
  470.     WR_STR(str,a);
  471.   } 
  472.   else  { 
  473.     serror(" Parameterfehler in WinWrite! "); 
  474.     return(FALSE); 
  475.   }
  476.  
  477.   return(OK);
  478. }