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 / PlotL1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-21  |  53.0 KB  |  1,461 lines

  1. /****************************************************************
  2. *                                                                                                                                *
  3. *     Filename : PlotL1.c                                                                                    *
  4. *                                                                                                                                *
  5. *****************************************************************
  6. *                                                                                                                                *
  7. *        Comment : Dieses File ist die erste Stufe der Plotlibrary.    *
  8. *                            Hier sind alle für den Programmierer sichtbaren        *
  9. *                            Funktionen enthalten.                                                            *
  10. *                            Die Dokumentation der einzelnen Funktionen ist        *
  11. *                            im User Manual enthalten.                                                    *
  12. *                                                                                                                                *
  13. *                                Funktionen                                                        *
  14. *                            ==========                                                        *
  15. *                                                                                                                                *
  16. *            Open_Plot()                oeffnet die Plotlibrary                                    *
  17. *            Close_Plot()            schliesst die Plotlibrary                                *
  18. *            Get_Data()                generiert eine neue Kurve                                *
  19. *            Load_Data()                holt Daten von File für eine neue Kurve    *
  20. *            Del_Data()                löschen bestimmter Daten                                *
  21. *            Set_Axisname()        setzt/löscht Achsenname                                    *
  22. *            Set_Unit()                setzt/löscht Achseneinheit                            *
  23. *            Set_Titel()                setzt/löscht Graphiktitel                                *
  24. *            Set_Curvename()        setzt/löscht Kurvenname                                    *
  25. *            Set_Value()                setzt/löscht Darstellungsgrenzen                *
  26. *            Get_Value()                holt aktuelle Darstellungsgrenzen                *
  27. *            Set_Autoval()            setzt/löscht Autominmaxparamter                    *
  28. *            Set_Grid()                setzt/löscht Gitterdarstellung                    *
  29. *            Set_Fill()                setzt/löscht Füllmuster bei Niveau            *
  30. *            Set_Mes()                    setzt Achsensmasstab                                        *
  31. *            Set_Curvecolor()    setzt Kurvenfarbe                                                *
  32. *            Set_3DOptions()        definiert die 3D Ausgabe                                *
  33. *            Set_PlotSize()        definiert die Plotterausgabe                        *
  34. *            Display()                    stellt alle Daten dar                                        *
  35. *                                                                                                                                *
  36. *                Rev : V1.0                                                                                            *
  37. *                                                                                                                                *
  38. *        History : V1.0 erstellen dieses Files                            15/11/89    *
  39. *                                                                                                                                *
  40. *                Doc : Plotlibrary User's Guide                                                    *
  41. *                                                                                                                                *
  42. *             Bugs : keine bekannten                                                                        *
  43. *                                                                                                                                *
  44. *            Autor : Oesch Silvano                                                                            *
  45. *                                                                                                                                *
  46. *            Datum : 15/11/89                                                                                    *
  47. *                                                                                                                                *
  48. ****************************************************************/
  49.  
  50.  
  51. /****************************************************************
  52. *                                                                                                                                *
  53. *    Plotlibrary Includedateien                                                                        *
  54. *                                                                                                                                *
  55. ****************************************************************/
  56.  
  57. #include "Plot.h"
  58. #include "PlotL2.h"
  59. #include "OpClL2.h"
  60. #include "LoadL2.h"
  61. #include "DispL2.h"
  62.  
  63.  
  64. /****************************************************************
  65. *                                                                                                                                *
  66. *    externe Variablen                                                                                            *
  67. *                                                                                                                                *
  68. ****************************************************************/
  69.  
  70. extern struct Plot *plot;
  71. extern int plerr;
  72.  
  73.  
  74. /****************************************************************
  75. *                                                                                                                                *
  76. *    Function : Open_Plot()                                                                                *
  77. *                                                                                                                                *
  78. *****************************************************************
  79. *                                                                                                                                *
  80. *         Input : void                                                                                                *
  81. *                                                                                                                                *
  82. *        Output : int returnset                                                                            *
  83. *                            != FALSE            keine Fehler                                                *
  84. *                            == FALSE            Fehler aufgetreten                                    *
  85. *                                                                                                                                *
  86. *****************************************************************
  87. *                                                                                                                                *
  88. *     Comment : Oeffnet die Plotlibrary und alloziert die Plot-        *
  89. *                         struktur. Es werden alle Defaultwerte eingestellt.    *
  90. *                                                                                                                                *
  91. *         Error : - Sequence error                                                                        *
  92. *                         - memory allocation failed in create_plot                    *
  93. *                                                                                                                                *
  94. *             Rev : V1.0                                                                                                *
  95. *                                                                                                                                *
  96. *     History : V1.0 erstellen dieses Files                            15/11/89    *
  97. *                                                                                                                                *
  98. *             Doc : Plotlibrary User's Guide                                                        *
  99. *                                                                                                                                *
  100. *          Bugs : keine bekannten                                                                        *
  101. *                                                                                                                                *
  102. *         Autor : Oesch Silvano                                                                            *
  103. *                                                                                                                                *
  104. *         Datum : 15/11/89                                                                                        *
  105. *                                                                                                                                *
  106. ****************************************************************/
  107.  
  108. int open_plot()
  109. {
  110.     int returnset;                                        /* Rückgabewert                            */
  111.  
  112.     if (plot)                                                    /* schon gesetzt ?                    */
  113.     {
  114.         seterror(SEQOPPLOT);                        /* Error                                        */
  115.         setreturn(FALSE);
  116.     }
  117.     else
  118.         setreturn(createplot());                /* Speicher holen und             */
  119.     return (returnset);                                /* als Rückgabewert setzten    */
  120. }
  121.  
  122.  
  123. /****************************************************************
  124. *                                                                                                                                *
  125. *    Function : Close_Plot()                                                                                *
  126. *                                                                                                                                *
  127. *****************************************************************
  128. *                                                                                                                                *
  129. *         Input : void                                                                                                *
  130. *                                                                                                                                *
  131. *        Output : int returnset                                                                            *
  132. *                            != FALSE            keine Fehler                                                *
  133. *                            == FALSE            Fehler aufgetreten                                    *
  134. *                                                                                                                                *
  135. *****************************************************************
  136. *                                                                                                                                *
  137. *     Comment : Gibt den gesammten angeforderten Speicher an das        *
  138. *                         System zurück.                                                                            *
  139. *                         Alle Kurvendaten sowie die entsprechenden                    *
  140. *                         Strukturen werden aufgehoben.                                            *
  141. *                         Als letzte wird die Plotstruktur zurück gegeben.        *
  142. *                                                                                                                                *
  143. *      Errors : - sequence error                                                                        *
  144. *                                                                                                                                *
  145. *             Rev : V1.0                                                                                                *
  146. *                                                                                                                                *
  147. *     History : V1.0 erstellen dieses Files                            15/11/89    *
  148. *                                                                                                                                *
  149. *             Doc : Plotlibrary User's Guide                                                        *
  150. *                                                                                                                                *
  151. *          Bugs : keine bekannten                                                                        *
  152. *                                                                                                                                *
  153. *         Autor : Oesch Silvano                                                                            *
  154. *                                                                                                                                *
  155. *         Datum : 15/11/89                                                                                        *
  156. *                                                                                                                                *
  157. ****************************************************************/
  158.  
  159. int close_plot()
  160. {
  161.     int returnset;                                        /* Rückgabewert                            */
  162.  
  163.     if (plot == NULL)                                    /* schon gesetzt ?                    */
  164.     {                                                                    /* Nein                                            */
  165.         seterror(SEQCLOSE);                            /* Error                                        */
  166.         setreturn(FALSE);
  167.     }
  168.     else
  169.     {
  170.         closeplot();                                        /* alles schliessen und         */
  171.         setreturn (TRUE);                                /* Rückgabewert setzten            */
  172.     }
  173.     return (returnset);
  174. }
  175.  
  176.  
  177. /****************************************************************
  178. *                                                                                                                                *
  179. *    Function : get_data()                                                                                    *
  180. *                                                                                                                                *
  181. *****************************************************************
  182. *                                                                                                                                *
  183. *         Input : function,xmin,xmax,count                                                        *
  184. *                            DATA (*function)()    Funktionspointer                            *
  185. *                            DATA xmin                        x-Startwert                                        *
  186. *                            DATA xmax                        x-Endwert                                            *
  187. *                            int     count                    Anzahl Elemente                                *
  188. *                                                                                                                                *
  189. *        Output : int returnset                                                                            *
  190. *                            != FALSE            id der neu generierten Kurve                *
  191. *                            FALSE                    Fehler aufgetreten                                    *
  192. *                                                                                                                                *
  193. *****************************************************************
  194. *                                                                                                                                *
  195. *     Comment : Generiert eine neue Kurve anhand einer math.                *
  196. *                         Funktion und addiert sie zu der bestehenden                *
  197. *                         Liste. Wenn die Funktion erfolgreich ausgeführt        *
  198. *                         wurde, ist der Rückgabewert die ID der Kurve                *
  199. *                         ansonsten wird er auf FALSE gesetzt.                                *
  200. *                                                                                                                                *
  201. *      Errors : - Sequence error                                                                        *
  202. *                         - Parameter failure                                                                *
  203. *                         - Memory allocation failure                                                *
  204. *                         - invalid curve typ set in plotstructur                        *
  205. *                                                                                                                                *
  206. *             Rev : V1.0                                                                                                *
  207. *                                                                                                                                *
  208. *     History : V1.0 erstellen dieses Files                            16/11/89    *
  209. *                                                                                                                                *
  210. *             Doc : Plotlibrary User's Guide                                                        *
  211. *                                                                                                                                *
  212. *          Bugs : keine bekannten                                                                        *
  213. *                                                                                                                                *
  214. *         Autor : Oesch Silvano                                                                            *
  215. *                                                                                                                                *
  216. *         Datum : 16/11/89                                                                                        *
  217. *                                                                                                                                *
  218. ****************************************************************/
  219.  
  220. int get_data(function,xmin,xmax,count)
  221. DATA (*function)(DATA);
  222. DATA    xmin,
  223.             xmax;
  224. int        count;
  225. {
  226.     int returnset;                                        /* Rückgabewert                            */
  227.  
  228.     if (plot == NULL)                                    /* schon gesetzt ?                    */
  229.     {                                                                    /* Nein                                            */
  230.         seterror(SEQGEDATA);                        /* Error                                        */
  231.         setreturn(FALSE);
  232.     }
  233.     else                                                            /* Parameter kontrolle            */
  234.         if ((function == NULL) or                /* keine Funktion                        */
  235.                 ((xmax - xmin) <= NULL) or    /* keine pos. Differenz            */
  236.                 (count <= 1))                                /* min 2 Pkt zu berechnen        */
  237.         {
  238.             seterror(PARAGEDATA);                    /* dann Parameterfehler            */
  239.             setreturn(FALSE);
  240.         }
  241.         else                                                        /* alles ok                                    */
  242.             if (plot->typ != D2)                    /* Nur 2D Daten                            */
  243.             {
  244.                 seterror(INVTYPGDATA);
  245.                 setreturn(FALSE);
  246.             }
  247.             else                                                    /* getdata Level 2 rufen        */
  248.                                                                         /* mit ID als rückgabe            */
  249.                 setreturn(getdata(function,xmin,xmax,count));
  250.     return(returnset);
  251. }
  252.  
  253.  
  254. /****************************************************************
  255. *                                                                                                                                *
  256. *    Function : load_data()                                                                                *
  257. *                                                                                                                                *
  258. *****************************************************************
  259. *                                                                                                                                *
  260. *         Input : file,typ                                                                                        *
  261. *                            char *file        Datenfilename                                                *
  262. *                            int  typ            optionaler Darstellungstyp                    *
  263. *                                                                                                                                *
  264. *        Output : int returnset                                                                            *
  265. *                            != FALSE            id der neu Kurve oder alles ok            *
  266. *                            FALSE                    Fehler aufgetreten                                    *
  267. *                                                                                                                                *
  268. *****************************************************************
  269. *                                                                                                                                *
  270. *     Comment : Die angegebene Datei wird geladen. Ein Vergleich        *
  271. *                         zwischen typ und der Datei wird gemacht und ent-        *
  272. *                         sprechend gehandelt. Je nach typ werden                         *
  273. *                         verschiedene Kurven generiert ( NIVEAU ) oder auch    *
  274. *                         nur einzelne. Der Typ ist optional.                                *
  275. *                                                                                                                                *
  276. *                         Die folgenden Parameter sind in Plotlib.h                    *
  277. *                         definiert:                                                                                    *
  278. *                                                                                                                                *
  279. *                                NOTYP    ->    keine Typenprüfung,es wird der Typ        *
  280. *                                                    aus dem File genommen                                    *
  281. *                                D2        ->    2D Darstellung                                                *
  282. *                                NIV        ->    Niveau Darstellung                                        *
  283. *                                D3        ->    3D Darstellung                                                *
  284. *                                                                                                                                *
  285. *      Errors : - Sequence error                                                                        *
  286. *                         - Parameter failure                                                                *
  287. *                         - more curve not allowed for this typ                            *
  288. *                         - Memory allocation failure in getcurve()                    *
  289. *                         - file not found                                                                        *
  290. *                         - file is empty                                                                        *
  291. *                         - invalid file typ                                                                    *
  292. *                         - invalid datas                                                                        *
  293. *                         - reallocation failed                                                            *
  294. *                                                                                                                                *
  295. *             Rev : V1.0                                                                                                *
  296. *                                                                                                                                *
  297. *     History : V1.0 erstellen dieses Files                            21/11/89    *
  298. *                                                                                                                                *
  299. *             Doc : Plotlibrary User's Guide                                                        *
  300. *                                                                                                                                *
  301. *          Bugs : keine bekannten                                                                        *
  302. *                                                                                                                                *
  303. *         Autor : Oesch Silvano                                                                            *
  304. *                                                                                                                                *
  305. *         Datum : 21/11/89                                                                                        *
  306. *                                                                                                                                *
  307. ****************************************************************/
  308.  
  309. int load_data(file,typ)
  310. char *file;
  311. int typ;
  312. {
  313.     int returnset;                                        /* Rückgabewert                            */
  314.  
  315.     if (plot == NULL)                                    /* schon gesetzt ?                    */
  316.     {                                                                    /* Nein                                            */
  317.         seterror(SEQLODATA);                        /* Error                                        */
  318.         setreturn(FALSE);
  319.     }
  320.     else                                                            /* Parameter kontrolle            */
  321.         if ((file == NULL) or                        /* kein Filename                        */
  322.                 (typ < NOTYP) or                        /* typ not in range                    */
  323.                 (typ > D3))
  324.         {
  325.             seterror(PARAGEDATA);                    /* dann Parameterfehler            */
  326.             setreturn(FALSE);
  327.         }
  328.         else                                                        /* check ob mehrere Kurven    */
  329.             if ((plot->first != NULL) and    /* von diesem typ geladen        */
  330.                     ((plot->typ == NIV) or        /* werden dürfen                        */
  331.                      (plot->typ == D3)))            /* NIV und 3D dürfen nicht    */
  332.             {                                                            /* überlagert werden !            */
  333.                 seterror(MORENOTALL);                /* Fehler                                        */
  334.                 setreturn(FALSE);
  335.             }
  336.             else                                                    /* sonst alles ok, laden        */
  337.                 setreturn(loaddata(file,typ));
  338.     return(returnset);
  339. }
  340.  
  341.  
  342. /****************************************************************
  343. *                                                                                                                                *
  344. *    Function : del_data()                                                                                    *
  345. *                                                                                                                                *
  346. *****************************************************************
  347. *                                                                                                                                *
  348. *         Input : id,name                                                                                        *
  349. *                            int id            id der zu löschenden Kurve                        *
  350. *                            char *name    name der zu löschenden Kurve                    *
  351. *                                                                                                                                *
  352. *        Output : int returnset                                                                            *
  353. *                            != FALSE            alles klar Kurve(n) gelöscht                *
  354. *                            FALSE                    Fehler aufgetreten                                    *
  355. *                                                                                                                                *
  356. *****************************************************************
  357. *                                                                                                                                *
  358. *     Comment : Diese Funktion löscht bestimmte Daten aus dem            *
  359. *                         Speicher. Es können so überlagerte Kurven                    *
  360. *                         selektiv wieder gelöscht werden.                                        *
  361. *                         Es darf nur ein Parameter gesetzt sein. Entweder        *
  362. *                         ID oder Name.                                                                            *
  363. *                                                                                                                                *
  364. *                         Die folgenden Parameter sind in Plotlib.h                    *
  365. *                         definiert:                                                                                    *
  366. *                                                                                                                                *
  367. *                            DELALL        ->    löscht alle Daten im Speicher                *
  368. *                            DELLAST        ->    löscht die letzte Kurve                            *
  369. *                            NOID            ->    keine id aber Namen gegeben                    *
  370. *                                                                                                                                *
  371. *      Errors : - sequence error                                                                        *
  372. *                         - parameter failure                                                                *
  373. *                         - curve not found in slist...                                            *
  374. *                                                                                                                                *
  375. *             Rev : V1.0                                                                                                *
  376. *                                                                                                                                *
  377. *     History : V1.0 erstellen dieses Files                            26/11/89    *
  378. *                                                                                                                                *
  379. *             Doc : Plotlibrary User's Guide                                                        *
  380. *                                                                                                                                *
  381. *          Bugs : keine bekannten                                                                        *
  382. *                                                                                                                                *
  383. *         Autor : Oesch Silvano                                                                            *
  384. *                                                                                                                                *
  385. *         Datum : 26/11/89                                                                                        *
  386. *                                                                                                                                *
  387. ****************************************************************/
  388.  
  389. int del_data(id,name)
  390. int id;
  391. char *name;
  392. {
  393.     int returnset;
  394.  
  395.     if ((plot == NULL) or                            /* plot gesetzt und                 */
  396.             (plot->first == NULL))                /* Daten vorhanden ?                */
  397.     {                                                                    /* Nein                                            */
  398.         seterror(SEQDEDATA);                        /* Error                                        */
  399.         setreturn(FALSE);
  400.     }
  401.     else                                                            /* Parameter kontrolle            */
  402.         if (((id == NOID) and                        /* Nur 1 Parameter darf            */
  403.                  (name == NULL)) or                    /* gesetzt sein                            */
  404.                 ((id != NOID) and
  405.                     (name != NULL)))
  406.         {                                                                /* keiner oder mehrere sind    */
  407.             seterror(PARADEDATA);                    /* gesetzt. Fehler                    */
  408.             setreturn(FALSE);
  409.         }
  410.         else                                                        /* alles klar                                */
  411.             setreturn(deldata(id,name));    /* lösche Kurve                            */
  412.  
  413.     return(returnset);
  414. }
  415.  
  416.  
  417. /****************************************************************
  418. *                                                                                                                                *
  419. *    Function : set_axisname()                                                                            *
  420. *                                                                                                                                *
  421. *****************************************************************
  422. *                                                                                                                                *
  423. *         Input : axis,axisname                                                                            *
  424. *                            int axis                Achsenparameter                                        *
  425. *                            char *axisname    Name der Achse                                        *
  426. *                                                                                                                                *
  427. *        Output : int returnset                                                                            *
  428. *                            != FALSE            alle klar                                                    *
  429. *                            == FALSE                Fehler                                                        *
  430. *                                                                                                                                *
  431. *****************************************************************
  432. *                                                                                                                                *
  433. *     Comment : Diese Funktion setzt/löscht die verschiedenen            *
  434. *                         Achsennamen. Für die 2D-Darstellung ist der                *
  435. *                         Z-Parameter nicht erlaubt.                                                    *
  436. *                                                                                                                                *
  437. *                         Die folgenden Parameter sind in Plotlib.h                    *
  438. *                         definiert:                                                                                    *
  439. *                                                                                                                                *
  440. *                            XAXIS        ->    x-Achse                                                                *
  441. *                            YAXIS        ->    y-Achse                                                                *
  442. *                            ZAXIS        ->    z-Achse                                                                *
  443. *                                                                                                                                *
  444. *      Errors : - sequence error                                                                        *
  445. *                         - parameter failure                                                                *
  446. *                         - name not allowed for this typ                                        *
  447. *                         - string already set                                                                *
  448. *                         - name to big                                                                            *
  449. *                         - memory allocation failure                                                *
  450. *                         - no name given                                                                        *
  451. *                                                                                                                                *
  452. *             Rev : V1.0                                                                                                *
  453. *                                                                                                                                *
  454. *     History : V1.0 erstellen dieses Files                            29/11/89    *
  455. *                                                                                                                                *
  456. *             Doc : Plotlibrary User's Guide                                                        *
  457. *                                                                                                                                *
  458. *          Bugs : keine bekannten                                                                        *
  459. *                                                                                                                                *
  460. *         Autor : Oesch Silvano                                                                            *
  461. *                                                                                                                                *
  462. *         Datum : 29/11/89                                                                                        *
  463. *                                                                                                                                *
  464. ****************************************************************/
  465.  
  466. int set_axisname(axis,axisname)
  467. int axis;
  468. char *axisname;
  469. {
  470.  
  471.     int returnset;
  472.  
  473.     if (plot == NULL)                                    /* plot gesetzt ?                        */
  474.     {                                                                    /* Nein                                            */
  475.         seterror(SEQAXNAME);                        /* Error                                        */
  476.         setreturn(FALSE);
  477.     }
  478.     else                                                            /* Parameter kontrolle            */
  479.         if ((axis < XAXIS) or                        /* Achsenrange                            */
  480.                 (axis > ZAXIS))
  481.         {                                                                /* NOK ?                                        */
  482.             seterror(PARAXNAME);                    /* Fehler                                        */
  483.             setreturn(FALSE);
  484.         }
  485.         else
  486.             if ((plot->typ == D2) and            /* 2D und Z ?                                */
  487.                     (axis == ZAXIS))
  488.             {                                                            /* Ja Fehler                                */
  489.                 seterror(NONAMETYP);
  490.                 setreturn(FALSE);
  491.             }
  492.             else                                                    /* alles ok setzten                    */
  493.                 setreturn(setaxisname(axis,axisname));
  494.  
  495.     return(returnset);
  496. }
  497.  
  498.  
  499. /****************************************************************
  500. *                                                                                                                                *
  501. *    Function : set_unit()                                                                                    *
  502. *                                                                                                                                *
  503. *****************************************************************
  504. *                                                                                                                                *
  505. *         Input : axis,unit                                                                                    *
  506. *                            int axis                Achsenparameter                                        *
  507. *                            char *unit            Einheit der Achse                                    *
  508. *                                                                                                                                *
  509. *        Output : int returnset                                                                            *
  510. *                            != FALSE            alle klar                                                    *
  511. *                            == FALSE                Fehler                                                        *
  512. *                                                                                                                                *
  513. *****************************************************************
  514. *                                                                                                                                *
  515. *     Comment : Diese Funktion setzt/löscht die verschiedenen            *
  516. *                         Achseneiheiten. Für die 2D-Darstellung ist der            *
  517. *                         Z-Parameter nicht erlaubt.                                                    *
  518. *                                                                                                                                *
  519. *                         Die folgenden Parameter sind in Plotlib.h                    *
  520. *                         definiert:                                                                                    *
  521. *                                                                                                                                *
  522. *                            XAXIS        ->    x-Achse                                                                *
  523. *                            YAXIS        ->    y-Achse                                                                *
  524. *                            ZAXIS        ->    z-Achse                                                                *
  525. *                                                                                                                                *
  526. *      Errors : - sequence error                                                                        *
  527. *                         - parameter failure                                                                *
  528. *                         - name not allowed for this typ                                        *
  529. *                         - string already set                                                                *
  530. *                         - name to big                                                                            *
  531. *                         - memory allocation failure                                                *
  532. *                         - no name given                                                                        *
  533. *                                                                                                                                *
  534. *             Rev : V1.0                                                                                                *
  535. *                                                                                                                                *
  536. *     History : V1.0 erstellen dieses Files                            30/11/89    *
  537. *                                                                                                                                *
  538. *             Doc : Plotlibrary User's Guide                                                        *
  539. *                                                                                                                                *
  540. *          Bugs : keine bekannten                                                                        *
  541. *                                                                                                                                *
  542. *         Autor : Oesch Silvano                                                                            *
  543. *                                                                                                                                *
  544. *         Datum : 30/11/89                                                                                        *
  545. *                                                                                                                                *
  546. ****************************************************************/
  547.  
  548. int set_unit(axis,unit)
  549. int axis;
  550. char *unit;
  551. {
  552.  
  553.     int returnset;
  554.  
  555.     if (plot == NULL)                                    /* plot gesetzt ?                        */
  556.     {                                                                    /* Nein                                            */
  557.         seterror(SEQSEUNI);                            /* Error                                        */
  558.         setreturn(FALSE);
  559.     }
  560.     else                                                            /* Parameter kontrolle            */
  561.         if ((axis < XAXIS) or                        /* Achsenrange                            */
  562.                 (axis > ZAXIS))
  563.         {                                                                /* NOK ?                                        */
  564.             seterror(PARASEUNI);                    /* Fehler                                        */
  565.             setreturn(FALSE);
  566.         }
  567.         else
  568.             if ((plot->typ == D2) and            /* 2D und Z ?                                */
  569.                     (axis == ZAXIS))
  570.             {                                                            /* Ja Fehler                                */
  571.                 seterror(NONAMETYP);
  572.                 setreturn(FALSE);
  573.             }
  574.             else                                                    /* alles ok setzten                    */
  575.                 setreturn(setunit(axis,unit));
  576.  
  577.     return(returnset);
  578. }
  579.  
  580.  
  581. /****************************************************************
  582. *                                                                                                                                *
  583. *    Function : set_titel()                                                                                *
  584. *                                                                                                                                *
  585. *****************************************************************
  586. *                                                                                                                                *
  587. *         Input : titel                                                                                            *
  588. *                            char *titel            Titel der Graphik                                    *
  589. *                                                                                                                                *
  590. *        Output : int returnset                                                                            *
  591. *                            != FALSE            alle klar                                                    *
  592. *                            == FALSE                Fehler                                                        *
  593. *                                                                                                                                *
  594. *****************************************************************
  595. *                                                                                                                                *
  596. *     Comment : Diese Funktion setzt/löscht den Graphiktitel.            *
  597. *                                                                                                                                *
  598. *      Errors : - sequence error                                                                        *
  599. *                         - string already set                                                                *
  600. *                         - name to big                                                                            *
  601. *                         - memory allocation failure                                                *
  602. *                         - no name given                                                                        *
  603. *                                                                                                                                *
  604. *             Rev : V1.0                                                                                                *
  605. *                                                                                                                                *
  606. *     History : V1.0 erstellen dieses Files                            30/11/89    *
  607. *                                                                                                                                *
  608. *             Doc : Plotlibrary User's Guide                                                        *
  609. *                                                                                                                                *
  610. *          Bugs : keine bekannten                                                                        *
  611. *                                                                                                                                *
  612. *         Autor : Oesch Silvano                                                                            *
  613. *                                                                                                                                *
  614. *         Datum : 30/11/89                                                                                        *
  615. *                                                                                                                                *
  616. ****************************************************************/
  617.  
  618. int set_titel(titel)
  619. char *titel;
  620. {
  621.  
  622.     int returnset;
  623.  
  624.     if (plot == NULL)                                    /* plot gesetzt ?                        */
  625.     {                                                                    /* Nein                                            */
  626.         seterror(SEQSEUNI);                            /* Error                                        */
  627.         setreturn(FALSE);
  628.     }
  629.     else                                                            /* go Level 2                                */
  630.         setreturn(settitel(titel));
  631.  
  632.     return(returnset);
  633. }
  634.  
  635.  
  636. /****************************************************************
  637. *                                                                                                                                *
  638. *    Function : set_curvename()                                                                        *
  639. *                                                                                                                                *
  640. *****************************************************************
  641. *                                                                                                                                *
  642. *         Input : id,name                                                                                        *
  643. *                            int id                    id der Kurve                                            *
  644. *                            char *name            Name der Kurve                                        *
  645. *                                                                                                                                *
  646. *        Output : int returnset                                                                            *
  647. *                            != FALSE            alle klar                                                    *
  648. *                            == FALSE                Fehler                                                        *
  649. *                                                                                                                                *
  650. *****************************************************************
  651. *                                                                                                                                *
  652. *     Comment : Diese Funktion setzt/löscht den Namen einer Kurve    *
  653. *                                                                                                                                *
  654. *      Errors : - sequence error                                                                        *
  655. *                         - parameter failure                                                                *
  656. *                         - curve not found                                                                    *
  657. *                         - string already set                                                                *
  658. *                         - name to big                                                                            *
  659. *                         - memory allocation failure                                                *
  660. *                         - no name given                                                                        *
  661. *                                                                                                                                *
  662. *             Rev : V1.0                                                                                                *
  663. *                                                                                                                                *
  664. *     History : V1.0 erstellen dieses Files                            01/12/89    *
  665. *                                                                                                                                *
  666. *             Doc : Plotlibrary User's Guide                                                        *
  667. *                                                                                                                                *
  668. *          Bugs : keine bekannten                                                                        *
  669. *                                                                                                                                *
  670. *         Autor : Oesch Silvano                                                                            *
  671. *                                                                                                                                *
  672. *         Datum : 01/12/89                                                                                        *
  673. *                                                                                                                                *
  674. ****************************************************************/
  675.  
  676. int set_curvename(id,name)
  677. int id;
  678. char *name;
  679. {
  680.  
  681.     int returnset;
  682.  
  683.     if ((plot == NULL) or                            /* plot gesetzt ?                        */
  684.             (plot->first == NULL))                /* Daten vorhanden ?                */
  685.     {                                                                    /* Nein                                            */
  686.         seterror(SEQCURNAM);                        /* Error                                        */
  687.         setreturn(FALSE);
  688.     }
  689.     else                                                            /* Parameter Fehler ?                */
  690.         if (id == NULL)
  691.         {
  692.             seterror(PARACURNAM);                    /* Ja, setzte Fehler                */
  693.             setreturn(FALSE);
  694.         }
  695.         else                                                        /* go Level 2                                */
  696.             setreturn(setcurvename(id,name));
  697.  
  698.     return(returnset);
  699. }
  700.  
  701. /****************************************************************
  702. *                                                                                                                                *
  703. *    Function : set_value()                                                                                *
  704. *                                                                                                                                *
  705. *****************************************************************
  706. *                                                                                                                                *
  707. *         Input : typ,value                                                                                    *
  708. *                            int typ                    Funktionsauswahl siehe unten            *
  709. *                            DATA value        neuer Wert                                                *
  710. *                                                                                                                                *
  711. *        Output : int returnset                                                                            *
  712. *                            != FALSE            alle klar                                                    *
  713. *                            == FALSE                Fehler                                                        *
  714. *                                                                                                                                *
  715. *****************************************************************
  716. *                                                                                                                                *
  717. *     Comment : Diese Funktion setzt oder löscht Darstellungs-            *
  718. *                         grenzen von den verschiedenen Achsen. Es kann            *
  719. *                         immer nur ein Wert der spez.    Achse gesetz werden.    *
  720. *                         Wenn die Löschfunktion gewählt wurde, werden                *
  721. *                         die entsprechenden Werte aller Kurven geholt                *
  722. *                         und neu gesetzt.                                                                        *
  723. *                                                                                                                                *
  724. *                         Die folgenden Übergabeparamter sind in Plotlib.h        *
  725. *                         definiert:                                                                                    *
  726. *                                                                                                                                *
  727. *                                XMIN,XMAX    -> X-Achsen Grenzwerte                                *
  728. *                                YMIN,YMAX    -> X-Achsen Grenzwerte                                *
  729. *                                ZMIN,ZMAX    -> X-Achsen Grenzwerte                                *
  730. *                                CLEAR            -> Grenzwerte neu berechnen                        *
  731. *                                                                                                                                *
  732. *      Errors : - sequence error                                                                        *
  733. *                         - parameter failure                                                                *
  734. *                         - value not allowed for this typ                                        *
  735. *                         - value higher then maxvalue                                                *
  736. *                         - value lower then minvalue                                                *
  737. *                                                                                                                                *
  738. *             Rev : V1.0                                                                                                *
  739. *                                                                                                                                *
  740. *     History : V1.0 erstellen dieses Files                            02/12/89    *
  741. *                                                                                                                                *
  742. *             Doc : Plotlibrary User's Guide                                                        *
  743. *                                                                                                                                *
  744. *          Bugs : keine bekannten                                                                        *
  745. *                                                                                                                                *
  746. *         Autor : Oesch Silvano                                                                            *
  747. *                                                                                                                                *
  748. *         Datum : 02/12/89                                                                                        *
  749. *                                                                                                                                *
  750. ****************************************************************/
  751.  
  752. int set_value(typ,value)
  753. int typ;
  754. DATA value;
  755. {
  756.  
  757.     int returnset;                                        /* allg Rückgabewert                */
  758.  
  759.     if (plot == NULL)                                    /* plot gesetzt ?                        */
  760.     {                                                                    /* Nein                                            */
  761.         seterror(SEQSEVAL);                            /* Error                                        */
  762.         setreturn(FALSE);
  763.     }
  764.     else                                                            /* Parameter im Bereich ?        */
  765.         if ((typ < CLEAR) or
  766.                 (typ > ZMAX))
  767.         {
  768.             seterror(PARASEVAL);                    /* Nein,  Fehler                        */
  769.             setreturn(FALSE);
  770.         }
  771.         else                                                        /* go Level 2                                */
  772.             setreturn(setvalue(typ,value));
  773.  
  774.     return(returnset);
  775. }
  776.  
  777.  
  778. /****************************************************************
  779. *                                                                                                                                *
  780. *    Function : get_value()                                                                                *
  781. *                                                                                                                                *
  782. *****************************************************************
  783. *                                                                                                                                *
  784. *         Input : typ                                                                                                *
  785. *                            int typ                    Funktionsauswahl siehe unten            *
  786. *                            DATA *value        Zeiger auf Grenzwertvariable            *
  787. *                                                                                                                                *
  788. *        Output : int returnset                                                                            *
  789. *                            != FALSE            alle klar                                                    *
  790. *                            == FALSE                Fehler                                                        *
  791. *                                                                                                                                *
  792. *****************************************************************
  793. *                                                                                                                                *
  794. *     Comment : Diese Funktion holt die aktuelle Darstellungs-            *
  795. *                         grenze von der spezifizierten Achse. Es kann                *
  796. *                         immer nur ein Wert abgefragt werden.                                *
  797. *                                                                                                                                *
  798. *                         Die folgenden Übergabeparamter sind in Plotlib.h        *
  799. *                         definiert:                                                                                    *
  800. *                                                                                                                                *
  801. *                                XMIN,XMAX    -> X-Achsen Grenzwerte                                *
  802. *                                YMIN,YMAX    -> X-Achsen Grenzwerte                                *
  803. *                                ZMIN,ZMAX    -> X-Achsen Grenzwerte                                *
  804. *                                                                                                                                *
  805. *      Errors : - sequence error                                                                        *
  806. *                         - parameter failure                                                                *
  807. *                                                                                                                                *
  808. *             Rev : V1.0                                                                                                *
  809. *                                                                                                                                *
  810. *     History : V1.0 erstellen dieses Files                            02/12/89    *
  811. *                                                                                                                                *
  812. *             Doc : Plotlibrary User's Guide                                                        *
  813. *                                                                                                                                *
  814. *          Bugs : keine bekannten                                                                        *
  815. *                                                                                                                                *
  816. *         Autor : Oesch Silvano                                                                            *
  817. *                                                                                                                                *
  818. *         Datum : 02/12/89                                                                                        *
  819. *                                                                                                                                *
  820. ****************************************************************/
  821.  
  822. int get_value(typ,value)
  823. int typ;
  824. DATA *value;
  825. {
  826.  
  827.     int returnset;                                        /* allg Rückgabewert                */
  828.  
  829.     if (plot == NULL)                                    /* plot gesetzt und                 */
  830.     {                                                                    /* Nein                                            */
  831.         seterror(SEQGEVAL);                            /* Error                                        */
  832.         setreturn(FALSE);
  833.     }
  834.     else                                                            /* Parameter im Bereich ?        */
  835.         if ((typ < XMIN) or
  836.                 (typ > ZMAX))
  837.         {
  838.             seterror(PARAGEVAL);                    /* Nein,  Fehler                        */
  839.             setreturn(FALSE);
  840.         }
  841.         else
  842.         {
  843.             getvalue(typ,value);
  844.             setreturn(TRUE);
  845.         }
  846.     return(returnset);
  847. }
  848.  
  849.  
  850. /****************************************************************
  851. *                                                                                                                                *
  852. *    Function : set_autoval()                                                                            *
  853. *                                                                                                                                *
  854. *****************************************************************
  855. *                                                                                                                                *
  856. *         Input : para                                                                                                *
  857. *                            int para                Autoparameter siehe unten                    *
  858. *                                                                                                                                *
  859. *        Output : int returnset                                                                            *
  860. *                            != FALSE            alle klar                                                    *
  861. *                            == FALSE                Fehler                                                        *
  862. *                                                                                                                                *
  863. *****************************************************************
  864. *                                                                                                                                *
  865. *     Comment : Diese Funktion setzt den Autoparameter in der            *
  866. *                         Plotstruktur. Mit diesem Parameter wird                        *
  867. *                         festgelegt, ob die Grenzwerte der Plotstruktur            *
  868. *                         automatisch nach jedem addieren oder löschen                *
  869. *                         einer Kurve berechnet werden.                                            *
  870. *                                                                                                                                *
  871. *                         Die folgenden Parameter sind in Plotlib.h                    *
  872. *                         definiert:                                                                                    *
  873. *                                                                                                                                *
  874. *                                AUTOON    -> automatisches berechnen ein                    *
  875. *                                AUTOOFF    -> automatisches berechnen aus                    *
  876. *                                                                                                                                *
  877. *                         Wenn diese Funktion mit AUTOON aufgerufen wird,        *
  878. *                         werden die Werte sogleich angepasst.                                *
  879. *                                                                                                                                *
  880. *      Errors : - sequence error                                                                        *
  881. *                         - parameter failure                                                                *
  882. *                                                                                                                                *
  883. *             Rev : V1.0                                                                                                *
  884. *                                                                                                                                *
  885. *     History : V1.0 erstellen dieses Files                            03/12/89    *
  886. *                                                                                                                                *
  887. *             Doc : Plotlibrary User's Guide                                                        *
  888. *                                                                                                                                *
  889. *          Bugs : keine bekannten                                                                        *
  890. *                                                                                                                                *
  891. *         Autor : Oesch Silvano                                                                            *
  892. *                                                                                                                                *
  893. *         Datum : 03/12/89                                                                                        *
  894. *                                                                                                                                *
  895. ****************************************************************/
  896.  
  897. int set_autoval(para)
  898. int para;
  899. {
  900.  
  901.     int returnset;                                        /* allg Rückgabewert                */
  902.  
  903.     if (plot == NULL)                                    /* plot gesetzt                         */
  904.     {                                                                    /* Nein                                            */
  905.         seterror(SEQAUVAL);                            /* Error                                        */
  906.         setreturn(FALSE);
  907.     }
  908.     else                                                            /* Parameter im Bereich ?        */
  909.         if ((para < AUTOON) or
  910.                 (para > AUTOOFF))
  911.         {
  912.             seterror(PARAAUVAL);                    /* Nein,  Fehler                        */
  913.             setreturn(FALSE);
  914.         }
  915.         else
  916.         {
  917.             setautoval(para);                            /* go to Level 2                        */
  918.             setreturn(TRUE);                            /* kein Rückgabewert also        */
  919.         }                                                                /* TRUE setzten                            */
  920.     return(returnset);
  921. }
  922.  
  923.  
  924. /****************************************************************
  925. *                                                                                                                                *
  926. *    Function : set_Grid()                                                                                    *
  927. *                                                                                                                                *
  928. *****************************************************************
  929. *                                                                                                                                *
  930. *         Input : typ                                                                                                *
  931. *                            int typ                    Gitterparameter                                        *
  932. *                                                                                                                                *
  933. *        Output : int returnset                                                                            *
  934. *                            != FALSE               alle klar                                                    *
  935. *                            == FALSE                Fehler                                                        *
  936. *                                                                                                                                *
  937. *****************************************************************
  938. *                                                                                                                                *
  939. *     Comment : Diese Funktion setzt den Gitterparameter                        *
  940. *                         entsprechend dem typ. Wenn dieser Parameter                *
  941. *                         gesetzt ist (GRID), wird auf der Ausgabe ein                *
  942. *                         Gitter dargestellt.                                                                *
  943. *                                                                                                                                *
  944. *                         Die folgenden Parameter sind in Plotlib.h                    *
  945. *                         definiert:                                                                                    *
  946. *                                                                                                                                *
  947. *                                GRID        -> Darstellung mit Gitter                                *
  948. *                                NOGRID    -> Darstellung ohne Gitter                            *
  949. *                                                                                                                                *
  950. *      Errors : - sequence error                                                                        *
  951. *                         - parameter failure                                                                *
  952. *                                                                                                                                *
  953. *             Rev : V1.0                                                                                                *
  954. *                                                                                                                                *
  955. *     History : V1.0 erstellen dieses Files                            03/12/89    *
  956. *                                                                                                                                *
  957. *             Doc : Plotlibrary User's Guide                                                        *
  958. *                                                                                                                                *
  959. *          Bugs : keine bekannten                                                                        *
  960. *                                                                                                                                *
  961. *         Autor : Oesch Silvano                                                                            *
  962. *                                                                                                                                *
  963. *         Datum : 03/12/89                                                                                        *
  964. *                                                                                                                                *
  965. ****************************************************************/
  966.  
  967. int set_grid(typ)
  968. int typ;
  969. {
  970.  
  971.     int returnset;                                        /* allg Rückgabewert                */
  972.  
  973.     if (plot == NULL)                                    /* plot gesetzt                         */
  974.     {                                                                    /* Nein                                            */
  975.         seterror(SEQSEGRID);                        /* Error                                        */
  976.         setreturn(FALSE);
  977.     }
  978.     else                                                            /* Parameter im Bereich ?        */
  979.         if ((typ < GRID) or
  980.                 (typ > NOGRID))
  981.         {
  982.             seterror(PARASEGRID);                    /* Nein,  Fehler                        */
  983.             setreturn(FALSE);
  984.         }
  985.         else
  986.         {
  987.             setgrid(typ);                                    /* go to Level 2                        */
  988.             setreturn(TRUE);                            /* kein Rückgabewert also        */
  989.         }                                                                /* TRUE setzten                            */
  990.     return(returnset);
  991. }
  992.  
  993. /****************************************************************
  994. *                                                                                                                                *
  995. *    Function : Set_Fill()                                                                                    *
  996. *                                                                                                                                *
  997. *****************************************************************
  998. *                                                                                                                                *
  999. *         Input : typ                                                                                                *
  1000. *                            int typ                    Musterparameter                                        *
  1001. *                                                                                                                                *
  1002. *        Output : int returnset                                                                            *
  1003. *                            != FALSE               alle klar                                                    *
  1004. *                            == FALSE                Fehler                                                        *
  1005. *                                                                                                                                *
  1006. *****************************************************************
  1007. *                                                                                                                                *
  1008. *     Comment : Diese Funktion setzt das Muster entsprechend                *
  1009. *                         entsprechend dem typ. Wenn dieser Parameter                *
  1010. *                         gesetzt ist (STYLE), wird auf der Ausgabe einer        *
  1011. *                         Niveaukurve die Kurve ausgefüllt.                                    *
  1012. *                                                                                                                                *
  1013. *                         Die folgenden Parameter sind in Plotlib.h                    *
  1014. *                         definiert:                                                                                    *
  1015. *                                                                                                                                *
  1016. *                                STYLE        -> Darstellung mit Muster                                *
  1017. *                                NOSTYLE    -> Darstellung ohne Muster                            *
  1018. *                                                                                                                                *
  1019. *      Errors : - sequence error                                                                        *
  1020. *                         - parameter failure                                                                *
  1021. *                                                                                                                                *
  1022. *             Rev : V1.0                                                                                                *
  1023. *                                                                                                                                *
  1024. *     History : V1.0 erstellen dieses Files                            04/01/90    *
  1025. *                                                                                                                                *
  1026. *             Doc : Plotlibrary User's Guide                                                        *
  1027. *                                                                                                                                *
  1028. *          Bugs : keine bekannten                                                                        *
  1029. *                                                                                                                                *
  1030. *         Autor : Oesch Silvano                                                                            *
  1031. *                                                                                                                                *
  1032. *         Datum : 04/01/90                                                                                        *
  1033. *                                                                                                                                *
  1034. ****************************************************************/
  1035.  
  1036. int set_fill(typ)
  1037. int typ;
  1038. {
  1039.  
  1040.     int returnset;                                        /* allg Rückgabewert                */
  1041.  
  1042.     if (plot == NULL)                                    /* plot gesetzt                         */
  1043.     {                                                                    /* Nein                                            */
  1044.         seterror(SEQSEFILL);                        /* Error                                        */
  1045.         setreturn(FALSE);
  1046.     }
  1047.     else                                                            /* Parameter im Bereich ?        */
  1048.         if ((typ < NOSTYLE) or
  1049.                 (typ > STYLE))
  1050.         {
  1051.             seterror(PARASEFILL);                    /* Nein,  Fehler                        */
  1052.             setreturn(FALSE);
  1053.         }
  1054.         else
  1055.         {
  1056.             setfill(typ);                                    /* go to Level 2                        */
  1057.             setreturn(TRUE);                            /* kein Rückgabewert also        */
  1058.         }                                                                /* TRUE setzten                            */
  1059.     return(returnset);
  1060. }
  1061.  
  1062. /****************************************************************
  1063. *                                                                                                                                *
  1064. *    Function : set_mes()                                                                                    *
  1065. *                                                                                                                                *
  1066. *****************************************************************
  1067. *                                                                                                                                *
  1068. *         Input : axis,unit                                                                                    *
  1069. *                            int axis                zu setzende Achse                                    *
  1070. *                            int unit                neue Skalierung                                        *
  1071. *                                                                                                                                *
  1072. *        Output : int returnset                                                                            *
  1073. *                            != FALSE                 alle klar                                                    *
  1074. *                            == FALSE                Fehler                                                        *
  1075. *                                                                                                                                *
  1076. *****************************************************************
  1077. *                                                                                                                                *
  1078. *     Comment : Diese Funktion legt die Skalierung einer Achse            *
  1079. *                         fest.                                                                                            *
  1080. *                                                                                                                                *
  1081. *                         Die folgenden Parameter sind in Plotlib.h                    *
  1082. *                         definiert:                                                                                    *
  1083. *                                                                                                                                *
  1084. *                            XAXIS        ->    x-Achse                                                                *
  1085. *                            YAXIS        ->    y-Achse                                                                *
  1086. *                            ZAXIS        ->    z-Achse                                                                *
  1087. *                                                                                                                                *
  1088. *                            LIN            ->    lineare Darstellung                                        *
  1089. *                            LOG            ->    logarithmische Darstellung                        *
  1090. *                            LN            ->    natürlich logarithmische Darstellung    *
  1091. *                                                                                                                                *
  1092. *      Errors : - sequence error                                                                        *
  1093. *                         - parameter failure                                                                *
  1094. *                                                                                                                                *
  1095. *             Rev : V1.0                                                                                                *
  1096. *                                                                                                                                *
  1097. *     History : V1.0 erstellen dieses Files                            04/12/89    *
  1098. *                                                                                                                                *
  1099. *             Doc : Plotlibrary User's Guide                                                        *
  1100. *                                                                                                                                *
  1101. *          Bugs : keine bekannten                                                                        *
  1102. *                                                                                                                                *
  1103. *         Autor : Oesch Silvano                                                                            *
  1104. *                                                                                                                                *
  1105. *         Datum : 04/12/89                                                                                        *
  1106. *                                                                                                                                *
  1107. ****************************************************************/
  1108.  
  1109. int set_mes(axis,typ)
  1110. int axis;
  1111. int typ;
  1112. {
  1113.  
  1114.     int returnset;
  1115.  
  1116.     if (plot == NULL)                                    /* plot gesetzt                         */
  1117.     {                                                                    /* Nein                                            */
  1118.         seterror(SEQSEMES);                            /* Error                                        */
  1119.         setreturn(FALSE);
  1120.     }
  1121.     else                                                            /* Parameter im Bereich ?        */
  1122.         if ((axis < XAXIS) or
  1123.                 (axis > ZAXIS) or
  1124.                 (typ < LIN) or
  1125.                 (typ > LN))
  1126.         {
  1127.             seterror(PARASEMES);                    /* Nein,  Fehler                        */
  1128.             setreturn(FALSE);
  1129.         }
  1130.         else
  1131.             if ((plot->typ == D2) and            /* 2D Darstellung und Z         */
  1132.                     (axis == ZAXIS))                    /* definiert ?                            */
  1133.             {                                                            /* Ja Fehler                                */
  1134.                 seterror(NONAMETYP);
  1135.                 setreturn(FALSE);
  1136.             }
  1137.             else                                                    /* go Level 2                                */
  1138.                 setreturn(setmes(axis,typ));
  1139.     return(returnset);
  1140. }
  1141.  
  1142.  
  1143. /****************************************************************
  1144. *                                                                                                                                *
  1145. *    Function : set_curvecolor()                                                                        *
  1146. *                                                                                                                                *
  1147. *****************************************************************
  1148. *                                                                                                                                *
  1149. *         Input : id,name,color                                                                            *
  1150. *                            int id                    id der Kurve                                            *
  1151. *                            char *name            name der Kurve                                        *
  1152. *                            int color                Farbe der Kurve                                        *
  1153. *                                                                                                                                *
  1154. *        Output : int returnset                                                                            *
  1155. *                            != FALSE                 alle klar                                                    *
  1156. *                            == FALSE                Fehler                                                        *
  1157. *                                                                                                                                *
  1158. *****************************************************************
  1159. *                                                                                                                                *
  1160. *     Comment : Die Funktion set_curvecolor weist einer Kurve eine    *
  1161. *                         bestimmte Farbe zu. Die Kurve wird dann in dieser    *
  1162. *                         Farbe beim Bildaufbau gezeichnet. Bei einer                *
  1163. *                         Ausgabe auf ein einfarbiges Gerät wird dieser Wert    *
  1164. *                         für die Musteridentifikation verwendet.                        *
  1165. *                         ACHTUNG: Der Paramter für die Farbe wird erst in        *
  1166. *                         der Display Funktion kontrolliert. Es kann                    *
  1167. *                         deshalb vorkommen, dass nicht die gewählte Farbe        *
  1168. *                         dargestellt wird.                                                                    *
  1169. *                                                                                                                                *
  1170. *                         Die folgenden Parameter sind in Plotlib.h                    *
  1171. *                         definiert:                                                                                    *
  1172. *                                                                                                                                *
  1173. *                                NOID        -> keine ID sondern Namen gegeben                *
  1174. *                                COLDET    -> Farbe detection                                            *
  1175. *                                                                                                                                *
  1176. *      Errors : - sequence error                                                                        *
  1177. *                         - parameter failure                                                                *
  1178. *                         - curve not found                                                                    *
  1179. *                                                                                                                                *
  1180. *             Rev : V1.0                                                                                                *
  1181. *                                                                                                                                *
  1182. *     History : V1.0 erstellen dieses Files                            04/12/89    *
  1183. *                                                                                                                                *
  1184. *             Doc : Plotlibrary User's Guide                                                        *
  1185. *                                                                                                                                *
  1186. *          Bugs : keine bekannten                                                                        *
  1187. *                                                                                                                                *
  1188. *         Autor : Oesch Silvano                                                                            *
  1189. *                                                                                                                                *
  1190. *         Datum : 04/12/89                                                                                        *
  1191. *                                                                                                                                *
  1192. ****************************************************************/
  1193.  
  1194. int set_curvecolor(id,name,color)
  1195. int id;
  1196. char *name;
  1197. int color;
  1198. {
  1199.  
  1200.     int returnset;                                        /* allg Rückgabewert                */
  1201.  
  1202.     if ((plot == NULL) or                            /* plot gesetzt und                 */
  1203.             (plot->first == NULL))                /* Daten vorhanden ?                */
  1204.     {                                                                    /* Nein                                            */
  1205.         seterror(SEQCURCOL);                        /* Error                                        */
  1206.         setreturn(FALSE);
  1207.     }
  1208.     else                                                            /* Parameter kontrolle            */
  1209.         if (((id == NOID) and                        /* Nur 1 Parameter darf            */
  1210.                  (name == NULL)) or                    /* gesetzt sein                            */
  1211.                 ((id != NOID) and
  1212.                     (name != NULL)))
  1213.         {                                                                /* keiner oder mehrere sind    */
  1214.             seterror(PARADEDATA);                    /* gesetzt. Fehler                    */
  1215.             setreturn(FALSE);
  1216.         }
  1217.         else
  1218.             setreturn(setcurvecolor(id,name,color));
  1219.     return(returnset);
  1220. }
  1221.  
  1222. /****************************************************************
  1223. *                                                                                                                                *
  1224. *    Function : Set_3DOptions()                                                                        *
  1225. *                                                                                                                                *
  1226. *****************************************************************
  1227. *                                                                                                                                *
  1228. *         Input : typ                                                                                                *
  1229. *                            int typ                    Options                                                        *
  1230. *                                                                                                                                *
  1231. *        Output : int returnset                                                                            *
  1232. *                            != FALSE               alle klar                                                    *
  1233. *                            == FALSE                Fehler                                                        *
  1234. *                                                                                                                                *
  1235. *****************************************************************
  1236. *                                                                                                                                *
  1237. *     Comment : Diese Funktion setzt die 3D Ausgabe mit den                *
  1238. *                         gewünschten Parametern. Es können so die Ver-            *
  1239. *                         netzung der Oberfläche sowie die versteckten                *
  1240. *                         Linien ein- und ausgeschalten werden.                            *
  1241. *                                                                                                                                *
  1242. *                         Die folgenden Parameter sind in Plotlib.h                    *
  1243. *                         definiert:                                                                                    *
  1244. *                                                                                                                                *
  1245. *                            CROSHON        -> Darstellung mit Vernetzung                        *
  1246. *                            CROSHOFF    -> Darstellung ohne Vernetzung                    *
  1247. *                            HIDDENON    -> Darstellung mit versteckten Linien        *
  1248. *                            HIDDENOFF    -> Darstellung ohne versteckten Linien    *
  1249. *                                                                                                                                *
  1250. *      Errors : - sequence error                                                                        *
  1251. *                         - parameter failure                                                                *
  1252. *                                                                                                                                *
  1253. *             Rev : V1.0                                                                                                *
  1254. *                                                                                                                                *
  1255. *     History : V1.0 erstellen dieses Files                            04/02/90    *
  1256. *                                                                                                                                *
  1257. *             Doc : Plotlibrary User's Guide                                                        *
  1258. *                                                                                                                                *
  1259. *          Bugs : keine bekannten                                                                        *
  1260. *                                                                                                                                *
  1261. *         Autor : Oesch Silvano                                                                            *
  1262. *                                                                                                                                *
  1263. *         Datum : 04/01/90                                                                                        *
  1264. *                                                                                                                                *
  1265. ****************************************************************/
  1266.  
  1267. int set_3doptions(typ)
  1268. int typ;
  1269. {
  1270.  
  1271.     int returnset;                                        /* allg Rückgabewert                */
  1272.  
  1273.     if (plot == NULL)                                    /* plot gesetzt                         */
  1274.     {                                                                    /* Nein                                            */
  1275.         seterror(SEQ3DOPT);                            /* Error                                        */
  1276.         setreturn(FALSE);
  1277.     }
  1278.     else
  1279.         setreturn(set3doptions(typ));        /* go to Level 2                        */
  1280.     return(returnset);
  1281. }
  1282.  
  1283. /****************************************************************
  1284. *                                                                                                                                *
  1285. *    Function : set_plotsize()                                                                            *
  1286. *                                                                                                                                *
  1287. *****************************************************************
  1288. *                                                                                                                                *
  1289. *         Input : x,y,xsize,ysize,attr,name                                                    *
  1290. *                            int x                        Start von rechten Rand                        *
  1291. *                            int y                        Start von oberem Rand                            *
  1292. *                            int xsize                Länge der Ausgabe                                    *
  1293. *                            int ysize                Höhe der Ausgabe                                    *
  1294. *                            int attr                Ausgabeattribute                                    *
  1295. *                            char *name            Ausgabedatei                                            *
  1296. *                                                                                                                                *
  1297. *        Output : int returnset                                                                            *
  1298. *                            != FALSE                 alle klar                                                    *
  1299. *                            == FALSE                Fehler                                                        *
  1300. *                                                                                                                                *
  1301. *****************************************************************
  1302. *                                                                                                                                *
  1303. *     Comment : set_plotsize() legt die Dimension der Ausgabe            *
  1304. *                         auf einen Plotter fest.                                                        *
  1305. *                         Die Grössenangaben beziehen sich auf den oberen        *
  1306. *                         rechten Rand der Graphik. Für die Attribute ist        *
  1307. *                         in Plotlib.h definiert:                                                        *
  1308. *                                                                                                                                *
  1309. *                                ROTATE    ->    Die Ausgabe wird um +90 Grad                *
  1310. *                                                        gedreht.                                                        *
  1311. *                                                                                                                                *
  1312. *                         Generell erfolgt die Ausgabe in eine Datei. Es            *
  1313. *                         können aber auch direkte Ausgaben über die                    *
  1314. *                         Schnittstelle erfolgen, wenn diese auch wie eine        *
  1315. *                         Datei angesprochen werden können. Mögliche                    *
  1316. *                         Filenamen auf dem Amiga für die Schnittstellen            *
  1317. *                         sind PAR:, PRT: und SER:.                                                    *
  1318. *                         Wenn keine Filenamen spezifiziert wurde, wird            *
  1319. *                         default Plot.plt verwendet.                                                *
  1320. *                                                                                                                                *
  1321. *      Errors : - sequence error                                                                        *
  1322. *                         - parameter failure                                                                *
  1323. *                         - memory allocation failure                                                *
  1324. *                                                                                                                                *
  1325. *             Rev : V1.0                                                                                                *
  1326. *                                                                                                                                *
  1327. *     History : V1.0 erstellen dieses Files                            31/12/89    *
  1328. *                                                                                                                                *
  1329. *             Doc : Plotlibrary User's Guide                                                        *
  1330. *                                                                                                                                *
  1331. *          Bugs : keine bekannten                                                                        *
  1332. *                                                                                                                                *
  1333. *         Autor : Oesch Silvano                                                                            *
  1334. *                                                                                                                                *
  1335. *         Datum : 31/12/89                                                                                        *
  1336. *                                                                                                                                *
  1337. ****************************************************************/
  1338.  
  1339. int set_plotsize(x,y,xsize,ysize,attr,name)
  1340. int x,
  1341.         y,
  1342.         xsize,
  1343.         ysize,
  1344.         attr;
  1345. char *name;
  1346. {
  1347.  
  1348.     int returnset;
  1349.  
  1350.     if (plot == NULL)                                    /* plot gesetzt                         */
  1351.     {                                                                    /* Nein                                            */
  1352.         seterror(SEQSEPLO);                            /* Error                                        */
  1353.         setreturn(FALSE);
  1354.     }
  1355.     else                                                            /* Grösse im Bereich ?            */
  1356.         if ((!xsize) or
  1357.                 (!ysize) or
  1358.                 ( attr & ~ROTATE))
  1359.         {
  1360.             seterror(PARASEPLO);                    /* Nein,  Fehler                        */
  1361.             setreturn(FALSE);
  1362.         }
  1363.         else
  1364.             setreturn(setplotsize(x,y,xsize,ysize,attr,name));
  1365.     return(returnset);
  1366. }
  1367.  
  1368.  
  1369. /****************************************************************
  1370. *                                                                                                                                *
  1371. *    Function : display()                                                                                    *
  1372. *                                                                                                                                *
  1373. *****************************************************************
  1374. *                                                                                                                                *
  1375. *         Input : typ,para                                                                                        *
  1376. *                            int typ                    output typ                                                *
  1377. *                            int para                Graphikparamter                                        *
  1378. *                                                                                                                                *
  1379. *        Output : int returnset                                                                            *
  1380. *                            != FALSE                 alle klar                                                    *
  1381. *                            == FALSE                Fehler                                                        *
  1382. *                                                                                                                                *
  1383. *****************************************************************
  1384. *                                                                                                                                *
  1385. *     Comment : Diese Funktion ist die komplexeste Funktion der        *
  1386. *                         der gesammten Library. Mit ihr wird die Ausgabe        *
  1387. *                         der Daten auf die verschiedenen Ausgabegeräte            *
  1388. *                         ausgeführt. Die Darstellung wird aus der Plot-            *
  1389. *                         struktur genommen so wie sie zu diesem Zeitpunkt        *
  1390. *                         eingestellt ist.                                                                        *
  1391. *                         Der Graphikparameter gibt Auskunft, ob der                    *
  1392. *                         Programmierer vom Textmodus in den Graphikmodus        *
  1393. *                         umgeschaltet hat. Wenn dem so ist, muss keine            *
  1394. *                         Graphik initialisiert werden.                                            *
  1395. *                         Diese Funktion ist die einzige dieser Library            *
  1396. *                         welche auf den Level 3 zugreift.                                        *
  1397. *                                                                                                                                *
  1398. *                         Die folgenden Parameter sind in Plotlib.h                    *
  1399. *                         definiert:                                                                                    *
  1400. *                                                                                                                                *
  1401. *                                SCREENOUT        -> Ausgabe auf Bildschirm                        *
  1402. *                                SCREENCLOSE    -> Schliesen des Graphikschirms            *
  1403. *                                PRINTOUT        -> Ausgabe aus Matrixdrucker                *
  1404. *                                PLOTOUT            -> Ausgabe auf Plotter HPGL                    *
  1405. *                                                                                                                                *
  1406. *                                GRAPHNOTSET    -> Graphik nicht initialisiert            *
  1407. *                                GRAPHSET        -> Graphik schon init.                            *
  1408. *                                                                                                                                *
  1409. *      Errors : - sequence error                                                                        *
  1410. *                         - parameter failure                                                                *
  1411. *                         - invalid display parameter                                                *
  1412. *                         - function not implemeted                                                     *
  1413. *                         - graphic not open                                                                     *
  1414. *                         - displaypara not equal                                                        *
  1415. *                         - no plotdatas specified                                                        *
  1416. *                         - graphic open failure                                                            *
  1417. *                         - graphic mem alloc failure                                                *
  1418. *                         - polygon fill failure                                                            *
  1419. *                         - plotdfile open failure                                                        *
  1420. *                         - plotsize not in range                                                        *
  1421. *                                                                                                                                *
  1422. *             Rev : V1.0                                                                                                *
  1423. *                                                                                                                                *
  1424. *     History : V1.0 erstellen dieses Files                            06/12/89    *
  1425. *                                                                                                                                *
  1426. *             Doc : Plotlibrary User's Guide                                                        *
  1427. *                                                                                                                                *
  1428. *          Bugs : keine bekannten                                                                        *
  1429. *                                                                                                                                *
  1430. *         Autor : Oesch Silvano                                                                            *
  1431. *                                                                                                                                *
  1432. *         Datum : 06/12/89                                                                                        *
  1433. *                                                                                                                                *
  1434. ****************************************************************/
  1435.  
  1436. int display(typ,para)
  1437. int typ,
  1438.         para;
  1439.  
  1440. {
  1441.     int returnset;
  1442.  
  1443.     if ((plot == NULL) or                            /* plot gesetzt und                 */
  1444.             (plot->first == NULL))                /* Daten vorhanden ?                */
  1445.     {                                                                    /* Nein                                            */
  1446.         seterror(SEQDISP);                            /* Error                                        */
  1447.         setreturn(FALSE);
  1448.     }
  1449.     else                                                            /* Parameter kontrolle            */
  1450.         if ((typ < SCREENOUT) or                /* outputparameter in range    */
  1451.                 (typ > PLOTOUT))
  1452.         {
  1453.             seterror(PARADISP);                        /* Nein, Fehler                            */
  1454.             setreturn(FALSE);
  1455.         }
  1456.         else
  1457.             setreturn(displ2(typ,para));    /* go Level 2                                */
  1458.     return(returnset);
  1459. }
  1460.  
  1461.