home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / libs / plotlib.lha / Plot_1.lzh / Source / test.c < prev   
Encoding:
C/C++ Source or Header  |  1990-02-08  |  19.4 KB  |  684 lines
  1. /****************************************************************
  2. *                                                                                                                                *
  3. *     Filename : Test.c                                                                                        *
  4. *                                                                                                                                *
  5. *****************************************************************
  6. *                                                                                                                                *
  7. *        Comment : Testprogramm für die Plotlibrary                                    *
  8. *                                                                                                                                *
  9. *                Rev : V1.0                                                                                            *
  10. *                                                                                                                                *
  11. *        History : V1.0 erstellen dieses Files                            01/12/89    *
  12. *                                                                                                                                *
  13. *                Doc : Plotlibrary User's Guide                                                    *
  14. *                                                                                                                                *
  15. *             Bugs : keine bekannten                                                                        *
  16. *                                                                                                                                *
  17. *            Autor : Oesch Silvano                                                                            *
  18. *                                                                                                                                *
  19. *            Datum : 01/12/89                                                                                    *
  20. *                                                                                                                                *
  21. ****************************************************************/
  22.  
  23. /****************************************************************
  24. *                                                                                                                                *
  25. *    allgemeine Includedateien                                                                            *
  26. *                                                                                                                                *
  27. ****************************************************************/
  28.  
  29. #include <ctype.h>
  30. #include <string.h>
  31. #include <signal.h>
  32. #include <stdio.h>
  33. #include <math.h>
  34.  
  35. /****************************************************************
  36. *                                                                                                                                *
  37. *    Plotlibrary Includedateien                                                                        *
  38. *                                                                                                                                *
  39. ****************************************************************/
  40.  
  41. #include "plotlib.h"
  42.  
  43. /****************************************************************
  44. *                                                                                                                                *
  45. *    Die nächsten Includedateien sind nur für das Testprogramm            *
  46. *    notwendig. Bei einem normalen Applikationsprogramm müssen            *
  47. *    und dürfen diese Dateien nicht geladen werden.                                *
  48. *                                                                                                                                *
  49. ****************************************************************/
  50.  
  51. #include "Plot.h"
  52. #include "DebugL2.h"
  53.  
  54. /****************************************************************
  55. *                                                                                                                                *
  56. *    Globale Variablen                                                                                            *
  57. *                                                                                                                                *
  58. ****************************************************************/
  59.  
  60. extern int plerr;
  61. extern struct Plot *plot;
  62.  
  63. /****************************************************************
  64. *                                                                                                                                *
  65. *    Math. Funktionsdefinitionen für die Get_data Funktion                    *
  66. *                                                                                                                                *
  67. ****************************************************************/
  68.  
  69. #define LASTFCT 9                                        /* max. definierte Fkt            */
  70.  
  71. char *fct[] =                                                /* Funktionstext                        */
  72. {
  73.     "sin(x)",
  74.     "cos(x)",
  75.     "tan(x)",
  76.     "exp(x)",
  77.     "log(x)",
  78.     "sqrt(x)",
  79.     "sin(x)/x",
  80.     "x",
  81.     "x^2"
  82. };
  83.  
  84. DATA myfct();                                            /* eine eigene Fkt                    */
  85. DATA linear();
  86. DATA quadrat();
  87.  
  88.  
  89.  
  90. DATA (*funcptr[])() =                            /* Array von Fkt. adressen    */
  91. {
  92.     sin,
  93.     cos,
  94.     tan,
  95.     exp,
  96.     log,
  97.     sqrt,
  98.     myfct,
  99.     linear,
  100.     quadrat
  101. };
  102.  
  103. /****************************************************************
  104. *                                                                                                                                *
  105. *    Function : myfct()                                                                                        *
  106. *                                                                                                                                *
  107. *****************************************************************
  108. *                                                                                                                                *
  109. *         Input : DATA x            x-Wert                                                                    *
  110. *                                                                                                                                *
  111. *        Output : DATA y            Resultat der Berechnung                                    *
  112. *                                                                                                                                *
  113. *****************************************************************
  114. *                                                                                                                                *
  115. *     Comment : Beispiel einer eigenen math. Funktion.                            *
  116. *                                                                                                                                *
  117. ****************************************************************/
  118.  
  119. DATA myfct(x)                                                /* eine eigene Fkt                    */
  120. DATA x;
  121. {
  122.     if (x == 0.0)
  123.         return(1.0);
  124.     else
  125.         return((DATA)(sin(x)/x));
  126. }
  127.  
  128. /****************************************************************
  129. *                                                                                                                                *
  130. *    Function : linear()                                                                                        *
  131. *                                                                                                                                *
  132. *****************************************************************
  133. *                                                                                                                                *
  134. *         Input : DATA x            x-Wert                                                                    *
  135. *                                                                                                                                *
  136. *        Output : DATA y            Resultat der Berechnung                                    *
  137. *                                                                                                                                *
  138. *****************************************************************
  139. *                                                                                                                                *
  140. *     Comment : Beispiel einer eigenen math. Funktion.                            *
  141. *                                                                                                                                *
  142. ****************************************************************/
  143.  
  144. DATA linear(x)                                            /* eine eigene Fkt                    */
  145. DATA x;
  146. {
  147.     return(x);
  148. }
  149.  
  150.  
  151. /****************************************************************
  152. *                                                                                                                                *
  153. *    Function : Quadrat()                                                                                    *
  154. *                                                                                                                                *
  155. *****************************************************************
  156. *                                                                                                                                *
  157. *         Input : DATA x            x-Wert                                                                    *
  158. *                                                                                                                                *
  159. *        Output : DATA y            Resultat der Berechnung                                    *
  160. *                                                                                                                                *
  161. *****************************************************************
  162. *                                                                                                                                *
  163. *     Comment : Beispiel einer eigenen math. Funktion.                            *
  164. *                                                                                                                                *
  165. ****************************************************************/
  166.  
  167. DATA quadrat(x)                                            /* eine eigene Fkt                    */
  168. DATA x;
  169. {
  170.     return((DATA)(x*x));
  171. }
  172.  
  173.  
  174. /****************************************************************
  175. *                                                                                                                                *
  176. *    Function : displayfct()                                                                                *
  177. *                                                                                                                                *
  178. *****************************************************************
  179. *                                                                                                                                *
  180. *         Input : void                                                                                                *
  181. *                                                                                                                                *
  182. *        Output : int                Nummer der Funktion                                            *
  183. *                                                                                                                                *
  184. *****************************************************************
  185. *                                                                                                                                *
  186. *     Comment : Zeigt die verschiedenen definierten Funktionen.        *
  187. *                                                                                                                                *
  188. ****************************************************************/
  189.  
  190. int displayfct()
  191. {
  192.     int i;
  193.     for (i=0;i<LASTFCT;i++)                        /* zeige alle Fkt mit ID        */
  194.         printf("[%d] -> %s\n",i,fct[i]);
  195.     printf("\nWelche Nummer : ");
  196.     scanf("%d",&i);                                        /* Hole Wahl                                */
  197.     if ((i >= LASTFCT) or                            /* in Range                                    */
  198.             (i < 0 ))
  199.     {
  200.         printf("Funktion nicht bekannt!\n");
  201.         return(-1);
  202.     }
  203.     else
  204.         return(i);
  205. }
  206.  
  207.  
  208. /****************************************************************
  209. *                                                                                                                                *
  210. *    Function : axmenu()                                                                                        *
  211. *                                                                                                                                *
  212. *****************************************************************
  213. *                                                                                                                                *
  214. *         Input : int *axis                                                                                    *
  215. *                                                                                                                                *
  216. *        Output : void                                                                                                *
  217. *                                                                                                                                *
  218. *****************************************************************
  219. *                                                                                                                                *
  220. *     Comment : Achsenauswahlmenu                                                                    *
  221. *                                                                                                                                *
  222. ****************************************************************/
  223.  
  224. void axmenu(axis)
  225. int *axis;
  226. {
  227.     printf("\n[%d] -> X-Achse\n",XAXIS);
  228.     printf("[%d] -> Y-Achse\n",YAXIS);
  229.     printf("[%d] -> Z-Achse\n\n",ZAXIS);
  230.     printf("Welche Achse : ");
  231.     scanf("%d",axis);
  232. }
  233.  
  234. /****************************************************************
  235. *                                                                                                                                *
  236. *    Function : status()                                                                                        *
  237. *                                                                                                                                *
  238. *****************************************************************
  239. *                                                                                                                                *
  240. *         Input : id,string                                                                                    *
  241. *                            int id                    Rückgabewert                                            *
  242. *                            char *string        TRUE Ausgabetext                                    *
  243. *                                                                                                                                *
  244. *        Output : void                                                                                                *
  245. *                                                                                                                                *
  246. *****************************************************************
  247. *                                                                                                                                *
  248. *     Comment : Rückgabewert Auswertung                                                        *
  249. *                                                                                                                                *
  250. ****************************************************************/
  251.  
  252. void status(id,string)
  253. int id;
  254. char *string;
  255. {
  256.     if (id  == FALSE)
  257.         dis_ploterror();
  258.     else
  259.         printf("Rückgabewert %d : %s\n",id,string);
  260. }
  261.  
  262. /****************************************************************
  263. *                                                                                                                                *
  264. *    Function : gettyp()                                                                                        *
  265. *                                                                                                                                *
  266. *****************************************************************
  267. *                                                                                                                                *
  268. *         Input : void                                                                                                *
  269. *                                                                                                                                *
  270. *        Output : int typ                                                                                        *
  271. *                                                                                                                                *
  272. *****************************************************************
  273. *                                                                                                                                *
  274. *     Comment : Typauswahl                                                                                    *
  275. *                                                                                                                                *
  276. ****************************************************************/
  277.  
  278. int gettyp()
  279. {
  280.     int i;
  281.  
  282.     printf("\n[%d] -> Eingabe des Namens\n",NOID);
  283.     printf("[%d] -> Eingabe der ID\n",1);
  284.     printf("Bitte Kennzahl eingeben : ");
  285.     scanf("%d",&i);
  286.     return(i);
  287. }
  288.  
  289. /****************************************************************
  290. *                                                                                                                                *
  291. *    Function : getid()                                                                                        *
  292. *                                                                                                                                *
  293. *****************************************************************
  294. *                                                                                                                                *
  295. *         Input : id                                                                                                    *
  296. *                            int *id                    gesuchte ID                                                *
  297. *                                                                                                                                *
  298. *        Output : void                                                                                                *
  299. *                                                                                                                                *
  300. *****************************************************************
  301. *                                                                                                                                *
  302. *     Comment : Hole ID                                                                                        *
  303. *                                                                                                                                *
  304. ****************************************************************/
  305.  
  306. void getid(id)
  307. int *id;
  308. {
  309.     printf("Bitte ID geben : ");
  310.     scanf("%d",id);
  311. }
  312.  
  313. /****************************************************************
  314. *                                                                                                                                *
  315. *    Function : getname()                                                                                    *
  316. *                                                                                                                                *
  317. *****************************************************************
  318. *                                                                                                                                *
  319. *         Input : string                                                                                            *
  320. *                            char *string        gesuchter String                                    *
  321. *                                                                                                                                *
  322. *        Output : void                                                                                                *
  323. *                                                                                                                                *
  324. *****************************************************************
  325. *                                                                                                                                *
  326. *     Comment : Hole String                                                                                *
  327. *                                                                                                                                *
  328. ****************************************************************/
  329.  
  330. void getname(buffer)
  331. char *buffer;
  332. {
  333.     printf("Bitte Namen geben : ");
  334.     scanf("%s",buffer);
  335. }
  336.  
  337. /****************************************************************
  338. *                                                                                                                                *
  339. *    Function : menu()                                                                                            *
  340. *                                                                                                                                *
  341. *****************************************************************
  342. *                                                                                                                                *
  343. *         Input : void                                                                                                *
  344. *                                                                                                                                *
  345. *        Output : void                                                                                                *
  346. *                                                                                                                                *
  347. *****************************************************************
  348. *                                                                                                                                *
  349. *     Comment : Menu Auswahl                                                                                *
  350. *                                                                                                                                *
  351. ****************************************************************/
  352.  
  353. int menu()
  354. {
  355.     int returnset,i;
  356.  
  357. #define MENUITEMS 24
  358.  
  359. char *menutext[MENUITEMS] =
  360. {
  361.     "\nT E S T   P R O G R A M M für die Plotlibrary\n",
  362.     "---------------------------------------------\n\n",
  363.     "[ 1] Library öffnen\t[ 2] Library schliessen\n",
  364.     "[ 3] 2D Daten laden\t[ 4] Niveau Daten laden\n",
  365.     "[ 5] 3D Daten Laden\t[ 6] Kurve berechnen\n",
  366.     "[ 7] Plot Struktur\t[ 8] Kurve zeigen\n",
  367.     "[ 9] Werte zeigen\n",
  368.     "[10] Kurve löschen\t[11] alles löschen\n",
  369.     "[12] Plotter Parameter\n",
  370.     "[14] Muster ON\t\t[15] Muster OFF\n",
  371.     "[20] Value setzen\t[21] Value löschen\n",
  372.     "[22] Autoval ON\t\t[23] Autoval OFF\n",
  373.     "[24] Gitter ON\t\t[25] Gitter OFF\n",
  374.     "[26] Masstab setzen\n",
  375.     "[28] Kurvenfarbe\t[29] Farbe löschen\n",
  376.     "[30] Display\t\t[31] Bildschirm schliessen\n",
  377.     "[40] Achsenname setzen\t[41] Achsenname löschen\n",
  378.     "[42] Einheit setzen\t[43] Einheit löschen\n",
  379.     "[44] Titel setzen\t[45] Titel löschen\n",
  380.     "[46] Kurvenname setzen\t[47] Kurvenname löschen\n",
  381.     "[48] Crosshatching ein\t[49] Crosshatching aus\n",
  382.     "[50] Hiddenline ein\t[51] Hiddenline aus\n",
  383.     "[99] Exit\n",
  384.     "Bitte eine Zahl eingeben : "
  385. };
  386.  
  387.     for (i=0;i<MENUITEMS;i++)
  388.         printf("%s",menutext[i]);
  389.     scanf("%d",&returnset);
  390.     return(returnset);
  391. }
  392.  
  393.  
  394. /****************************************************************
  395. *                                                                                                                                *
  396. *                                    H A U P T P R O G R A M M                                            *
  397. *                                                                                                                                *
  398. ****************************************************************/
  399.  
  400. main()
  401. {
  402.  
  403.     int i,id,wahl,count,fctid,typ,color,out,
  404.             dis = FALSE,x,y,xl,yl,attr;
  405.     DATA xmin,xmax,value;
  406.     char buffer[80];
  407.  
  408.     for (;;)
  409.     {
  410.         wahl = menu();
  411.         switch (wahl)
  412.         {
  413.             case 1:        id = open_plot();
  414.                                 status(id,"Plotlibrary geöffnet");
  415.                                 break;
  416.  
  417.             case 2:        id = close_plot();
  418.                                 status(id,"Plotlibrary geschlossen");
  419.                                 dis = FALSE;
  420.                                 break;
  421.  
  422.             case 3:        getname(buffer);
  423.                                 id = load_data(buffer,D2);
  424.                                 status(id,"Datenfile geladen");
  425.                                 break;
  426.  
  427.             case 4:        getname(buffer);
  428.                                 id = load_data(buffer,NIV);
  429.                                 status(id,"Datenfile geladen");
  430.                                 break;
  431.  
  432.             case 5:        getname(buffer);
  433.                                 id = load_data(buffer,D3);
  434.                                 status(id,"Datenfile geladen");
  435.                                 break;
  436.  
  437.             case 6:        fctid = displayfct();
  438.                                 if (fctid == -1) break;
  439.                                 printf("Grenzen angeben : xmin,xmax,iterate :");
  440.                                 scanf("%lf,%lf,%d",&xmin,&xmax,&count);
  441.                                 id = get_data(funcptr[fctid],xmin,xmax,count);
  442.                                 status(id,"Kurve berechnet");
  443.                                 break;
  444.  
  445.             case 7:        dispplot();
  446.                                 break;
  447.  
  448.             case 8:        getid(&id);
  449.                                 displaycurve(id);
  450.                                 break;
  451.  
  452.             case 9:        getid(&id);
  453.                                 displaydata(id);
  454.                                 break;
  455.  
  456.             case 10:    typ = gettyp();
  457.                                 if (typ != NOID)
  458.                                 {
  459.                                     getid(&id);
  460.                                     id = del_data(id,NULL);
  461.                                 }
  462.                                 else
  463.                                 {
  464.                                     getname(buffer);
  465.                                     id = del_data(NOID,buffer);
  466.                                 }
  467.                                 status(id,"Kurve gelöscht");
  468.                                 break;
  469.  
  470.             case 11:    id = del_data(DELALL,NULL);
  471.                                 status(id,"Kurven gelöscht");
  472.                                 break;
  473.  
  474.             case 12:    printf("Eingabe von Start x,y in cm : ");
  475.                                 scanf("%d,%d",&x,&y);
  476.                                 printf("Grösse des Bildes x,y in cm : ");
  477.                                 scanf("%d,%d",&xl,&yl);
  478.                                 printf(" [%d] -> Normal\n",0);
  479.                                 printf(" [%d] -> Drehung\n",ROTATE);
  480.                                 printf(" Ihre Wahl : ");
  481.                                 scanf("%d",&attr);
  482.                                 printf(" Filename : ");
  483.                                 scanf("%s",buffer);
  484.                                 id = set_plotsize(x,y,xl,yl,attr,buffer);
  485.                                 status(id,"Parameter gesetzt");
  486.                                 break;
  487.  
  488.             case 14:    id = set_fill(STYLE);
  489.                                 status(id,"Muster auf ON gesetzt");
  490.                                 break;
  491.  
  492.             case 15:    id = set_fill(NOSTYLE);
  493.                                 status(id,"Muster auf OFF gesetzt");
  494.                                 break;
  495.  
  496.             case 20:    printf("\n[%d] -> Xmin\n",XMIN);
  497.                                 printf("[%d] -> Xmax\n",XMAX);
  498.                                 printf("[%d] -> Ymin\n",YMIN);
  499.                                 printf("[%d] -> Ymax\n",YMAX);
  500.                                 printf("[%d] -> Zmin\n",ZMIN);
  501.                                 printf("[%d] -> Zmax\n",ZMAX);
  502.                                 printf("Welcher Typ : ");
  503.                                 scanf("%d",&id);
  504.                                 printf("Neuer Wert : ");
  505.                                 scanf("%lf",&value);
  506.                                 id = set_value(id,value);
  507.                                 status(id,"Neuer Wert gesetzt");
  508.                                 break;
  509.  
  510.             case 21:    id = set_value(CLEAR,(DATA)NULL);
  511.                                 status(id,"Alle Werte gelöscht");
  512.                                 break;
  513.  
  514.             case 22:    id = set_autoval(AUTOON);
  515.                                 status(id,"Autoval auf ON gesetzt");
  516.                                 break;
  517.  
  518.             case 23:    id = set_autoval(AUTOOFF);
  519.                                 status(id,"Autoval auf OFF gesetzt");
  520.                                 break;
  521.  
  522.             case 24:    id = set_grid(GRID);
  523.                                 status(id,"Gitter auf ON gesetzt");
  524.                                 break;
  525.  
  526.             case 25:    id = set_grid(NOGRID);
  527.                                 status(id,"Gitter auf OFF gesetzt");
  528.                                 break;
  529.  
  530.             case 26:    axmenu(&id);
  531.                                 printf("\n[%d] -> Linear\n",LIN);
  532.                                 printf("[%d] -> Logarithmisch\n",LOG);
  533.                                 printf("[%d] -> natürlich Logarithmisch\n",LN);
  534.                                 printf(" Kennwert eingeben :");
  535.                                 scanf("%d",&typ);
  536.                                 id = set_mes(id,typ);
  537.                                 status(id,"Masstab gesetzt");
  538.                                 break;
  539.  
  540.             case 28:    typ = gettyp();
  541.                                 if (typ != NOID)
  542.                                     getid(&id);
  543.                                 else
  544.                                     getname(buffer);
  545.                                 printf("Welche Farbe : ");
  546.                                 scanf("%d",&color);
  547.                                 if (typ != NOID)
  548.                                     id = set_curvecolor(id,NULL,color);
  549.                                 else
  550.                                     id = set_curvecolor(NOID,buffer,color);
  551.                                 status(id,"Farbe gesetzt");
  552.                                 break;
  553.  
  554.             case 29:    typ = gettyp();
  555.                                 if (typ != NOID)
  556.                                 {
  557.                                     getid(&id);
  558.                                     id = set_curvecolor(id,NULL,COLDET);
  559.                                 }
  560.                                 else
  561.                                 {
  562.                                     getname(buffer);
  563.                                     id = set_curvecolor(NOID,buffer,COLDET);
  564.                                 }
  565.                                 status(id,"Farbe gelöscht");
  566.                                 break;
  567.  
  568.             case 30:    printf("\n[%d] -> Bildschirm\n",SCREENOUT);
  569.                                 printf("[%d] -> Matrixdrucker\n",PRINTOUT);
  570.                                 printf("[%d] -> Plotter\n",PLOTOUT);
  571.                                 printf("Welche Art Ausgabe : ");
  572.                                 scanf("%d",&id);
  573.                                 if (id == SCREENOUT)
  574.                                 {
  575.                                     printf ("[%d] -> Ausgabe NSET\n",GRAPHNOTSET);
  576.                                     printf ("[%d] -> Ausgabe SET\n",GRAPHSET);
  577.                                     printf("Welche Art Ausgabe : ");
  578.                                     scanf("%d",&out);
  579. /*******************/
  580. #ifdef __MSDOS__
  581. #ifdef __TURBOC__
  582. /*******************/
  583.                                     id = display(id,out);
  584.                                     id = (int)getch();
  585.                                     id = display(SCREENCLOSE,NULL);
  586.                                     dis = FALSE;
  587. #endif
  588. #endif
  589.  
  590. /*******************/
  591. #ifdef AMIGA
  592. /*******************/
  593.                                     id = display(id,out);
  594.                                     dis = TRUE;
  595. #endif
  596.                                 }
  597.                                 else
  598.                                 {
  599.                                     id = display(id,GRAPHNOTSET);
  600.                                     dis = TRUE;
  601.                                 }
  602.                                 status(id,"Ausgabe gemacht");
  603.                                 break;
  604.  
  605.             case 31:    id = display(SCREENCLOSE,NULL);
  606.                                 status(id,"Graphikschirm geschlossen");
  607.                                 dis = FALSE;
  608.                                 break;
  609.  
  610.             case 40:    axmenu(&id);
  611.                                 getname(buffer);
  612.                                 id = set_axisname(id,buffer);
  613.                                 status(id,"Achsenname gesetzt");
  614.                                 break;
  615.  
  616.             case 41:    axmenu(&id);
  617.                                 id = set_axisname(id,NULL);
  618.                                 status(id,"Achsenname gelöscht");
  619.                                 break;
  620.  
  621.             case 42:    axmenu(&id);
  622.                                 getname(buffer);
  623.                                 id = set_unit(id,buffer);
  624.                                 status(id,"Achseneinheit gesetzt");
  625.                                 break;
  626.  
  627.             case 43:    axmenu(&id);
  628.                                 id = set_unit(id,NULL);
  629.                                 status(id,"Achseneinheit gelöscht");
  630.                                 break;
  631.  
  632.             case 44:    getname(buffer);
  633.                                 id = set_titel(buffer);
  634.                                 status(id,"Titel gesetzt");
  635.                                 break;
  636.  
  637.             case 45:    id = set_titel(NULL);
  638.                                 status(id,"Titel gelöscht");
  639.                                 break;
  640.  
  641.             case 46:    getid(&id);
  642.                                 getname(buffer);
  643.                                 id = set_curvename(id,buffer);
  644.                                 status(id,"Kurvenname gesetzt");
  645.                                 break;
  646.  
  647.             case 47:    getid(&id);
  648.                                 id = set_curvename(id,NULL);
  649.                                 status(id,"Kurvenname gelöscht");
  650.                                 break;
  651.  
  652.             case 48:    id = set_3doptions(CROSHON);
  653.                                 status(id,"Crosshatching eingeschaltet");
  654.                                 break;
  655.  
  656.             case 49:    id = set_3doptions(CROSHOFF);
  657.                                 status(id,"Crosshatching ausgeschaltet");
  658.                                 break;
  659.  
  660.             case 50:    id = set_3doptions(HIDDENON);
  661.                                 status(id,"Hiddenlines eingeschaltet");
  662.                                 break;
  663.  
  664.             case 51:    id = set_3doptions(HIDDENOFF);
  665.                                 status(id,"Hiddenlines ausgeschaltet");
  666.                                 break;
  667.  
  668.             case 99:    if (dis == TRUE)
  669.                                 {
  670.                                     printf ("Graphik noch geöffnet");
  671.                                     break;
  672.                                 }
  673.                                 else exit(0);
  674.  
  675.             default:    printf("keine legale Funktion angewählt");
  676.                                 break;
  677.         }
  678.         printf("\n\nRETURN to continue");
  679.         while (getchar() != '\n');
  680.         while (getchar() != '\n');
  681.     }
  682. }
  683.  
  684.