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 / PlotL2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-21  |  46.7 KB  |  1,332 lines
  1. /****************************************************************
  2. *                                                                                                                                *
  3. *     Filename : PlotL2.c                                                                                    *
  4. *                                                                                                                                *
  5. *****************************************************************
  6. *                                                                                                                                *
  7. *        Comment : Level 2 von der Plotlibrary. Unterstützt die            *
  8. *                            alle Level 1 Funktionen ohne Open- und Closeplot.    *
  9. *                            Zusätzlich sind weitere Unterfunktionen dazu            *
  10. *                            gekommen wie die Liste zeigt.                                            *
  11. *                                                                                                                                *
  12. *                                Funktionen                                                        *
  13. *                            ==========                                                        *
  14. *                                                                                                                                *
  15. *                delcurve()                löscht eine bestimmte Kurve                        *
  16. *                getsize()                    berechnet die Grösse der Daten                *
  17. *                valsize()                    berechnet Anzahl Elemente                            *
  18. *                getdata()                    generiert math. Kurve                                    *
  19. *                getcurve()                alloziert Speicher für eine Kurve            *
  20. *                calcdata()                berechnet die Daten aus math. Funk.        *
  21. *                setminmax()                setzt neue Grenzen in plot                        *
  22. *                checkbound()            kontrolliert die Grenzen für != LIN        *
  23. *                deldata()                    löscht Kurve anhand id oder namen            *
  24. *                setaxisname()            gibt einer Achse einen Namen                    *
  25. *                setunit()                    setzt Achseneinheit                                        *
  26. *                settitel()                setzt Graphiktitel                                        *
  27. *                setcurvename()        setzt Kurvenname                                            *
  28. *                setstring()                kopiert und setzt einen String                *
  29. *                delstring()                löscht einen String                                        *
  30. *                setvalue()                setzt Grenzwerte                                            *
  31. *                getvalue()                holt aktuelle Grenzwerte                            *
  32. *                setautoval()            setzt auto. Grenzwertanpassung                *
  33. *                setgrid()                    setzt Gitterparameter                                    *
  34. *                setfill()                    setzt Musterparameter                                    *
  35. *                setmes()                    setzt Achsenmasstab                                        *
  36. *                set3doptions()        legt 3D Ausgabe fest                                    *
  37. *                setplotsize()            legt Plotterausgabe fest                            *
  38. *                setcurvecolor()        setzt Kurvenfarbe                                            *
  39. *                                                                                                                                *
  40. *                Rev : V1.0                                                                                            *
  41. *                                                                                                                                *
  42. *        History : V1.0 erstellen dieses Files                            15/11/89    *
  43. *                                                                                                                                *
  44. *                Doc : Plotlibrary User's Guide                                                    *
  45. *                                                                                                                                *
  46. *             Bugs : keine bekannten                                                                        *
  47. *                                                                                                                                *
  48. *            Autor : Oesch Silvano                                                                            *
  49. *                                                                                                                                *
  50. *            Datum : 15/11/89                                                                                    *
  51. *                                                                                                                                *
  52. ****************************************************************/
  53.  
  54. /****************************************************************
  55. *                                                                                                                                *
  56. *    Plotlibrary Includedateien                                                                        *
  57. *                                                                                                                                *
  58. ****************************************************************/
  59.  
  60. #include "Plot.h"
  61. #include "PlotL2.h"
  62. #include "GfxL3.h"
  63. #include "OpClL2.h"
  64.  
  65. /****************************************************************
  66. *                                                                                                                                *
  67. *    externe Variablen                                                                                            *
  68. *                                                                                                                                *
  69. ****************************************************************/
  70.  
  71. extern struct Plot *plot;
  72. extern int plerr;
  73.  
  74. /****************************************************************
  75. *                                                                                                                                *
  76. *    Function : delcurve()                                                                                    *
  77. *                                                                                                                                *
  78. *****************************************************************
  79. *                                                                                                                                *
  80. *         Input : curve                                                                                            *
  81. *                            struct Curve *curve                                                                *
  82. *                                                                                                                                *
  83. *        Output : void                                                                                                *
  84. *                                                                                                                                *
  85. *****************************************************************
  86. *                                                                                                                                *
  87. *     Comment : Loescht eine komplette Kurve aus der Liste der            *
  88. *                         der aktiven Kurven. Der allozierte Speicher wird        *
  89. *                         an das System zurückgegeben. Die Plotstruktur            *
  90. *                         wird korrigiert.                                                                        *
  91. *                                                                                                                                *
  92. ****************************************************************/
  93.  
  94. static void delcurve(curve)
  95. struct Curve *curve;
  96. {
  97.     dellist(curve);                                        /* lösche aus Liste                    */
  98.     if (curve->val)
  99.         free(curve->val);                                /* vorhandene Daten löschen    */
  100.     if (curve->titel)
  101.         free(curve->titel);                            /* vorhandener Name löschen    */
  102.     free(curve);                                            /* Speicher freigeben                */
  103.     if (plot->first == NULL)                    /* war es die  letzte ?            */
  104.     {                                                                    /* Ja                                                */
  105.         if (plot->disp != NULL)                    /* Bildschirm geöffnet ?        */
  106.             ScCloseGraphics();                        /* dann schliessen                    */
  107.         initplot();                                            /* plot initialisieren            */
  108.     }
  109.     else                                                            /* sonst                                        */
  110.         if (plot->autoval == AUTOON)        /* nur wenn gewünscht                */
  111.             setminmax();                                    /* refresh der plotstruktur    */
  112. }
  113.  
  114. /****************************************************************
  115. *                                                                                                                                *
  116. *    Function : getdata()                                                                                    *
  117. *                                                                                                                                *
  118. *****************************************************************
  119. *                                                                                                                                *
  120. *         Input : function,xmin,xmax,count                                                        *
  121. *                            (*function())            math. Berechnungsfunktion                *
  122. *                            int xmin                    Startwert                                                *
  123. *                            int xmax                    Endwert                                                    *
  124. *                            int count                    Anzahl zu berechnende Elemente    *
  125. *                                                                                                                                *
  126. *        Output : int returnset            ID der neuen Kurve                            *
  127. *                            != FALSE                    neue ID                                                    *
  128. *                            == FALSE                    Fehler                                                    *
  129. *                                                                                                                                *
  130. *****************************************************************
  131. *                                                                                                                                *
  132. *     Comment : Diese Funktion ist die zweite Stufe der Get_Data-    *
  133. *                         funktion. Es wird eine Kurve mittels einer math.        *
  134. *                         Funktion berechnet. Wenn die Funktion erfolgreich    *
  135. *                         ausgeführt werden konnte, wird die neue Kurve            *
  136. *                         zur Kurvenliste addiert. Ansonsten werden alle            *
  137. *                         angeforderten Resourcen freigegeben.                                *
  138. *                                                                                                                                *
  139. ****************************************************************/
  140.  
  141. int getdata(function,xmin,xmax,count)
  142. DATA (*function)(DATA);
  143. DATA    xmin,
  144.             xmax;
  145. int        count;
  146. {
  147.     int returnset;                                        /* Rückgabewert                            */
  148.     struct Curve *curve;                            /* Kurvenzeiger                            */
  149.  
  150.     curve = getcurve(count);                    /* alloziere Kurve count        */
  151.                                                                         /* Datenfeldern                            */
  152.     if ( curve == NULL)                                /* Fehler ?                                    */
  153.         setreturn(FALSE);                                /* Ja, zurück                                */
  154.     else                                                            /* sonst weiter                            */
  155.     {
  156.  
  157.         curve->xmin = xmin;                            /* initialisiere bestehende    */
  158.         curve->xmax = xmax;                            /* Werte, sonst müssen sie    */
  159.         curve->count = count;                        /* weiter gegeben werden        */
  160.  
  161.         calcdata(curve,function);                /* berechne Datenelemente        */
  162.         addlist(curve);                                    /* füge zur liste und hole    */
  163.                                                                         /* die ID                                        */
  164.         if (plot->autoval == AUTOON)        /* nur wenn gewünscht                */
  165.             setminmax();                                    /* Grenzen korrigieren            */
  166.         setreturn(curve->id);                        /* ID als Rückgabewert            */
  167.     }
  168.     return(returnset);
  169. }
  170.  
  171. /****************************************************************
  172. *                                                                                                                                *
  173. *    Function : getsize()                                                                                    *
  174. *                                                                                                                                *
  175. *****************************************************************
  176. *                                                                                                                                *
  177. *         Input : count                                                                                            *
  178. *                            int count            Anzahl Datenelemente in der Kurve        *
  179. *                                                                                                                                *
  180. *        Output : int size                benötigte Bytes des Datenarrays            *
  181. *                                                                                                                                *
  182. *****************************************************************
  183. *                                                                                                                                *
  184. *     Comment : Berechnet die benötigte Grösse in Bytes eines            *
  185. *                         Datenfeldes. Der eingestellte Darstellungstyp            *
  186. *                         wird berücksichtigt.                                                                *
  187. *                                                                                                                                *
  188. ****************************************************************/
  189.  
  190. int getsize(count)
  191. int count;
  192. {
  193.     return((int)(sizeof(DATA)*count*valsize()));
  194. }
  195.  
  196. /****************************************************************
  197. *                                                                                                                                *
  198. *    Function : valsize()                                                                                    *
  199. *                                                                                                                                *
  200. *****************************************************************
  201. *                                                                                                                                *
  202. *         Input : void                                                                                                *
  203. *                                                                                                                                *
  204. *        Output : int returnset    Grösse des Sizefaktors                            *
  205. *                            != FALSE            alles klar                                                    *
  206. *                            == FALSE            Fehler                                                            *
  207. *                                                                                                                                *
  208. *****************************************************************
  209. *                                                                                                                                *
  210. *     Comment : Diese Funktion Übergibt die Anzahl Datenelemente        *
  211. *                         eines Datenpaares. Der eingestellte Kurventyp            *
  212. *                         wird berücksichtigt.                                                                *
  213. *                                                                                                                                *
  214. ****************************************************************/
  215.  
  216. int valsize()
  217. {
  218.     int returnset;
  219.  
  220.     switch (plot->typ)                                    /* welcher Typ                    */
  221.     {
  222.         case D2:    setreturn(D2MULT);            /* 2 Datenfelder                */
  223.                             break;
  224.         case NIV:    setreturn(NIVMULT);            /* 2 Datenfelder                */
  225.                             break;
  226.         case D3:    setreturn(D3MULT);            /* 3 Datenfelder                */
  227.                             break;
  228.         default:    seterror (INVCURTYP);        /* kein gültiger Typ        */
  229.                             setreturn(FALSE);                /* sofort zurück                */
  230.     }
  231.     return(returnset);
  232. }
  233.  
  234. /****************************************************************
  235. *                                                                                                                                *
  236. *    Function : getcurve()                                                                                    *
  237. *                                                                                                                                *
  238. *****************************************************************
  239. *                                                                                                                                *
  240. *         Input : count                                                                                            *
  241. *                            int count                Anzahl notwendiger Datenelemente    *
  242. *                                                                                                                                *
  243. *        Output : struct Curve *        Kurvenzeiger mit Array                        *
  244. *                            * != NULL                komplette Kurve erstellt                    *
  245. *                            * == NULL                Speicherfehler oder                                *
  246. *                                                            falscher Typ in plot definiert        *
  247. *                                                                                                                                *
  248. *****************************************************************
  249. *                                                                                                                                *
  250. *     Comment : Es wird eine komplette Kurvenstruktur alloziert.        *
  251. *                         Wenn kein Speicher vorhanden für die Kurve oder         *
  252. *                         für die Daten ist, gibt es eine Fehler. Vorhandene    *
  253. *                         Resourcen werden freigegeben. Die Daten werden in    *
  254. *                         abhängigkeit des Types in der Plotstruktur                    *
  255. *                         alloziert. Es gibt einen Fehler wenn dieser Typ        *
  256. *                         nicht definiert ist.                                                                *
  257. *                         Alle Werte der Struktur sind gelöscht!                            *
  258. *                                                                                                                                *
  259. ****************************************************************/
  260.  
  261. struct Curve *getcurve(count)
  262. int count;
  263. {
  264.     int curvesize,                                        /* grösse der Kurve                    */
  265.             valsize;                                            /* Grösse des Datenfeldes        */
  266.     struct Curve *curve,                            /* Kurvenzeiger                            */
  267.                              *returnset;                    /* Rückgabewert                            */
  268.  
  269.     curvesize = sizeof(struct Curve);    /* Grösse bestimmen und         */
  270.     curve = (struct Curve *)calloc(1,curvesize);
  271.                                                                         /* Speicher holen                        */
  272.     if ( curve == FALSE)                            /* bekommen ?                                */
  273.     {                                                                    /* Nein, Fehler                            */
  274.         seterror(MEMGETDATA);
  275.         setreturn (FALSE);
  276.     }
  277.     else                                                            /* Ja, prüfe Type für                */
  278.     {                                                                    /* berechnung des Daten-        */
  279.                                                                         /* feldes                                        */
  280.         valsize = getsize(count);                /* hole Grösse                            */
  281.         if (valsize == NULL)                        /* ohne Fehler                            */
  282.             setreturn(FALSE);                            /* Nein                                            */
  283.         else
  284.         {
  285.             curve->val = (DATA *)malloc(valsize);
  286.                                                                         /* Speicher holen                        */
  287.             if (curve->val == NULL)                /* bekommen ?                                */
  288.             {                                                            /* Nein !!                                    */
  289.                 free(curve);                                /* Kurvenspeicher freigeben    */
  290.                 seterror(MEMGETDATA);                /* und Fehler setzten                */
  291.                 setreturn (FALSE);
  292.             }
  293.             else                                                    /* und sonst                                */
  294.             {
  295.                 curve->maxcount = count;
  296.                                                                         /* init. maxcount                        */
  297.                 setreturn(curve);                        /* mit Kurvenzeiger zurück    */
  298.             }
  299.         }
  300.     }
  301.     return(returnset);
  302. }
  303.  
  304. /****************************************************************
  305. *                                                                                                                                *
  306. *    Function : calcdata()                                                                                    *
  307. *                                                                                                                                *
  308. *****************************************************************
  309. *                                                                                                                                *
  310. *         Input : curve,function                                                                            *
  311. *                            struct Curve *curve        Kurvenstruktur                            *
  312. *                            DATA (*function)()        Funktionsadresse                        *
  313. *                                                                                                                                *
  314. *        Output : void                                                                                                *
  315. *                                                                                                                                *
  316. *****************************************************************
  317. *                                                                                                                                *
  318. *     Comment : Berechnet Kurvenwerte mithilfe einer                                *
  319. *                         mathematischen Funktion. Die Daten werden in ein        *
  320. *                         Array geschrieben welches schon vorbereitet ist.        *
  321. *                         Die minmaxwerte werden mit den ersten Daten                *
  322. *                         gesetzt und danach kontrolliert gesetzt.                        *
  323. *                                                                                                                                *
  324. ****************************************************************/
  325.  
  326. static void calcdata(curve,function)
  327. struct Curve *curve;
  328. DATA (*function)(DATA);
  329. {
  330.     DATA    step,                                                /* Differenz zwischen x1,x2    */
  331.                 x,                                                    /* x Werte                                    */
  332.                 y,                                                    /* y Wert                                        */
  333.                 *array=curve->val;                    /* Feldzeiger initialisiert    */
  334.     int     i,                                                    /* counter                                    */
  335.                 init=NULL;                                    /* switch initialisiert            */
  336.  
  337.     step = (curve->xmax-curve->xmin)/(curve->count-1);
  338.                                                                         /* berechne Schrittweite        */
  339.     for (i=0;i<curve->count;i++)            /* für alle Felder                    */
  340.     {
  341.         x=curve->xmin+i*step;                        /* x-Werte berechnet                */
  342.  
  343. /****************************************************************
  344. *    Dieser Wert könnte auch aufaddiert werden, die Rechnungs-            *
  345. *    fehler werden dadurch aber immer grösser. Desshalb wird                *
  346. *    x immer mit Start + step*counter berechnet.                                        *
  347. ****************************************************************/
  348.  
  349.         y=(*function)(x);                                /* berechne y                                */
  350.         *array++=x;                                            /* Schreibe Werte in Array    */
  351.         *array++=y;
  352.         if (init)                                                /* Daten schon init ?                */
  353.         {
  354.             if (curve->ymin > y)                    /* ok, nur min und max            */
  355.                 curve->ymin = y;                        /* setzten                                    */
  356.             else if (curve->ymax < y)
  357.                 curve->ymax=y;
  358.         }
  359.         else                                                        /* nein, also init. mit            */
  360.         {
  361.             curve->ymin = curve->ymax = y;
  362.                                                                         /* ersten Werten die vor-        */
  363.                                                                         /* handen.                                    */
  364.             init ++;                                            /* init switch setzten            */
  365.         }
  366.     }
  367. }
  368.  
  369. /****************************************************************
  370. *                                                                                                                                *
  371. *    Function : setminmax()                                                                                *
  372. *                                                                                                                                *
  373. *****************************************************************
  374. *                                                                                                                                *
  375. *         Input : void                                                                                                *
  376. *                                                                                                                                *
  377. *        Output : void                                                                                                *
  378. *                                                                                                                                *
  379. *****************************************************************
  380. *                                                                                                                                *
  381. *     Comment : Setzt die min - maxparameter in der Plotstruktur        *
  382. *                         anhand der minmax-Werte in den Kurvenstrukturen.        *
  383. *                         Wenn kein automatisches setzten dieser Werte                *
  384. *                         gewünscht wird, muss der autoval Parameter in der    *
  385. *                         Plotstruktur gesetzt sein welche vor dem Aufruf        *
  386. *                         dieser Funktion abgefragt werden muss.                            *
  387. *                         Der clippindikator wird gelöscht.                                    *
  388. *                                                                                                                                *
  389. ****************************************************************/
  390.  
  391. void setminmax()
  392. {
  393.     struct Curve *curve = plot->first;
  394.                                                                         /* Kurvenstruktur auf erste    */
  395.                                                                         /* Kurve initialisieren            */
  396.     if (curve)                                                /* wenn Kurve vorhanden            */
  397.     {
  398.         plot->xmin = curve->xmin;                /* Werte auf erste Kurve        */
  399.         plot->xmax = curve->xmax;                /* setzten                                    */
  400.         plot->ymin = curve->ymin;
  401.         plot->ymax = curve->ymax;
  402.         plot->zmin = curve->zmin;
  403.         plot->zmax = curve->zmax;
  404.         curve = curve->next;                        /* nächste Kurve nehmen            */
  405.     }
  406.  
  407.     while (curve != NULL)                            /* alle vorhandenen Werte        */
  408.     {                                                                    /* kontrollieren                        */
  409.         if (plot->xmin > curve->xmin)        /* vergleichen und nur            */
  410.             plot->xmin = curve->xmin;            /* schreiben wenn not-            */
  411.         if (plot->xmax < curve->xmax)        /* wendig                                        */
  412.             plot->xmax = curve->xmax;
  413.         if (plot->ymin > curve->ymin)
  414.             plot->ymin = curve->ymin;
  415.         if (plot->ymax < curve->ymax)
  416.             plot->ymax = curve->ymax;
  417.         if (plot->zmin > curve->zmin)
  418.             plot->zmin = curve->zmin;
  419.         if (plot->zmax < curve->zmax)
  420.             plot->zmax = curve->zmax;
  421.         curve = curve->next;                        /* nächste Kurve nehmen            */
  422.     }
  423.     plot->clipp = NOCLIPP;                        /* kein Clipping mehr             */
  424.                                                                         /* notwendig                                */
  425.     if (plot->xmes != LIN)                        /* wenn nicht LIN kontr.        */
  426.         checkbound(&plot->xmin);
  427.     if (plot->ymes != LIN)
  428.         checkbound(&plot->ymin);
  429.     if (plot->zmes != LIN)
  430.         checkbound(&plot->zmin);
  431.  
  432. }
  433.  
  434. /****************************************************************
  435. *                                                                                                                                *
  436. *    Function : checkbound()                                                                                *
  437. *                                                                                                                                *
  438. *****************************************************************
  439. *                                                                                                                                *
  440. *         Input : min                                                                                                *
  441. *                            DATA *min                Pointer auf ersten Wert                        *
  442. *                                                                                                                                *
  443. *        Output : void                                                                                                *
  444. *                                                                                                                                *
  445. *****************************************************************
  446. *                                                                                                                                *
  447. *     Comment : Kontrolliert die log. Grenzen    auf ihre negativen    *                                                                                                                                *
  448. *                         Werte. Wenn neg. Werte vorhanden sind, werden sie    *
  449. *                         auf 1.0 bzw. 3 Dekaden tiefer gesetzt. Für diese        *
  450. *                         Darstellung wird dann das Clipping benötigt.                *
  451. *                                                                                                                                *
  452. ****************************************************************/
  453.  
  454. static void checkbound(min)
  455. DATA *min;
  456. {
  457.     DATA *max = min+1,
  458.              maxvalue = 1.0;                        /* max. Wert                                    */
  459.  
  460.     if (*max <= 0.0)                                /* max kleiner = NULL                    */
  461.     {                                                                /* Ja                                                    */
  462.         *max = maxvalue;                            /* dann neuer Wert setzten        */
  463.         plot->clipp = CLIPP;                    /* Clipping notwendig                     */
  464.     }
  465.  
  466.     if (*min <= 0.0)                                /* min kleiner = NULL                    */
  467.     {                                                                /* Ja                                                    */
  468.         *min = *max/1000;                            /* dann neuer Wert setzten        */
  469.         plot->clipp = CLIPP;                    /* Clipping notwendig                     */
  470.     }
  471. }
  472.  
  473. /****************************************************************
  474. *                                                                                                                                *
  475. *    Function : deldata()                                                                                    *
  476. *                                                                                                                                *
  477. *****************************************************************
  478. *                                                                                                                                *
  479. *         Input : id,name                                                                                        *
  480. *                            int id                zu löschende Kurve mit ID                        *
  481. *                            char *name        zu löschende Kurve mit Name                    *
  482. *                                                                                                                                *
  483. *                                                                                                                                *
  484. *        Output : int returnset                                                                            *
  485. *                            != FALSE            alles klar                                                    *
  486. *                            == FALSE            Fehler                                                            *
  487. *                                                                                                                                *
  488. *****************************************************************
  489. *                                                                                                                                *
  490. *     Comment : Löscht eine komplette Kurve aus der Liste der            *
  491. *                         der aktiven Kurven. Die allozierte Speicher wird        *
  492. *                         an das System zurückgegeben.                                                *
  493. *                                                                                                                                *
  494. *                         Diese Funktion erfüllt 4 Optionen:                                    *
  495. *                                                                                                                                *
  496. *                            - alle Kurven löschen                                                            *
  497. *                            - letzte Kurve der Liste löschen                                    *
  498. *                            - Kurve mit ID löschen                                                        *
  499. *                            - Kurve mit Namen löschen                                                    *
  500. *                                                                                                                                *
  501. ****************************************************************/
  502.  
  503. int deldata(id,name)
  504. int id;
  505. char *name;
  506. {
  507.     int returnset;                                        /* allg. Rückgabewert                */
  508.     struct Curve *curve;                            /* Kurvenzeiger                            */
  509.  
  510.     switch (id)                                                /* welcher typ zum löschen    */
  511.     {
  512.         case DELALL:
  513.             while (plot->first != NULL)        /* solange Kurven vorhanden    */
  514.                 delcurve(plot->first);            /* gib Kurven frei                    */
  515.             setreturn(TRUE);                            /* alles ok                                    */
  516.             break;
  517.  
  518.         case DELLAST:
  519.             delcurve(plot->last);                    /* gib Kurven frei                    */
  520.             setreturn(TRUE);                            /* alles ok                                    */
  521.             break;
  522.  
  523.         case NOID:
  524.             curve = slistname(name);            /* suche Kurvenzeiger                */
  525.             if (curve == NULL)                        /* gefunden                                    */
  526.                 setreturn(FALSE);                        /* Nein Fehler                            */
  527.             else                                                    /* Ja                                                */
  528.             {
  529.                 delcurve(curve);                        /* lösche Kurve                            */
  530.                 setreturn(TRUE);                        /* alles ok                                    */
  531.             }
  532.             break;
  533.  
  534.         default:                                                /* irgend eine ID                        */
  535.             curve = slistid(id);                    /* suche Kurve                            */
  536.             if (curve == NULL)                        /* gefunden ?                                */
  537.                 setreturn(FALSE);                        /* Nein Fehler                            */
  538.             else                                                    /* und sonst                                */
  539.             {
  540.                 delcurve(curve);                        /* löschen                                    */
  541.                 setreturn(TRUE);                        /* alles ok                                    */
  542.             }
  543.             break;
  544.     }
  545.     return(returnset);
  546. }
  547.  
  548. /****************************************************************
  549. *                                                                                                                                *
  550. *    Function : setaxisname()                                                                            *
  551. *                                                                                                                                *
  552. *****************************************************************
  553. *                                                                                                                                *
  554. *         Input : axis,axisname                                                                            *
  555. *                            int axis                    Achsenid                                                *
  556. *                            char *axisname        neuer Achsenname                                *
  557. *                                                                                                                                *
  558. *        Output : int returnset                                                                            *
  559. *                            != FALSE                    alles ok                                                *
  560. *                            == FALSE                    Fehler                                                    *
  561. *                                                                                                                                *
  562. *****************************************************************
  563. *                                                                                                                                *
  564. *     Comment : Setzt oder löscht einen AXNAMLEN (definiert in            *
  565. *                         Plot.h) Zeichen grossen Titel welcher jeder                *
  566. *                         Achse gegeben werden kann.                                                    *
  567. *                         In einen temp Variable wird die Adresse des                *
  568. *                         enstrechenden Strings geladen. Danach wird die            *
  569. *                         Lösch- oder Setzfunktion aufgerufen.                                *
  570. *                                                                                                                                *
  571. ****************************************************************/
  572.  
  573. setaxisname(axis,axisname)
  574. int axis;
  575. char *axisname;
  576. {
  577.  
  578.     int returnset;                                        /* allg. Rückgabewert                */
  579.     char **temp;                                            /* Adr. von der Adresse            */
  580.                                                                         /* des Strings                            */
  581.  
  582.     switch(axis)                                            /* welche Achse                            */
  583.     {                                                                    /* entsprechende Adresse        */
  584.         case XAXIS:                                            /* des Strings                            */
  585.             temp = &plot->xname;
  586.             break;
  587.         case YAXIS:
  588.             temp = &plot->yname;
  589.             break;
  590.         case ZAXIS:
  591.             temp = &plot->zname;
  592.             break;
  593.         default:
  594.             break;
  595.     }
  596.     if (axisname == NULL)                            /* löschen ?                                */
  597.         setreturn(delstring(temp));            /* Ja                                                */
  598.     else                                                            /* sonst setzten                        */
  599.         setreturn(setstring(temp,axisname,AXNAMLEN));
  600.  
  601.     return(returnset);
  602. }
  603.  
  604. /****************************************************************
  605. *                                                                                                                                *
  606. *    Function : setunit()                                                                                    *
  607. *                                                                                                                                *
  608. *****************************************************************
  609. *                                                                                                                                *
  610. *         Input : axis,unit                                                                                    *
  611. *                            int axis                    Achsenid                                                *
  612. *                            char *unit                neuer Eiheitenname                            *
  613. *                                                                                                                                *
  614. *        Output : int returnset                                                                            *
  615. *                            != FALSE                    alles ok                                                *
  616. *                            == FALSE                    Fehler                                                    *
  617. *                                                                                                                                *
  618. *****************************************************************
  619. *                                                                                                                                *
  620. *     Comment : Setzt oder löscht einen UNITLEN (definiert in            *
  621. *                         Plot.h) Zeichen grossen Titel                                            *
  622. *                                                                                                                                *
  623. ****************************************************************/
  624.  
  625. setunit(axis,unit)
  626. int axis;
  627. char *unit;
  628. {
  629.  
  630.     int returnset;                                        /* allg. Rückgabewert                */
  631.     char **temp;                                            /* Adr. von der Adresse            */
  632.                                                                         /* des Strings                            */
  633.  
  634.     switch(axis)                                            /* welche Achse                            */
  635.     {                                                                    /* entsprechende Adresse        */
  636.         case XAXIS:                                            /* des Strings                            */
  637.             temp = &plot->xunit;
  638.             break;
  639.         case YAXIS:
  640.             temp = &plot->yunit;
  641.             break;
  642.         case ZAXIS:
  643.             temp = &plot->zunit;
  644.             break;
  645.         default:
  646.             break;
  647.     }
  648.     if (unit == NULL)                                    /* löschen ?                                */
  649.         setreturn(delstring(temp));            /* Ja                                                */
  650.     else                                                            /* sonst setzten                        */
  651.         setreturn(setstring(temp,unit,UNITLEN));
  652.  
  653.     return(returnset);
  654. }
  655.  
  656. /****************************************************************
  657. *                                                                                                                                *
  658. *    Function : settitel()                                                                                    *
  659. *                                                                                                                                *
  660. *****************************************************************
  661. *                                                                                                                                *
  662. *         Input : titel                                                                                            *
  663. *                            char *titel                neuer Graphikname                                *
  664. *                                                                                                                                *
  665. *        Output : int returnset                                                                            *
  666. *                            != FALSE                    alles ok                                                *
  667. *                            == FALSE                    Fehler                                                    *
  668. *                                                                                                                                *
  669. *****************************************************************
  670. *                                                                                                                                *
  671. *     Comment : Setzt oder löscht einen TITELLEN (definiert in            *
  672. *                         Plot.h) Zeichen grossen Titel                                            *
  673. *                                                                                                                                *
  674. ****************************************************************/
  675.  
  676. settitel(titel)
  677. char *titel;
  678. {
  679.  
  680.     int returnset;                                        /* allg. Rückgabewert                */
  681.     char **temp;                                            /* Adr. von der Adresse            */
  682.                                                                         /* des Strings                            */
  683.  
  684.     temp = &plot->titel;
  685.     if (titel == NULL)                                /* löschen ?                                */
  686.         setreturn(delstring(temp));            /* Ja                                                */
  687.     else                                                            /* sonst setzten                        */
  688.         setreturn(setstring(temp,titel,TITELLEN));
  689.  
  690.     return(returnset);
  691. }
  692.  
  693. /****************************************************************
  694. *                                                                                                                                *
  695. *    Function : setcurvename()                                                                            *
  696. *                                                                                                                                *
  697. *****************************************************************
  698. *                                                                                                                                *
  699. *         Input : id,name                                                                                        *
  700. *                            int id                id der Kurve                                                *
  701. *                            char *name        neuer Name der Kurve                                *
  702. *                                                                                                                                *
  703. *        Output : int returnset                                                                            *
  704. *                            != FALSE            alles klar                                                    *
  705. *                            == FALSE            Fehler                                                            *
  706. *                                                                                                                                *
  707. *****************************************************************
  708. *                                                                                                                                *
  709. *     Comment : Dies Funktion setzt oder löscht einen CURNAMLEN        *
  710. *                         (definiert in Plot.h) grossen Kurvennamen.                    *
  711. *                                                                                                                                *
  712. ****************************************************************/
  713.  
  714. setcurvename(id,name)
  715. int id;
  716. char *name;
  717. {
  718.     int returnset;                                        /* allg Rückgabewert                */
  719.     char **temp;                                            /* Adr. von der Adresse            */
  720.                                                                         /* des Strings                            */
  721.     struct Curve *curve;                            /* Kurvenzeiger                            */
  722.  
  723.     curve = slistid(id);                            /* suche Kurve                            */
  724.     if (curve == NULL)                                /* gefunden ?                                */
  725.         setreturn(FALSE);                                /* Nein, Fehler                            */
  726.     else
  727.     {
  728.         temp = &curve->titel;                        /* Adresse von Stringzeiger    */
  729.         if (name == NULL)                                /* löschen oder setzen ?        */
  730.             setreturn(delstring(temp));        /* löschen                                    */
  731.         else
  732.             setreturn(setstring(temp,name,CURNAMLEN));
  733.                                                                         /* setzen                                        */
  734.     }
  735.     return(returnset);
  736. }
  737.  
  738. /****************************************************************
  739. *                                                                                                                                *
  740. *    Function : setstring()                                                                                *
  741. *                                                                                                                                *
  742. *****************************************************************
  743. *                                                                                                                                *
  744. *         Input : string,name,maxlen                                                                    *
  745. *                            char **string            Zeiger auf einen Stringzeiger        *
  746. *                            char *name                Stringzeiger                                        *
  747. *                            int maxlen                max. Stringlänge                                *
  748. *                                                                                                                                *
  749. *        Output : int returnset                                                                            *
  750. *                            != FALSE                    alles klar                                            *
  751. *                            == FALSE                    Fehler                                                    *
  752. *                                                                                                                                *
  753. *****************************************************************
  754. *                                                                                                                                *
  755. *     Comment : Diese Funktion kopiert den String name und setzt        *
  756. *                         die neue Adresse an die Stelle, wohin string                *
  757. *                         zeigt. Der String name wird jedoch auf die                    *
  758. *                         maximale Länge kontrolliert.                                                *
  759. *                                                                                                                                *
  760. ****************************************************************/
  761.  
  762. static int setstring(string,name,maxlen)
  763. char **string,
  764.          *name;
  765. int maxlen;
  766. {
  767.     int returnset,                                        /* allg Rückgabewert                */
  768.             namlen;                                                /* stringlänge                            */
  769.     char *newname;                                        /* neue Speicheradresse            */
  770.  
  771.     if (*string != NULL)
  772.     {
  773.         seterror(STRALLSET);
  774.         setreturn(FALSE);
  775.     }
  776.     else
  777.     {
  778.         namlen = strlen(name);                    /* berechne Länge                        */
  779.         if (namlen > maxlen)                        /* grösser als maxlen                */
  780.         {                                                                /* Ja Fehler                                */
  781.             seterror(NAMTOBIG);
  782.             setreturn(FALSE);
  783.         }
  784.         else                                                        /* also kopiere                            */
  785.         {
  786.             newname = malloc(namlen+1);        /* länge + 1 holen                    */
  787.             if (newname == NULL)                    /* bekommen                                    */
  788.             {
  789.                 seterror(NOMEMNAM);                    /* Nein, Fehler                            */
  790.                 setreturn(FALSE);
  791.             }
  792.             else                                                    /* kopiere String                        */
  793.             {
  794.                 *string = strcpy(newname,name);
  795.                 setreturn(TRUE);                        /* alles ok                                    */
  796.             }
  797.         }
  798.     }
  799.     return(returnset);
  800. }
  801.  
  802. /****************************************************************
  803. *                                                                                                                                *
  804. *    Function : delstring()                                                                                *
  805. *                                                                                                                                *
  806. *****************************************************************
  807. *                                                                                                                                *
  808. *         Input : string                                                                                            *
  809. *                            char **string                Zeiger auf Stringzeiger                *
  810. *                                                                                                                                *
  811. *        Output : int returnset                                                                            *
  812. *                            != FALSE                        alles klar                                        *
  813. *                            == FALSE                        Fehler                                                *
  814. *                                                                                                                                *
  815. *****************************************************************
  816. *                                                                                                                                *
  817. *     Comment : Löscht einen String welcher an der Adresse string    *
  818. *                         referenziert ist.                                                                    *
  819. *                                                                                                                                *
  820. ****************************************************************/
  821.  
  822. int delstring(string)
  823. char **string;
  824. {
  825.     int returnset;                                        /* allg Rückgabewert                */
  826.  
  827.     if (*string == NULL)                            /* ist String vorhanden            */
  828.     {
  829.         seterror(NONAMGIV);                            /* Nein, Fehler                            */
  830.         setreturn(FALSE);
  831.     }
  832.     else                                    
  833.     {
  834.         free(*string);                                    /* gib Speicher frei                */
  835.         *string = NULL;                                    /* und setzte auf NULL            */
  836.         setreturn(TRUE);                                /* alles klar                                */
  837.     }
  838.     return(returnset);
  839. }
  840.  
  841. /****************************************************************
  842. *                                                                                                                                *
  843. *    Function : setvalue()                                                                                    *
  844. *                                                                                                                                *
  845. *****************************************************************
  846. *                                                                                                                                *
  847. *         Input : typ,value                                                                                    *
  848. *                            int typ                Funktionsauswahl                                        *
  849. *                            DATA value    neuer Wert                                                    *
  850. *                                                                                                                                *
  851. *        Output : int returnset                                                                            *
  852. *                            != FALSE        alles klar                                                    *
  853. *                            == FALSE            Fehler                                                            *
  854. *                                                                                                                                *
  855. *****************************************************************
  856. *                                                                                                                                *
  857. *     Comment : Diese Funktion setze oder löscht die Darstellungs-    *
  858. *                         grenzen welche vom User gewählt wurden.                        *
  859. *                         Beim setzten wird wird eine Überlappung der Werte    *
  860. *                         z.Bsp. xmin > xmax kontroliert und ein Fehler            *
  861. *                         Fehler gestzt.                                                                            *
  862. *                                                                                                                                *
  863. ****************************************************************/
  864.  
  865. int setvalue(typ,value)
  866. int typ;
  867. DATA value;
  868. {
  869.  
  870.     int returnset;                                        /* allg Rückgabewert                */
  871.     DATA *min,*max;                                        /* Adr von Datenpaar                */
  872.  
  873.     if (typ == CLEAR)                                    /* CLEAR gesetzt ?                    */
  874.     {
  875.         setminmax();                                        /* Ja, neu setzten                    */
  876.         setreturn(TRUE);                                /* alles klar                                */
  877.     }
  878.     else                                                            /* also nicht CLEAR                    */
  879.     {
  880.         switch (typ/2*2)                                /* berechne typ von min            */
  881.         {                                                                /* Weise Adr. von min zu        */
  882.             case XMIN: min = &plot->xmin;
  883.                 break;
  884.             case YMIN: min = &plot->ymin;
  885.                 break;
  886.             case ZMIN: min = &plot->zmin;
  887.                 break;
  888.         }
  889.         max = min+1;                                        /* max Daten 1 Elem höher        */
  890.  
  891. /****************************************************************
  892. *                                                                                                                                *
  893. *    Folgende Bedingung muss für ein erfolgreiches setzten der            *
  894. *    minimalen Datenwerte erfüllt sein:                                                        *
  895. *                                                                                                                                *
  896. *        -    der neue Wert darf nicht grösser sein als der gesetzte        *
  897. *            max Wert des Wertepaares.                                                                    *
  898. *                                                                                                                                *
  899. *    Wenn der neue Wert kleiner ist als der minimale Wert, so wird    *
  900. *    der Clipping indikator gesetzt. Bei der Darstellung der Kurve    *
  901. *    wird dieser Indikator getestet ob ein Clipping notwendig ist.    *
  902. *    Der Clipping Indikator wird nur in der setminmax Funktion            *
  903. *    zurückgesetzt.                                                                                                *
  904. *                                                                                                                                *
  905. *    Für die max. Werte gelten die gleichen umgekehrten                        *
  906. *    Bedingungen.                                                                                                    *
  907. *                                                                                                                                *
  908. ****************************************************************/
  909.  
  910.         switch(typ)                                            /* welcher Typ                            */
  911.         {
  912.             case XMIN:                                        /* alle min Werte                        */
  913.             case YMIN:
  914.             case ZMIN:
  915.             if (value >= *max)                        /* value grösser= als max ?    */
  916.             {                                                            /* Ja                                                */
  917.                 seterror(VALTOHIGH);                /* Fehler                                        */
  918.                 setreturn(FALSE);
  919.             }
  920.             else                                                    /* Nein                                            */
  921.             {
  922.                 if (value > *min)                        /* value grösser als min ?    */
  923.                     plot->clipp = CLIPP;            /* Ja, clippen notwendig        */
  924.                 *min = value;                                /* neuer min Wert zuweisen    */
  925.                 setreturn(TRUE);                        /* alles klar                                */
  926.             }
  927.             break;
  928.     
  929.             case XMAX:                                        /* alle max Werte                        */
  930.             case YMAX:
  931.             case ZMAX:
  932.                 if (value <= *min)                    /* value kleiner= als min ?    */
  933.             {                                                            /* Ja                                                */
  934.                     seterror(VALTOLOW);                /* Fehler                                        */
  935.                     setreturn(FALSE);
  936.                 }
  937.                 else                                                /* Nein                                            */
  938.                 {
  939.                 if (value < *max)                        /* value kleiner als max ?    */
  940.                         plot->clipp = CLIPP;        /* Ja, clippen notwendig        */
  941.                     *max = value;                            /* neuer max Wert zuweisen    */
  942.                     setreturn(TRUE);                    /* alles klar                                */
  943.                 }
  944.                 break;
  945.  
  946.             default:                                            /* falscher Parameter                */
  947.                 seterror(PARASEVAL);                /* Fehler                                        */
  948.                 setreturn(FALSE);
  949.                 break;
  950.         }
  951.     }
  952.  
  953.     return(returnset);                                /* und zurück                                */
  954. }
  955.  
  956. /****************************************************************
  957. *                                                                                                                                *
  958. *    Function : getvalue()                                                                                    *
  959. *                                                                                                                                *
  960. *****************************************************************
  961. *                                                                                                                                *
  962. *         Input : typ,value                                                                                    *
  963. *                            int typ                Funktionsauswahl                                        *
  964. *                            DATA *value   neuer Wert                                                    *
  965. *                                                                                                                                *
  966. *        Output : void                                                                                                *
  967. *                                                                                                                                *
  968. *****************************************************************
  969. *                                                                                                                                *
  970. *     Comment : Diese Funktion setzt die Variable value auf den        *
  971. *                         gewünschten aktuellen Grenzwert.                                        *
  972. *                                                                                                                                *
  973. ****************************************************************/
  974.  
  975. void getvalue(typ,value)
  976. int typ;
  977. DATA *value;
  978. {
  979.  
  980.     DATA *min,*max;                                        /* Adr von Datenpaar                */
  981.  
  982.         switch (typ/2*2)                                /* berechne typ von min            */
  983.         {                                                                /* Weise Adr. von min zu        */
  984.             case XMIN: min = &plot->xmin;
  985.                 break;
  986.             case YMIN: min = &plot->ymin;
  987.                 break;
  988.             case ZMIN: min = &plot->zmin;
  989.                 break;
  990.         }
  991.         max = min+1;                                        /* max Daten 1 Elem höher        */
  992.  
  993.         switch(typ)                                            /* welcher Typ                            */
  994.         {
  995.             case XMIN:                                        /* alle min Werte                        */
  996.             case YMIN:
  997.             case ZMIN:
  998.                 *value = *min;                            /* min Wert zuweisen                */
  999.                 break;
  1000.     
  1001.             case XMAX:                                        /* alle max Werte                        */
  1002.             case YMAX:
  1003.             case ZMAX:
  1004.                 *value = *max;                            /* max Wert zuweisen                */
  1005.                 break;
  1006.  
  1007.         }
  1008. }
  1009.  
  1010. /****************************************************************
  1011. *                                                                                                                                *
  1012. *    Function : setautoval()                                                                                *
  1013. *                                                                                                                                *
  1014. *****************************************************************
  1015. *                                                                                                                                *
  1016. *         Input : para                                                                                                *
  1017. *                            int para                Autovalparameter                                    *
  1018. *                                                                                                                                *
  1019. *        Output : void                                                                                                *
  1020. *                                                                                                                                *
  1021. *****************************************************************
  1022. *                                                                                                                                *
  1023. *     Comment : Setzt den Autovalparameter. Wenn AUTOON gesetzt        *
  1024. *                         wird, dann werden alle minimalen und maximalen            *
  1025. *                         automatisch nach jeder Lade- oder Rechenfunktion        *
  1026. *                         neu gesetzt.                                                                                *
  1027. *                                                                                                                                *
  1028. ****************************************************************/
  1029.  
  1030. void setautoval(para)
  1031. int para;
  1032. {
  1033.  
  1034.     if (para == AUTOON)                                /* Wenn AUTOON                            */
  1035.     {
  1036.         plot->autoval = AUTOON;                    /* dann setzten und                    */
  1037.         setminmax();                                        /* neue Werte berechnen            */
  1038.     }
  1039.     else                                                            /* sonst                                        */
  1040.     {
  1041.         plot->autoval = AUTOOFF;                /* AUTOOFF setzten                    */
  1042.         plot->clipp = CLIPP;                        /* Clipping notwendig                */
  1043.     }
  1044. }
  1045.  
  1046. /****************************************************************
  1047. *                                                                                                                                *
  1048. *    Function : setgrid()                                                                                    *
  1049. *                                                                                                                                *
  1050. *****************************************************************
  1051. *                                                                                                                                *
  1052. *         Input : typ                                                                                                *
  1053. *                            int typ            Gitterparameter                                                *
  1054. *                                                                                                                                *
  1055. *        Output : void                                                                                                *
  1056. *                                                                                                                                *
  1057. *****************************************************************
  1058. *                                                                                                                                *
  1059. *     Comment : Diese Funktion setzt den Gitterparameter in der        *
  1060. *                         Plotstruktur. Dieser Parameter wird erst bei der        *
  1061. *                         Ausgabe der Graphik abgefragt.                                            *
  1062. *                                                                                                                                *
  1063. ****************************************************************/
  1064.  
  1065. void setgrid(typ)
  1066. int typ;
  1067. {
  1068.  
  1069.     if (typ == GRID)                                    /* wenn es GRID ist                    */
  1070.         plot->grid = GRID;                            /* setzte GRID                            */
  1071.     else                                                            /* sonst                                        */
  1072.         plot->grid = NOGRID;                        /* setzte NOGRID                        */
  1073.  
  1074. }
  1075.  
  1076. /****************************************************************
  1077. *                                                                                                                                *
  1078. *    Function : setfill()                                                                                    *
  1079. *                                                                                                                                *
  1080. *****************************************************************
  1081. *                                                                                                                                *
  1082. *         Input : typ                                                                                                *
  1083. *                            int typ            Musterparameter                                                *
  1084. *                                                                                                                                *
  1085. *        Output : void                                                                                                *
  1086. *                                                                                                                                *
  1087. *****************************************************************
  1088. *                                                                                                                                *
  1089. *     Comment : Diese Funktion setzt den Musterparameter in der        *
  1090. *                         Plotstruktur. Dieser Parameter wird erst bei der        *
  1091. *                         Ausgabe der Graphik abgefragt.                                            *
  1092. *                                                                                                                                *
  1093. ****************************************************************/
  1094.  
  1095. void setfill(typ)
  1096. int typ;
  1097. {
  1098.  
  1099.     if (typ == STYLE)                                    /* wenn es STYLE ist                */
  1100.         plot->style = STYLE;                        /* setzte STYLE                            */
  1101.     else                                                            /* sonst                                        */
  1102.         plot->style = NOSTYLE;                    /* setzte NOSTYLE                        */
  1103.  
  1104. }
  1105.  
  1106. /****************************************************************
  1107. *                                                                                                                                *
  1108. *    Function : setmes()                                                                                        *
  1109. *                                                                                                                                *
  1110. *****************************************************************
  1111. *                                                                                                                                *
  1112. *         Input : axis,typ                                                                                        *
  1113. *                            int axis            Achsenidentifikation                                *
  1114. *                            int typ                Masstabparameter                                        *
  1115. *                                                                                                                                *
  1116. *        Output : int returnset    allg Rückgabewert                                        *
  1117. *                            != FALSE        alles klar                                                    *
  1118. *                            == FALSE            Fehler                                                            *
  1119. *                                                                                                                                *
  1120. *****************************************************************
  1121. *                                                                                                                                *
  1122. *     Comment : Diese Funktion setzt bei der axis den                            *
  1123. *                         angegebenen typ. Dieser typ wird erst bei dem            *
  1124. *                         Aufbau der Ausgabe abgefragt. Für die LOG oder LN    *
  1125. *                         Darstellung sind Werte kleiner gleich NULL                 *
  1126. *                         erlaubt. Sie werden jedoch bei der Darstellung            *
  1127. *                         abgeschnitten. Der minimale Wert wird auf 0.1            *
  1128. *                         gesetzt wenn er <= NULL ist. Wenn der maximale         *
  1129. *                         auch <= NULL ist, wird dieser auf 1 gesetzt. Diese    *
  1130. *                         können nachträglich verändert werden.                            *
  1131. *                                                                                                                                *
  1132. ****************************************************************/
  1133.  
  1134. int setmes(axis,typ)
  1135. int axis;
  1136. int typ;
  1137. {
  1138.  
  1139.     DATA *min;
  1140.  
  1141.     switch(axis)                                            /* welche Achse                            */
  1142.     {
  1143.         case XAXIS:                                            /* x - Achse                                */
  1144.             plot->xmes = typ;                            /* setzte typ                                */
  1145.             min = &plot->xmin;
  1146.             break;
  1147.         case YAXIS:                                            /* y - Achse                                */
  1148.             plot->ymes = typ;                            /* setzte typ                                */
  1149.             min = &plot->ymin;
  1150.             break;
  1151.         case ZAXIS:                                            /* z - Achse                                */
  1152.             plot->zmes = typ;                            /* setzte typ                                */
  1153.             min = &plot->zmin;
  1154.             break;
  1155.     }
  1156.  
  1157.     if (typ != LIN)                                        /* wenn nicht LIN                        */
  1158.         checkbound(min);                                /* auf jedenfall Grenzen        */
  1159.                                                                         /* kontrollieren                        */
  1160.     else if (plot->autoval == AUTOON)    /* oder wenn autoval                */
  1161.         setminmax();                                        /* kontr. Grenzen                        */
  1162.     return(TRUE);
  1163. }
  1164.  
  1165. /****************************************************************
  1166. *                                                                                                                                *
  1167. *    Function : set3doptions()                                                                            *
  1168. *                                                                                                                                *
  1169. *****************************************************************
  1170. *                                                                                                                                *
  1171. *         Input : typ                                                                                                *
  1172. *                            int typ                Darstellungsparameter                                *
  1173. *                                                                                                                                *
  1174. *        Output : int returnset    allg Rückgabewert                                        *
  1175. *                            != FALSE        alles klar                                                    *
  1176. *                            == FALSE            Fehler                                                            *
  1177. *                                                                                                                                *
  1178. *****************************************************************
  1179. *                                                                                                                                *
  1180. *     Comment : Diese Funktion setzt für die 3D Darstellung                *
  1181. *                         das Crosshatching und die Hiddenlines.                            *
  1182. *                                                                                                                                *
  1183. ****************************************************************/
  1184.  
  1185. int set3doptions(typ)
  1186. int typ;
  1187. {
  1188.  
  1189.     int returnset = TRUE;
  1190.  
  1191.     if (typ & CROSHON)                                /* Crosshatching ein            */
  1192.     {
  1193.         plot->d3opt |= CROSH;
  1194.         typ &= ~CROSHON;
  1195.     }
  1196.     else if (typ & CROSHOFF)                    /* Crosshatching aus            */
  1197.     {
  1198.         plot->d3opt &= ~CROSH;
  1199.         typ &= ~CROSHOFF;
  1200.     }
  1201.  
  1202.     if (typ & HIDDENON)                                /* Hiddenline ein                    */
  1203.     {
  1204.         plot->d3opt |= HIDDEN;
  1205.         typ &= ~HIDDENON;
  1206.     }
  1207.     else if (typ & HIDDENOFF)                    /* Hiddenline aus                    */
  1208.     {
  1209.         plot->d3opt &= ~HIDDEN;
  1210.         typ &= ~HIDDENOFF;
  1211.     }
  1212.     if (typ)                                                    /* Optionen vorhanden            */
  1213.     {                                                                    /* Ja, Fehler                            */
  1214.         setreturn(FALSE);
  1215.         seterror(PARA3DOPT);
  1216.     }
  1217.     return(returnset);
  1218.  
  1219. }
  1220.  
  1221. /****************************************************************
  1222. *                                                                                                                                *
  1223. *    Function : setcurvecolor()                                                                        *
  1224. *                                                                                                                                *
  1225. *****************************************************************
  1226. *                                                                                                                                *
  1227. *         Input : id,name,color                                                                            *
  1228. *                            int id                id der gesuchten Kurve                            *
  1229. *                            char *name        name der gesuchten Kurve                        *
  1230. *                            int color            Farbe der Kurve                                            *
  1231. *                                                                                                                                *
  1232. *        Output : int returnset                                                                            *
  1233. *                            != FALSE        alle klar                                                        *
  1234. *                            == FALSE            Fehler                                                            *
  1235. *                                                                                                                                *
  1236. *****************************************************************
  1237. *                                                                                                                                *
  1238. *     Comment : Diese Funktion setzt bei einer Kurve eine                    *
  1239. *                         bestimmte Farbe.                                                                        *
  1240. *                                                                                                                                *
  1241. ****************************************************************/
  1242.  
  1243. int setcurvecolor(id,name,color)
  1244. int id;
  1245. char *name;
  1246. int color;
  1247. {
  1248.  
  1249.     int returnset;                                        /* allg Rückgabewert                */
  1250.     struct Curve *curve;                            /* Kurvenzeiger                            */
  1251.  
  1252.         if (id == NOID)                                    /* keine ID, also Namen            */
  1253.         {
  1254.             curve = slistname(name);            /* suche Kurvenzeiger                */
  1255.             if (curve == NULL)                        /* gefunden                                    */
  1256.                 setreturn(FALSE);                        /* Nein Fehler                            */
  1257.             else                                                    /* Ja                                                */
  1258.             {
  1259.                 curve->color = color;                /* setzte Farbe                            */
  1260.                 setreturn(TRUE);                        /* alles ok                                    */
  1261.             }
  1262.         }
  1263.         else
  1264.         {
  1265.             curve = slistid(id);                    /* suche Kurve                            */
  1266.             if (curve == NULL)                        /* gefunden ?                                */
  1267.                 setreturn(FALSE);                        /* Nein Fehler                            */
  1268.             else                                                    /* und sonst                                */
  1269.             {
  1270.                 curve->color = color;                /* setzte Farbe                            */
  1271.                 setreturn(TRUE);                        /* alles ok                                    */
  1272.             }
  1273.         }
  1274.     return(returnset);                                /* und zurück                                */
  1275. }
  1276.  
  1277. /****************************************************************
  1278. *                                                                                                                                *
  1279. *    Function : setplotsize()                                                                            *
  1280. *                                                                                                                                *
  1281. *****************************************************************
  1282. *                                                                                                                                *
  1283. *         Input : x,y,xsize,ysize,attr,name                                                    *
  1284. *                            int x                        Start von rechten Rand                        *
  1285. *                            int y                        Start von oberem Rand                            *
  1286. *                            int xsize                Länge der Ausgabe                                    *
  1287. *                            int ysize                Höhe der Ausgabe                                    *
  1288. *                            int attr                Ausgabeattribute                                    *
  1289. *                            char *name            Ausgabedatei                                            *
  1290. *                                                                                                                                *
  1291. *        Output : int returnset                                                                            *
  1292. *                            != FALSE                 alle klar                                                    *
  1293. *                            == FALSE                Fehler                                                        *
  1294. *                                                                                                                                *
  1295. *****************************************************************
  1296. *                                                                                                                                *
  1297. *     Comment : Diese Funktion setzt alle Paremter für die Ausgabe    *
  1298. *                         einer Graphik auf einen Plotter. Der Name wird wie    *
  1299. *                         normal kopiert und gesetzt. Die Abfrage dieser            *
  1300. *                         Parameter wird erst im Level 3 bei der Plotausgabe    *
  1301. *                         gemacht.                                                                                        *
  1302. *                                                                                                                                *
  1303. ****************************************************************/
  1304.  
  1305. int setplotsize(x,y,xsize,ysize,attr,name)
  1306. int x,
  1307.         y,
  1308.         xsize,
  1309.         ysize,
  1310.         attr;
  1311. char *name;
  1312. {
  1313.  
  1314.     int returnset;                                        /* allg. Rückgabewert                */
  1315.  
  1316.     plot->xout = x;                                        /* Start rechter Rand                */
  1317.     plot->yout = y;                                        /* Start oberer Rand                */
  1318.     plot->xlength = xsize;                        /* Länge                                        */
  1319.     plot->ylength = ysize;                        /* Höhe                                            */
  1320.     plot->pldisp = attr;                            /* Plotterattribute                    */
  1321.     if (name)                                                    /* Nur wenn name gegeben        */
  1322.     {
  1323.         if (plot->outname)                            /* Wenn name vorhanden dann    */
  1324.             delstring(&plot->outname);        /* dann löschen                            */
  1325.         setreturn(setstring(&plot->outname,name,80));
  1326.     }                                                                    /* und name setzten                    */
  1327.     if (returnset)
  1328.         plot->pldisp |= PLDATASET;            /* Daten gesetzt                        */
  1329.     return(returnset);
  1330. }
  1331.  
  1332.