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 / Demo / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-19  |  15.8 KB  |  803 lines
  1. /****************************************************************
  2. *                                                                                                                                *
  3. * Filename : Main.c                                                                                            *
  4. *                                                                                                                                *
  5. *****************************************************************
  6. *                                                                                                                                *
  7. *    Comment : Diese Datei beinhaltet alle Routinen für                        *
  8. *                        starten und beendigen des Demoprogrammes.                         *
  9. *                        Es werden hier folgende globalen Definitionen                *
  10. *                        gemacht:                                                                                        *
  11. *                                                                                                                                *
  12. *    IntuitionBase -> Basis von Intuitionlibrary                                        *
  13. *    GfxBase                -> Basis von Graphicslibrary                                        *
  14. *    Sc                        -> Screenpointer                                                                *
  15. *    Mw                        -> Mainwindowpointer                                                        *
  16. *    Vp                        -> Viewportpolinter                                                            *
  17. *    Rp                        -> Rastportpointer                                                            *
  18. *                                                                                                                                *
  19. *    newscreen            -> NewScreenstruktur                                                        *
  20. *    mainwindow        -> NewWindowstruktur                                                        *
  21. *    Menu1                    -> Menustruktur                                                                    *
  22. *                                                                                                                                *
  23. *            Rev : V1.0                                                                                                *
  24. *                                                                                                                                *
  25. *    History : V1.0 erstellen dieses Files                            01.09.89        *
  26. *                                                                                                                                *
  27. *            Doc :                                                                                                            *
  28. *                                                                                                                                *
  29. *         Bugs : keine bekannten                                                                            *
  30. *                                                                                                                                *
  31. *        Autor : Oesch Silvano                                                                                *
  32. *                                                                                                                                *
  33. *        Datum : 01.09.89                                                                                        *
  34. *                                                                                                                                *
  35. ****************************************************************/
  36.  
  37.  
  38. /****************************************************************
  39. *                                                                                                                                 *
  40. * allgemeine Includedateien                                                                            *
  41. *                                                                                                                                *
  42. ****************************************************************/
  43.  
  44. #include <ctype.h>
  45. #include <string.h>
  46. #include <stdlib.h>
  47. #include <stdio.h>
  48. #include <math.h>
  49. #include <exec/alerts.h>
  50. #include <exec/types.h>
  51. #include <exec/io.h>
  52. #include <intuition/intuition.h>
  53. #include <intuition/intuitionbase.h>
  54. #include <libraries/dos.h>
  55. #include <exec/libraries.h>
  56. #include <libraries/dosextens.h>
  57. #include <mylib/mylib.h>
  58. #include <libraries/reqbase.h>
  59. #include <proto/reqproto.h>
  60.  
  61. /****************************************************************
  62. *                                                                                                                                *
  63. * programmspezifische Includedateien                                                        *
  64. *                                                                                                                                *
  65. ****************************************************************/
  66.  
  67. char xminval[] = "Xmin = -5         ";
  68. char xmaxval[] = "Xmax =  5         ";
  69. char yminval[] = "Ymin = -5         ";
  70. char ymaxval[] = "Ymax =  5         ";
  71. char zminval[] = "Zmin = -5         ";
  72. char zmaxval[] = "Zmax =  5         ";
  73.  
  74. char *valtext[] =
  75. {
  76.     xminval,
  77.     xmaxval,
  78.     yminval,
  79.     ymaxval,
  80.     zminval,
  81.     zmaxval
  82. };
  83.  
  84. #include "Definitions.h"
  85. #include "FileIO.h"
  86. #include "menu.h"                                        /* init. Menustruktur                */
  87. #include "Texte.h"
  88. #include "Pointer.h"
  89. #include "Function.h"
  90.  
  91. #include <Plot/PlotLib.h>
  92. #include <Plot/Plot.h>
  93. #include <Plot/Plerror.h>
  94.  
  95. char about[] =    "          Function - P L O T        \n"
  96.                                 "          ------------------        \n"
  97.                                 "                                    \n"
  98.                                 " Ein Demonstrationsprogramm für die \n"
  99.                                 " die  Plotlibrary. Diese Library    \n"
  100.                                 " wurde geschrieben von              \n"
  101.                                 " Silvano Oesch                      \n";
  102.  
  103. /****************************************************************
  104. *                                                                                                                                *
  105. * globale Definitionen                                                                                    *
  106. *                                                                                                                                *
  107. ****************************************************************/
  108.  
  109. #define MENUTITEL MenuItem33
  110. #define MENUGITTER MenuItem1
  111. #define MENUAUTOVAL MenuItem2
  112. #define MENUCROSS MenuItem4
  113. #define MENUHIDDEN MenuItem5
  114. #define MENUZAXENAME SubItem3
  115. #define MENUZAXEUNIT SubItem4
  116. #define MENUYAXENAME SubItem5
  117. #define MENUYAXEUNIT SubItem6
  118. #define MENUXAXENAME SubItem7
  119. #define MENUXAXEUNIT SubItem8
  120.  
  121. struct Process    *myprocess;
  122. APTR    olderrorwindow;
  123. struct FileRequester mfr;
  124.  
  125. char filename[MAXPATH+FCHARS+2];
  126.  
  127. int redraw = FALSE,
  128.         loop = TRUE,
  129.         sctitel = TRUE;
  130.  
  131. DATA myfct(DATA x);
  132. DATA quadrat(DATA x);
  133.  
  134. DATA (*funcptr[])() =                            /* Array von Fkt. adressen    */
  135. {
  136.     sin,
  137.     cos,
  138.     myfct,
  139.     quadrat,
  140.     log
  141. };
  142.  
  143. /****************************************************************
  144. *                                                                                                                                *
  145. * externe Definitionen                                                                                    *
  146. *                                                                                                                                *
  147. ****************************************************************/
  148.  
  149. extern struct ReqBLib *ReqBase;
  150.  
  151. extern struct Screen *Sc;
  152. extern struct Window *Mw;
  153. extern struct ViewPort *Vp;
  154. extern struct Rastport *Rp;
  155. extern struct Rastport *WRp;
  156.  
  157. extern int    SCREENHOEHE,
  158.                         plerr;
  159.  
  160. extern struct Plot *plot;
  161.  
  162.  
  163. void setminmaxval()
  164. {
  165.     int i,erfolg;
  166.     DATA value;
  167.  
  168.     for (i=0;i<6;i++)
  169.     {
  170.         erfolg = get_value(i,&value);
  171.         if (erfolg)
  172.             sprintf(&valtext[i][7],"% .4lg",value);
  173.     }
  174. }
  175.  
  176.  
  177. DATA myfct(x)                                                /* eine eigene Fkt                    */
  178. DATA x;
  179. {
  180.     if (x == 0.0)
  181.         return(1.0);
  182.     else
  183.         return((DATA)(sin(x)/x));
  184. }
  185.  
  186. DATA quadrat(x)                                            /* eine eigene Fkt                    */
  187. DATA x;
  188. {
  189.     return((DATA)(x*x));
  190. }
  191.  
  192. void funktionen(smenu)
  193. int smenu;
  194. {
  195.  
  196.     DATA min,max;
  197.     char buffer[80];
  198.     int id,erfolg;
  199.  
  200.     switch(smenu)
  201.     {
  202.         case FORMEL:
  203.             SimpleRequest(funktion);
  204.             break;
  205.         default:
  206.         if (GetFloat("Bitte Startwert eingeben",&min))
  207.         {
  208.             if (GetFloat("Bitte Endwert eingeben",&max))
  209.             {
  210.                 id = get_data(funcptr[smenu-1],min,max,500);
  211.                 if (id == FALSE)
  212.                     SimpleRequest(get_ploterror());
  213.                 else
  214.                 {
  215.                     do
  216.                     {
  217.                         erfolg = GetString(buffer,"Kurvenname",NULL,20,40);
  218.                     }
  219.                     while(!erfolg);
  220.                     set_curvename(id,buffer);
  221.                     redraw = TRUE;
  222.                     setminmaxval();
  223.                 }
  224.             }
  225.         }
  226.         break;
  227.     }
  228. }
  229.  
  230.  
  231. void resetflags()
  232. {
  233.     MENUGITTER.Flags &= ~CHECKED;
  234.     MENUAUTOVAL.Flags &= ~CHECKED;
  235. }
  236.  
  237. void filemenu(smenu)
  238. int smenu;
  239. {
  240.     int erfolg,
  241.             id;
  242.     char buffer[80];
  243.  
  244.     switch (smenu)
  245.     {
  246.         case LOESCHEN:
  247.             erfolg = TwoGadRequest("Alles löschen !\nSind Sie sicher ?\n");
  248.             if (erfolg == TRUE)
  249.             {
  250.                 erfolg = del_data(DELALL,NULL);
  251.                 if (erfolg == FALSE)
  252.                     SimpleRequest(get_ploterror());
  253.                 else
  254.                 {
  255.                     Move(WRp,0,0);
  256.                     ClearScreen(WRp);
  257.                     resetflags();
  258.                     setminmaxval();
  259.                 }
  260.             }
  261.             break;
  262.  
  263.         case LADEN:
  264.             mfr.Title = "Laden";
  265.             erfolg = FileRequester(&mfr);
  266.             if (erfolg == TRUE)
  267.             {
  268.                 id = load_data(filename,NULL);
  269.                 if (id == FALSE)
  270.                     SimpleRequest(get_ploterror());
  271.                 else
  272.                 {
  273.                     do
  274.                     {
  275.                         buffer[0] = 0x00;
  276.                         erfolg = GetString(buffer,"Kurvenname",NULL,20,40);
  277.                     }
  278.                     while(!erfolg);
  279.                     set_curvename(id,buffer);
  280.                     redraw = TRUE;
  281.                     setminmaxval();
  282.                 }
  283.             }
  284.             break;
  285.  
  286.         case DRUCKAUSGABE:
  287.             erfolg = HardCopy(Sc,Mw);
  288.             if ( erfolg == FALSE )
  289.                 SimpleRequest(hardcopy);
  290.             break;
  291.  
  292.         case PLOTAUSGABE:
  293.             erfolg = HpPlot(Sc);
  294.             if ( erfolg == FALSE )
  295.                 SimpleRequest(get_ploterror());
  296.             break;
  297.  
  298.         case BEENDEN:
  299.             erfolg =     TwoGadRequest("Programm beenden !\nSind Sie sicher ?\n");
  300.             if (erfolg)
  301.             {
  302.                 loop=FALSE;
  303.                 ClearPointer(Mw);
  304.             }
  305.             break;
  306.  
  307.         case HELP:
  308.             erfolg = Help();
  309.             if ( erfolg == FALSE )
  310.                 SimpleRequest(hardcopy);
  311.             break;
  312.  
  313.         case INFORMATIONEN:
  314.             SimpleRequest(about);
  315.             break;
  316.  
  317.         default:
  318.             SimpleRequest(funktion);
  319.             break;
  320.     }
  321. }
  322.  
  323. void beschriftung (smenu,ssmenu)
  324. int smenu;
  325. {
  326.     int erfolg;
  327.     char buffer[50];
  328.  
  329.     switch (smenu)
  330.     {
  331.         case GRTITEL:
  332.             if (MENUTITEL.Flags & CHECKED)
  333.             {
  334.                 buffer[0] = 0x0;
  335.                 erfolg = GetString(buffer,"Titel der Graphik",NULL,28,49);
  336.                 if (erfolg)
  337.                 {
  338.                     erfolg = set_titel(buffer);
  339.                     if (erfolg == FALSE)
  340.                         SimpleRequest(get_ploterror());
  341.                 }
  342.                 if (erfolg == FALSE)
  343.                     MENUTITEL.Flags &= ~CHECKED;
  344.             }
  345.             else
  346.             {
  347.                 erfolg = set_titel(NULL);
  348.                 if (erfolg == FALSE)
  349.                 {
  350.                     MENUTITEL.Flags |= CHECKED;
  351.                     SimpleRequest(get_ploterror());
  352.                 }
  353.             }
  354.             break;
  355.  
  356.         case X_ACHSE:
  357.             if (ssmenu == XACHSENNAME)
  358.             {
  359.                 if (MENUXAXENAME.Flags & CHECKED)
  360.                 {
  361.                     buffer[0] = 0x0;
  362.                     erfolg = GetString(buffer,"Titel der X-Achse",NULL,28,49);
  363.                     if (erfolg)
  364.                     {
  365.                         erfolg = set_axisname(XAXIS,buffer);
  366.                         if (erfolg == FALSE)
  367.                             SimpleRequest(get_ploterror());
  368.                     }
  369.                     if (erfolg == FALSE)
  370.                         MENUXAXENAME.Flags &= ~CHECKED;
  371.                 }
  372.                 else
  373.                 {
  374.                     erfolg = set_axisname(XAXIS,NULL);
  375.                     if (erfolg == FALSE)
  376.                     {
  377.                         MENUXAXENAME.Flags |= CHECKED;
  378.                         SimpleRequest(get_ploterror());
  379.                     }
  380.                 }
  381.             }
  382.             else
  383.             {
  384.                 if (MENUXAXEUNIT.Flags & CHECKED)
  385.                 {
  386.                     buffer[0] = 0x0;
  387.                     erfolg = GetString(buffer,"Einheit der X-Achse",NULL,28,49);
  388.                     if (erfolg)
  389.                     {
  390.                         erfolg = set_unit(XAXIS,buffer);
  391.                         if (erfolg == FALSE)
  392.                             SimpleRequest(get_ploterror());
  393.                     }
  394.                     if (erfolg == FALSE)
  395.                         MENUXAXEUNIT.Flags &= ~CHECKED;
  396.                 }
  397.                 else
  398.                 {
  399.                     erfolg = set_unit(XAXIS,NULL);
  400.                     if (erfolg == FALSE)
  401.                     {
  402.                         MENUXAXEUNIT.Flags |= CHECKED;
  403.                         SimpleRequest(get_ploterror());
  404.                     }
  405.                 }
  406.             }
  407.             break;
  408.  
  409.         case Y_ACHSE:
  410.             if (ssmenu == YACHSENNAME)
  411.             {
  412.                 if (MENUYAXENAME.Flags & CHECKED)
  413.                 {
  414.                     buffer[0] = 0x0;
  415.                     erfolg = GetString(buffer,"Titel der Y-Achse",NULL,28,49);
  416.                     if (erfolg)
  417.                     {
  418.                         erfolg = set_axisname(YAXIS,buffer);
  419.                         if (erfolg == FALSE)
  420.                             SimpleRequest(get_ploterror());
  421.                     }
  422.                     if (erfolg == FALSE)
  423.                         MENUYAXENAME.Flags &= ~CHECKED;
  424.                 }
  425.                 else
  426.                 {
  427.                     erfolg = set_axisname(YAXIS,NULL);
  428.                     if (erfolg == FALSE)
  429.                     {
  430.                         MENUYAXENAME.Flags |= CHECKED;
  431.                         SimpleRequest(get_ploterror());
  432.                     }
  433.                 }
  434.             }
  435.             else
  436.             {
  437.                 if (MENUYAXEUNIT.Flags & CHECKED)
  438.                 {
  439.                     buffer[0] = 0x0;
  440.                     erfolg = GetString(buffer,"Einheit der Y-Achse",NULL,28,49);
  441.                     if (erfolg)
  442.                     {
  443.                         erfolg = set_unit(YAXIS,buffer);
  444.                         if (erfolg == FALSE)
  445.                             SimpleRequest(get_ploterror());
  446.                     }
  447.                     if (erfolg == FALSE)
  448.                         MENUYAXEUNIT.Flags &= ~CHECKED;
  449.                 }
  450.                 else
  451.                 {
  452.                     erfolg = set_unit(YAXIS,NULL);
  453.                     if (erfolg == FALSE)
  454.                     {
  455.                         MENUYAXEUNIT.Flags |= CHECKED;
  456.                         SimpleRequest(get_ploterror());
  457.                     }
  458.                 }
  459.             }
  460.             break;
  461.  
  462.         case Z_ACHSE:
  463.             if (ssmenu == ZACHSENNAME)
  464.             {
  465.                 if (MENUZAXENAME.Flags & CHECKED)
  466.                 {
  467.                     buffer[0] = 0x0;
  468.                     erfolg = GetString(buffer,"Titel der Z-Achse",NULL,28,49);
  469.                     if (erfolg)
  470.                     {
  471.                         erfolg = set_axisname(ZAXIS,buffer);
  472.                         if (erfolg == FALSE)
  473.                             SimpleRequest(get_ploterror());
  474.                     }
  475.                     if (erfolg == FALSE)
  476.                         MENUZAXENAME.Flags &= ~CHECKED;
  477.                 }
  478.                 else
  479.                 {
  480.                     erfolg = set_axisname(ZAXIS,NULL);
  481.                     if (erfolg == FALSE)
  482.                     {
  483.                         MENUZAXENAME.Flags |= CHECKED;
  484.                         SimpleRequest(get_ploterror());
  485.                     }
  486.                 }
  487.             }
  488.             else
  489.             {
  490.                 if (MENUZAXEUNIT.Flags & CHECKED)
  491.                 {
  492.                     buffer[0] = 0x0;
  493.                     erfolg = GetString(buffer,"Einheit der Z-Achse",NULL,28,49);
  494.                     if (erfolg)
  495.                     {
  496.                         erfolg = set_unit(ZAXIS,buffer);
  497.                         if (erfolg == FALSE)
  498.                         SimpleRequest(get_ploterror());
  499.                     }
  500.                     if (erfolg == FALSE)
  501.                         MENUZAXEUNIT.Flags &= ~CHECKED;
  502.                 }
  503.                 else
  504.                 {
  505.                     erfolg = set_unit(ZAXIS,NULL);
  506.                     if (erfolg == FALSE)
  507.                     {
  508.                         MENUZAXEUNIT.Flags |= CHECKED;
  509.                         SimpleRequest(get_ploterror());
  510.                     }
  511.                 }
  512.             }
  513.             break;
  514.         default:
  515.             SimpleRequest(funktion);
  516.             break;
  517.     }
  518. }
  519.  
  520. void darstellung(smenu,ssmenu)
  521. int smenu,
  522.         ssmenu;
  523. {
  524.     int erfolg;
  525.  
  526.     switch (smenu)
  527.     {
  528.  
  529.         case GITTER:
  530.             if (MENUGITTER.Flags & CHECKED)
  531.             {
  532.                 erfolg = set_grid(NOGRID);
  533.                 if (erfolg == FALSE)
  534.                 {
  535.                     MENUGITTER.Flags &= ~CHECKED;
  536.                     SimpleRequest(get_ploterror());
  537.                 }
  538.                 else
  539.                     redraw = TRUE;
  540.             }
  541.             else
  542.             {
  543.                 erfolg = set_grid(GRID);
  544.                 if (erfolg == FALSE)
  545.                 {
  546.                     MENUGITTER.Flags |= CHECKED;
  547.                     SimpleRequest(get_ploterror());
  548.                 }
  549.                 else
  550.                     redraw = TRUE;
  551.             }
  552.             break;
  553.  
  554.         case AUTOVAL:
  555.             if (MENUAUTOVAL.Flags & CHECKED)
  556.             {
  557.                 erfolg = set_autoval(AUTOOFF);
  558.                 if (erfolg == FALSE)
  559.                 {
  560.                     MENUAUTOVAL.Flags &= ~CHECKED;
  561.                     SimpleRequest(get_ploterror());
  562.                 }
  563.             }
  564.             else
  565.             {
  566.                 erfolg = set_autoval(AUTOON);
  567.                 if (erfolg == FALSE)
  568.                 {
  569.                     MENUAUTOVAL.Flags |= CHECKED;
  570.                     SimpleRequest(get_ploterror());
  571.                 }
  572.             }
  573.             break;
  574.  
  575.         case SCTITEL:
  576.             sctitel ^= TRUE;
  577.             if (sctitel)
  578.                 SetWindowTitles(Mw,(char *)-1,ScreenNamen);
  579.             else
  580.                 SetWindowTitles(Mw,(char *)-1,NULL);
  581.             ShowTitle(Sc,sctitel);
  582.             break;
  583.  
  584.         case CROSSHATCH:
  585.             if (MENUCROSS.Flags & CHECKED)
  586.             {
  587.                 erfolg = set_3doptions(CROSHON);
  588.                 if (erfolg == FALSE)
  589.                 {
  590.                     MENUCROSS.Flags &= ~CHECKED;
  591.                     SimpleRequest(get_ploterror());
  592.                 }
  593.             }
  594.             else
  595.             {
  596.                 erfolg = set_3doptions(CROSHOFF);
  597.                 if (erfolg == FALSE)
  598.                 {
  599.                     MENUCROSS.Flags |= CHECKED;
  600.                     SimpleRequest(get_ploterror());
  601.                 }
  602.             }
  603.             break;
  604.  
  605.         case HIDDENL:
  606.             if (MENUHIDDEN.Flags & CHECKED)
  607.             {
  608.                 erfolg = set_3doptions(HIDDENON);
  609.                 if (erfolg == FALSE)
  610.                 {
  611.                     MENUHIDDEN.Flags &= ~CHECKED;
  612.                     SimpleRequest(get_ploterror());
  613.                 }
  614.             }
  615.             else
  616.             {
  617.                 erfolg = set_3doptions(HIDDENOFF);
  618.                 if (erfolg == FALSE)
  619.                 {
  620.                     MENUHIDDEN.Flags |= CHECKED;
  621.                     SimpleRequest(get_ploterror());
  622.                 }
  623.             }
  624.             break;
  625.  
  626.         case NEUZEICHNEN:
  627.             redraw = TRUE;
  628.             break;
  629.  
  630.         case AUFLOESUNG:
  631.             myprocess->pr_WindowPtr = olderrorwindow;
  632.             erfolg = Oeffne_Screen(ssmenu);
  633.             olderrorwindow = myprocess->pr_WindowPtr;
  634.             myprocess->pr_WindowPtr = (APTR)Mw;
  635.             redraw = TRUE;
  636.             break;
  637.  
  638.         case FARBENAENDERN:
  639.             ColorRequester(1L);
  640.             break;
  641.  
  642.         case FARBENLADEN:
  643.             FarbenLaden();
  644.             break;
  645.  
  646.         case FARBENSICHERN:
  647.             FarbenSichern();
  648.             break;
  649.  
  650.         default:
  651.             SimpleRequest(funktion);
  652.             break;
  653.     }
  654. }
  655.  
  656. void skala(menu)
  657. int menu;
  658. {
  659.     int axis,mes,erfolg;
  660.  
  661.     axis = menu/3;
  662.     mes = menu%3;
  663.     erfolg = set_mes(axis+1,mes+1);
  664.     if (erfolg == FALSE)
  665.         SimpleRequest(get_ploterror());
  666.     else
  667.         redraw = TRUE;
  668. }
  669.  
  670. void setnewval(smenu)
  671. {
  672.     int erfolg;
  673.     DATA value;
  674.     switch(smenu)
  675.     {
  676.         case MSTAND:
  677.             set_value(CLEAR,0.0);
  678.             setminmaxval();
  679.             break;
  680.         default:
  681.             if (GetFloat("Bitte neuen Grenzwert eingeben",&value))
  682.             {
  683.                 erfolg = set_value(smenu,value);
  684.                 if (erfolg )
  685.                     sprintf(&valtext[smenu][7],"% .4lg",value);
  686.                 else
  687.                     SimpleRequest(get_ploterror());
  688.             }
  689.             break;
  690.     }
  691. }
  692.  
  693.  
  694. int main(zahl,string)
  695. int zahl;
  696. char *string[];
  697. {
  698.     struct IntuiMessage *message;
  699.  
  700.     ULONG class;
  701.     USHORT code;
  702.     int erfolg;
  703.     int autodisp = TRUE;
  704.     int menu,smenu,ssmenu;
  705.  
  706.     if (openall() == FALSE)
  707.     {
  708.         Delay (TIME);
  709.         closeall();
  710.         exit(5);
  711.     }
  712.  
  713.     if (open_plot() == FALSE)
  714.     {
  715.         dis_ploterror();
  716.         Delay (TIME);
  717.         closeall();
  718.         exit(5);
  719.     }
  720.  
  721.     mfr.PathName = filename;
  722.     mfr.Flags = FRQINFOGADGETM|FRQLOADINGM;
  723.     mfr.dirnamescolor = 2;
  724.     myprocess = (struct Process *)FindTask((char *)0);
  725.     olderrorwindow = myprocess->pr_WindowPtr;
  726.     myprocess->pr_WindowPtr = (APTR)Mw;
  727.  
  728.     while (loop)
  729.     {
  730.         message = (struct IntuiMessage *)GetMsg(Mw->UserPort);
  731.         if (message==NULL)
  732.         {
  733.             ClearPointer(Mw);
  734.             SetMenuStrip(Mw,&Menu1);
  735.             Wait(1L << Mw->UserPort->mp_SigBit);
  736.             continue;
  737.         }
  738.         class = message->Class;
  739.         code = message->Code;
  740.         ReplyMsg((struct Message *)message);
  741.         ClearMenuStrip(Mw);
  742.         SetPointer(Mw,sprite1,POINTERHOEHE,POINTERBREITE,
  743.                                                     POINTERSPOT,POINTERSPOT);
  744.         switch (class)
  745.         {
  746.             case MENUPICK:
  747.                 if (code == MENUNULL) break;
  748.                 menu = MENUNUM(code);
  749.                 smenu = ITEMNUM(code);
  750.                 ssmenu = SUBNUM(code);
  751.                 if (menu == NOMENU) break;
  752.                 if (smenu == NOITEM) break;
  753.                 switch (menu)
  754.                 {
  755.                     case FILEMENU:
  756.                         filemenu(smenu);
  757.                         break;
  758.  
  759.                     case BESCHRIFTUNG:
  760.                         beschriftung(smenu,ssmenu);
  761.                         break;
  762.  
  763.                     case SKALA:
  764.                         skala(smenu);
  765.                         break;
  766.  
  767.                     case GRENZEN:
  768.                         setnewval(smenu);
  769.                         break;
  770.  
  771.                     case BERECHNUNG:
  772.                         funktionen(smenu);
  773.                         break;
  774.  
  775.                     case DARSTELLUNG:
  776.                         darstellung(smenu,ssmenu);
  777.                         break;
  778.  
  779.                     default:
  780.                         SimpleRequest(funktion);
  781.                         break;
  782.                 }
  783.                 break;
  784.  
  785.             default:
  786.                 SimpleRequest(funktion);
  787.                 break;
  788.         }
  789.  
  790.         if ((redraw == TRUE)&&(autodisp == TRUE))
  791.         {
  792.             erfolg = display(SCREENOUT,GRAPHSET);
  793.             redraw = FALSE;
  794.             if ((erfolg == FALSE)&&(plerr != SEQDISP))
  795.                 SimpleRequest(get_ploterror());
  796.         }
  797.     }
  798.     myprocess->pr_WindowPtr = (APTR)olderrorwindow;
  799.     close_plot();
  800.     closeall();
  801.     exit (NULL);
  802. }
  803.