1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.11
4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24: #include "gnuplot.conv.h"
25:
26:
27: /*
28: ================================================================================
29: Fonction 'appel_gnuplot'
30: ================================================================================
31: Entrées : persistance 'E' écran, 'N' normal, 'I' impression, 'F' fichier
32: --------------------------------------------------------------------------------
33: Sorties : néant
34: --------------------------------------------------------------------------------
35: Effets de bord : néant
36: ================================================================================
37: */
38:
39: void
40: appel_gnuplot(struct_processus *s_etat_processus, unsigned char persistance)
41: {
42: file *entree_standard;
43: file *fichier_destination;
44: file *fichier_image;
45: file *fichier_impression;
46: file *fichier_source;
47:
48: int caractere;
49:
50: logical1 adequation_fichier;
51:
52: long compteur_nombre_fichiers;
53:
54: real8 phi;
55: real8 theta;
56:
57: struct_fichier_graphique *l_ancienne_base_liste;
58: struct_fichier_graphique *l_base_liste;
59: struct_fichier_graphique *l_fichier_courant;
60:
61: struct_marque *l_marque;
62:
63: unsigned char *nom_fichier;
64: unsigned char *commande_gnuplot;
65:
66: # ifndef GNUPLOT_SUPPORT
67: if ((*s_etat_processus).langue == 'F')
68: {
69: printf("+++Attention : Support de GnuPlot non compilé !\n");
70: }
71: else
72: {
73: printf("+++Warning : GnuPlot not available !\n");
74: }
75:
76: fflush(stdout);
77:
78: return;
79: # endif
80:
81: /*
82: * Comptage du nombre des fichiers et superposition le cas échéant
83: */
84:
85: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
86: compteur_nombre_fichiers = 0;
87: nom_fichier = NULL;
88:
89: while(l_fichier_courant != NULL)
90: {
91: compteur_nombre_fichiers++;
92: l_fichier_courant = (*l_fichier_courant).suivant;
93: }
94:
95: if (compteur_nombre_fichiers > ds_gnuplot_nombre_max_fichiers)
96: {
97: if ((*s_etat_processus).langue == 'F')
98: {
99: printf("+++Attention : Réduction du nombre de plans\n");
100: }
101: else
102: {
103: printf("+++Warning : Graphical depth reduction\n");
104: }
105:
106: l_base_liste = (*s_etat_processus).fichiers_graphiques;
107: (*s_etat_processus).fichiers_graphiques = NULL;
108:
109: while(l_base_liste != NULL)
110: {
111: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
112: adequation_fichier = d_faux;
113:
114: while(l_fichier_courant != NULL)
115: {
116: if ((strcmp((*l_fichier_courant).type, (*l_base_liste).type)
117: == 0) && ((*l_fichier_courant).systeme_axes ==
118: (*l_base_liste).systeme_axes))
119: {
120: adequation_fichier = d_vrai;
121: break;
122: }
123:
124: l_fichier_courant = (*l_fichier_courant).suivant;
125: }
126:
127: if (adequation_fichier == d_vrai)
128: {
129: if ((fichier_source = fopen((*l_base_liste).nom, "r"))
130: == NULL)
131: {
132: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
133: return;
134: }
135:
136: if ((fichier_destination = fopen((*l_fichier_courant).nom,
137: "a")) == NULL)
138: {
139: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
140: return;
141: }
142:
143: if (fprintf(fichier_destination, "\n") < 0)
144: {
145: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
146: return;
147: }
148:
149: while((caractere = getc(fichier_source)) != EOF)
150: {
151: if (putc(caractere, fichier_destination) == EOF)
152: {
153: (*s_etat_processus).erreur_systeme =
154: d_es_erreur_fichier;
155: return;
156: }
157: }
158:
159: if (fclose(fichier_source) != 0)
160: {
161: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
162: return;
163: }
164:
165: if (fclose(fichier_destination) != 0)
166: {
167: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
168: return;
169: }
170:
171: if (((*l_fichier_courant).presence_axes == d_vrai) ||
172: ((*l_base_liste).presence_axes == d_vrai))
173: {
174: (*l_fichier_courant).presence_axes = d_vrai;
175: }
176: else
177: {
178: (*l_fichier_courant).presence_axes = d_faux;
179: }
180:
181: if (destruction_fichier((*l_base_liste).nom) == d_erreur)
182: {
183: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
184: return;
185: }
186:
187: free((*l_base_liste).nom);
188:
189: if ((*l_base_liste).legende != NULL)
190: {
191: free((*l_base_liste).legende);
192: }
193: }
194: else
195: {
196: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
197:
198: if (l_fichier_courant == NULL)
199: {
200: if (((*s_etat_processus).fichiers_graphiques =
201: (struct_fichier_graphique *) malloc(
202: sizeof(struct_fichier_graphique))) == NULL)
203: {
204: (*s_etat_processus).erreur_systeme =
205: d_es_allocation_memoire;
206: return;
207: }
208:
209: (*(*s_etat_processus).fichiers_graphiques).suivant = NULL;
210: (*(*s_etat_processus).fichiers_graphiques).nom =
211: (*l_base_liste).nom;
212: (*(*s_etat_processus).fichiers_graphiques).legende = NULL;
213: (*(*s_etat_processus).fichiers_graphiques).presence_axes =
214: (*l_base_liste).presence_axes;
215: strcpy((*(*s_etat_processus).fichiers_graphiques).type,
216: (*l_base_liste).type);
217: (*(*s_etat_processus).fichiers_graphiques).dimensions =
218: (*l_base_liste).dimensions;
219: (*(*s_etat_processus).fichiers_graphiques).systeme_axes =
220: (*l_base_liste).systeme_axes;
221: }
222: else
223: {
224: while((*l_fichier_courant).suivant != NULL)
225: {
226: l_fichier_courant = (*l_fichier_courant).suivant;
227: }
228:
229: if (((*l_fichier_courant).suivant =
230: (struct_fichier_graphique *) malloc(
231: sizeof(struct_fichier_graphique))) == NULL)
232: {
233: (*s_etat_processus).erreur_systeme =
234: d_es_allocation_memoire;
235: return;
236: }
237:
238: l_fichier_courant = (*l_fichier_courant).suivant;
239:
240: (*l_fichier_courant).suivant = NULL;
241: (*l_fichier_courant).nom = (*l_base_liste).nom;
242: (*l_fichier_courant).legende = NULL;
243: (*l_fichier_courant).presence_axes = d_faux;
244: strcpy((*l_fichier_courant).type, (*l_base_liste).type);
245: (*l_fichier_courant).dimensions =
246: (*l_base_liste).dimensions;
247: (*l_fichier_courant).systeme_axes =
248: (*l_base_liste).systeme_axes;
249: }
250: }
251:
252: l_ancienne_base_liste = l_base_liste;
253: l_base_liste = (*l_base_liste).suivant;
254: free(l_ancienne_base_liste);
255: }
256: }
257:
258: /*
259: * Traitement du cas où l'afficheur n'est pas persistant
260: */
261:
262: if (persistance == 'N')
263: {
264: entree_standard = NULL;
265:
266: if ((*s_etat_processus).entree_standard == NULL)
267: {
268: #ifdef FORCE_GNUPLOT_PATH
269: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
270: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
271: == NULL)
272: {
273: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
274: return;
275: }
276:
277: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
278: ds_gnuplot_commande);
279: #else
280: if ((commande_gnuplot = malloc((1 +
281: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
282: == NULL)
283: {
284: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
285: return;
286: }
287:
288: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
289: #endif
290:
291: if (((*s_etat_processus).entree_standard =
292: popen(commande_gnuplot, "w")) == NULL)
293: {
294: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
295: return;
296: }
297:
298: free(commande_gnuplot);
299:
300: if (fprintf((*s_etat_processus).entree_standard,
301: "%s\n", ds_gnuplot_terminal_defaut) < 0)
302: {
303: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
304: return;
305: }
306: }
307:
308: if (strlen((*s_etat_processus).titre) > 0)
309: {
310: if (fprintf((*s_etat_processus).entree_standard,
311: "set title \"%s\"\n", (*s_etat_processus).titre) < 0)
312: {
313: (*s_etat_processus).erreur_systeme = d_es_processus;
314: return;
315: }
316: }
317: }
318: else if (persistance == 'E') /* Ecran */
319: {
320: entree_standard = (*s_etat_processus).entree_standard;
321:
322: #if FORCE_GNUPLOT_PATH
323: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
324: strlen(ds_gnuplot_commande_persistante)) *
325: sizeof(unsigned char))) == NULL)
326: {
327: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
328: return;
329: }
330:
331: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
332: ds_gnuplot_commande_persistante);
333: #else
334: if ((commande_gnuplot = malloc((1 +
335: strlen(ds_gnuplot_commande_persistante)) *
336: sizeof(unsigned char))) == NULL)
337: {
338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
339: return;
340: }
341:
342: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande_persistante);
343: #endif
344:
345: if (((*s_etat_processus).entree_standard =
346: popen(commande_gnuplot, "w")) == NULL)
347: {
348: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
349: return;
350: }
351:
352: free(commande_gnuplot);
353:
354: if (fprintf((*s_etat_processus).entree_standard,
355: "%s\n", ds_gnuplot_terminal_defaut) < 0)
356: {
357: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
358: return;
359: }
360:
361: if (strlen((*s_etat_processus).titre) > 0)
362: {
363: if (fprintf((*s_etat_processus).entree_standard,
364: "set title \"%s\"\n", (*s_etat_processus).titre) < 0)
365: {
366: (*s_etat_processus).erreur_systeme = d_es_processus;
367: return;
368: }
369: }
370: }
371: else if (persistance == 'I') /* Imprimante */
372: {
373: entree_standard = (*s_etat_processus).entree_standard;
374:
375: #ifdef FORCE_GNUPLOT_PATH
376: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
377: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
378: == NULL)
379: {
380: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
381: return;
382: }
383:
384: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
385: ds_gnuplot_commande);
386: #else
387: if ((commande_gnuplot = malloc((1 +
388: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
389: == NULL)
390: {
391: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
392: return;
393: }
394:
395: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
396: #endif
397:
398: if (((*s_etat_processus).entree_standard =
399: popen(commande_gnuplot, "w")) == NULL)
400: {
401: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
402: return;
403: }
404:
405: free(commande_gnuplot);
406:
407: if (fprintf((*s_etat_processus).entree_standard,
408: "%s\n", ds_gnuplot_terminal_defaut) < 0)
409: {
410: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
411: return;
412: }
413:
414: if ((nom_fichier = creation_nom_fichier(s_etat_processus,
415: (*s_etat_processus).chemin_fichiers_temporaires)) == NULL)
416: {
417: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
418: return;
419: }
420:
421: if (fprintf((*s_etat_processus).entree_standard,
422: "set terminal latex\n") < 0)
423: {
424: (*s_etat_processus).erreur_systeme = d_es_processus;
425: return;
426: }
427:
428: if (fprintf((*s_etat_processus).entree_standard, "set output \"%s\"\n",
429: nom_fichier) < 0)
430: {
431: (*s_etat_processus).erreur_systeme = d_es_processus;
432: return;
433: }
434: }
435: else /* persistance == 'F' comme fichier */
436: {
437: entree_standard = (*s_etat_processus).entree_standard;
438:
439: #ifdef FORCE_GNUPLOT_PATH
440: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
441: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
442: == NULL)
443: {
444: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
445: return;
446: }
447:
448: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
449: ds_gnuplot_commande);
450: #else
451: if ((commande_gnuplot = malloc((1 +
452: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
453: == NULL)
454: {
455: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
456: return;
457: }
458:
459: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
460: #endif
461:
462: if (((*s_etat_processus).entree_standard =
463: popen(commande_gnuplot, "w")) == NULL)
464: {
465: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
466: return;
467: }
468:
469: free(commande_gnuplot);
470:
471: if (fprintf((*s_etat_processus).entree_standard, "set terminal %s\n",
472: (*s_etat_processus).type_fichier_gnuplot) < 0)
473: {
474: (*s_etat_processus).erreur_systeme = d_es_processus;
475: return;
476: }
477:
478: if (fprintf((*s_etat_processus).entree_standard, "set output \"%s\"\n",
479: (*s_etat_processus).nom_fichier_gnuplot) < 0)
480: {
481: (*s_etat_processus).erreur_systeme = d_es_processus;
482: return;
483: }
484:
485: free((*s_etat_processus).nom_fichier_gnuplot);
486: free((*s_etat_processus).type_fichier_gnuplot);
487:
488: (*s_etat_processus).nom_fichier_gnuplot = NULL;
489: (*s_etat_processus).type_fichier_gnuplot = NULL;
490:
491: if (strlen((*s_etat_processus).titre) > 0)
492: {
493: if (fprintf((*s_etat_processus).entree_standard,
494: "set title \"%s\"\n", (*s_etat_processus).titre) < 0)
495: {
496: (*s_etat_processus).erreur_systeme = d_es_processus;
497: return;
498: }
499: }
500: }
501:
502: /*
503: * Affichace des marques
504: */
505:
506: l_marque = (*s_etat_processus).s_marques;
507:
508: while(l_marque != NULL)
509: {
510: if (fprintf((*s_etat_processus).entree_standard,
511: "set label \"%s\" at %s point front offset 0.2,0.2\n",
512: (*l_marque).label, (*l_marque).position) < 0)
513: {
514: (*s_etat_processus).erreur_systeme = d_es_processus;
515: return;
516: }
517:
518: l_marque = (*l_marque).suivant;
519: }
520:
521: /*
522: * Affichage, le cas échéant, des graduations
523: */
524:
525: if ((*s_etat_processus).x_tics < 0)
526: {
527: if (fprintf((*s_etat_processus).entree_standard, "unset xtics\n") < 0)
528: {
529: (*s_etat_processus).erreur_systeme = d_es_processus;
530: return;
531: }
532: }
533: else if ((*s_etat_processus).x_tics == 0)
534: {
535: if (fprintf((*s_etat_processus).entree_standard,
536: "set xtics autofreq\n") < 0)
537: {
538: (*s_etat_processus).erreur_systeme = d_es_processus;
539: return;
540: }
541: }
542: else
543: {
544: if (fprintf((*s_etat_processus).entree_standard, "set xtics %f\n",
545: (*s_etat_processus).x_tics) < 0)
546: {
547: (*s_etat_processus).erreur_systeme = d_es_processus;
548: return;
549: }
550: }
551:
552: if ((*s_etat_processus).mx_tics < 0)
553: {
554: if (fprintf((*s_etat_processus).entree_standard, "unset mxtics\n") < 0)
555: {
556: (*s_etat_processus).erreur_systeme = d_es_processus;
557: return;
558: }
559: }
560: else if ((*s_etat_processus).mx_tics == 0)
561: {
562: if (fprintf((*s_etat_processus).entree_standard,
563: "set mxtics default\n") < 0)
564: {
565: (*s_etat_processus).erreur_systeme = d_es_processus;
566: return;
567: }
568: }
569: else
570: {
571: if (fprintf((*s_etat_processus).entree_standard, "set mxtics %lld\n",
572: (*s_etat_processus).mx_tics) < 0)
573: {
574: (*s_etat_processus).erreur_systeme = d_es_processus;
575: return;
576: }
577: }
578:
579: if ((*s_etat_processus).y_tics < 0)
580: {
581: if (fprintf((*s_etat_processus).entree_standard, "unset ytics\n") < 0)
582: {
583: (*s_etat_processus).erreur_systeme = d_es_processus;
584: return;
585: }
586: }
587: else if ((*s_etat_processus).y_tics == 0)
588: {
589: if (fprintf((*s_etat_processus).entree_standard,
590: "set ytics autofreq\n") < 0)
591: {
592: (*s_etat_processus).erreur_systeme = d_es_processus;
593: return;
594: }
595: }
596: else
597: {
598: if (fprintf((*s_etat_processus).entree_standard, "set ytics %f\n",
599: (*s_etat_processus).y_tics) < 0)
600: {
601: (*s_etat_processus).erreur_systeme = d_es_processus;
602: return;
603: }
604: }
605:
606: if ((*s_etat_processus).my_tics < 0)
607: {
608: if (fprintf((*s_etat_processus).entree_standard, "unset mytics\n") < 0)
609: {
610: (*s_etat_processus).erreur_systeme = d_es_processus;
611: return;
612: }
613: }
614: else if ((*s_etat_processus).my_tics == 0)
615: {
616: if (fprintf((*s_etat_processus).entree_standard,
617: "set mytics default\n") < 0)
618: {
619: (*s_etat_processus).erreur_systeme = d_es_processus;
620: return;
621: }
622: }
623: else
624: {
625: if (fprintf((*s_etat_processus).entree_standard, "set mytics %lld\n",
626: (*s_etat_processus).my_tics) < 0)
627: {
628: (*s_etat_processus).erreur_systeme = d_es_processus;
629: return;
630: }
631: }
632:
633: if ((*s_etat_processus).z_tics < 0)
634: {
635: if (fprintf((*s_etat_processus).entree_standard, "unset ztics\n") < 0)
636: {
637: (*s_etat_processus).erreur_systeme = d_es_processus;
638: return;
639: }
640: }
641: else if ((*s_etat_processus).z_tics == 0)
642: {
643: if (fprintf((*s_etat_processus).entree_standard,
644: "set ztics autofreq\n") < 0)
645: {
646: (*s_etat_processus).erreur_systeme = d_es_processus;
647: return;
648: }
649: }
650: else
651: {
652: if (fprintf((*s_etat_processus).entree_standard, "set ztics %f\n",
653: (*s_etat_processus).z_tics) < 0)
654: {
655: (*s_etat_processus).erreur_systeme = d_es_processus;
656: return;
657: }
658: }
659:
660: if ((*s_etat_processus).mz_tics < 0)
661: {
662: if (fprintf((*s_etat_processus).entree_standard, "unset mztics\n") < 0)
663: {
664: (*s_etat_processus).erreur_systeme = d_es_processus;
665: return;
666: }
667: }
668: else if ((*s_etat_processus).mz_tics == 0)
669: {
670: if (fprintf((*s_etat_processus).entree_standard,
671: "set mztics default\n") < 0)
672: {
673: (*s_etat_processus).erreur_systeme = d_es_processus;
674: return;
675: }
676: }
677: else
678: {
679: if (fprintf((*s_etat_processus).entree_standard, "set mztics %lld\n",
680: (*s_etat_processus).mz_tics) < 0)
681: {
682: (*s_etat_processus).erreur_systeme = d_es_processus;
683: return;
684: }
685: }
686:
687: if ((*s_etat_processus).x2_tics < 0)
688: {
689: if (fprintf((*s_etat_processus).entree_standard, "unset x2tics\n") < 0)
690: {
691: (*s_etat_processus).erreur_systeme = d_es_processus;
692: return;
693: }
694: }
695: else if ((*s_etat_processus).x2_tics == 0)
696: {
697: if (fprintf((*s_etat_processus).entree_standard,
698: "set x2tics autofreq\n") < 0)
699: {
700: (*s_etat_processus).erreur_systeme = d_es_processus;
701: return;
702: }
703: }
704: else
705: {
706: if (fprintf((*s_etat_processus).entree_standard, "set x2tics %f\n",
707: (*s_etat_processus).x2_tics) < 0)
708: {
709: (*s_etat_processus).erreur_systeme = d_es_processus;
710: return;
711: }
712: }
713:
714: if ((*s_etat_processus).mx2_tics < 0)
715: {
716: if (fprintf((*s_etat_processus).entree_standard, "unset mx2tics\n") < 0)
717: {
718: (*s_etat_processus).erreur_systeme = d_es_processus;
719: return;
720: }
721: }
722: else if ((*s_etat_processus).mx2_tics == 0)
723: {
724: if (fprintf((*s_etat_processus).entree_standard,
725: "set mx2tics default\n") < 0)
726: {
727: (*s_etat_processus).erreur_systeme = d_es_processus;
728: return;
729: }
730: }
731: else
732: {
733: if (fprintf((*s_etat_processus).entree_standard, "set mx2tics %lld\n",
734: (*s_etat_processus).mx2_tics) < 0)
735: {
736: (*s_etat_processus).erreur_systeme = d_es_processus;
737: return;
738: }
739: }
740:
741: if ((*s_etat_processus).y2_tics < 0)
742: {
743: if (fprintf((*s_etat_processus).entree_standard, "unset y2tics\n") < 0)
744: {
745: (*s_etat_processus).erreur_systeme = d_es_processus;
746: return;
747: }
748: }
749: else if ((*s_etat_processus).y2_tics == 0)
750: {
751: if (fprintf((*s_etat_processus).entree_standard,
752: "set y2tics autofreq\n") < 0)
753: {
754: (*s_etat_processus).erreur_systeme = d_es_processus;
755: return;
756: }
757: }
758: else
759: {
760: if (fprintf((*s_etat_processus).entree_standard, "set y2tics %f\n",
761: (*s_etat_processus).y2_tics) < 0)
762: {
763: (*s_etat_processus).erreur_systeme = d_es_processus;
764: return;
765: }
766: }
767:
768: if ((*s_etat_processus).my2_tics < 0)
769: {
770: if (fprintf((*s_etat_processus).entree_standard, "unset my2tics\n") < 0)
771: {
772: (*s_etat_processus).erreur_systeme = d_es_processus;
773: return;
774: }
775: }
776: else if ((*s_etat_processus).my2_tics == 0)
777: {
778: if (fprintf((*s_etat_processus).entree_standard,
779: "set my2tics default\n") < 0)
780: {
781: (*s_etat_processus).erreur_systeme = d_es_processus;
782: return;
783: }
784: }
785: else
786: {
787: if (fprintf((*s_etat_processus).entree_standard, "set my2tics %lld\n",
788: (*s_etat_processus).my2_tics) < 0)
789: {
790: (*s_etat_processus).erreur_systeme = d_es_processus;
791: return;
792: }
793: }
794:
795: if ((*s_etat_processus).z2_tics < 0)
796: {
797: if (fprintf((*s_etat_processus).entree_standard, "unset z2tics\n") < 0)
798: {
799: (*s_etat_processus).erreur_systeme = d_es_processus;
800: return;
801: }
802: }
803: else if ((*s_etat_processus).z2_tics == 0)
804: {
805: if (fprintf((*s_etat_processus).entree_standard,
806: "set z2tics autofreq\n") < 0)
807: {
808: (*s_etat_processus).erreur_systeme = d_es_processus;
809: return;
810: }
811: }
812: else
813: {
814: if (fprintf((*s_etat_processus).entree_standard, "set z2tics %f\n",
815: (*s_etat_processus).z2_tics) < 0)
816: {
817: (*s_etat_processus).erreur_systeme = d_es_processus;
818: return;
819: }
820: }
821:
822: if ((*s_etat_processus).mz2_tics < 0)
823: {
824: if (fprintf((*s_etat_processus).entree_standard, "unset mz2tics\n") < 0)
825: {
826: (*s_etat_processus).erreur_systeme = d_es_processus;
827: return;
828: }
829: }
830: else if ((*s_etat_processus).mz2_tics == 0)
831: {
832: if (fprintf((*s_etat_processus).entree_standard,
833: "set mz2tics default\n") < 0)
834: {
835: (*s_etat_processus).erreur_systeme = d_es_processus;
836: return;
837: }
838: }
839: else
840: {
841: if (fprintf((*s_etat_processus).entree_standard, "set mz2tics %lld\n",
842: (*s_etat_processus).mz2_tics) < 0)
843: {
844: (*s_etat_processus).erreur_systeme = d_es_processus;
845: return;
846: }
847: }
848:
849: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
850:
851: while(l_fichier_courant != NULL)
852: {
853: if ((*l_fichier_courant).presence_axes == d_vrai)
854: {
855: if ((*s_etat_processus).x_lines == d_vrai)
856: {
857: if (fprintf((*s_etat_processus).entree_standard,
858: "set grid xtics\n") < 0)
859: {
860: (*s_etat_processus).erreur_systeme = d_es_processus;
861: return;
862: }
863: }
864:
865: if ((*s_etat_processus).y_lines == d_vrai)
866: {
867: if (fprintf((*s_etat_processus).entree_standard,
868: "set grid ytics\n") < 0)
869: {
870: (*s_etat_processus).erreur_systeme = d_es_processus;
871: return;
872: }
873: }
874:
875: if ((*s_etat_processus).z_lines == d_vrai)
876: {
877: if (fprintf((*s_etat_processus).entree_standard,
878: "set grid ztics\n") < 0)
879: {
880: (*s_etat_processus).erreur_systeme = d_es_processus;
881: return;
882: }
883: }
884:
885: if ((*s_etat_processus).x2_lines == d_vrai)
886: {
887: if (fprintf((*s_etat_processus).entree_standard,
888: "set grid x2tics\n") < 0)
889: {
890: (*s_etat_processus).erreur_systeme = d_es_processus;
891: return;
892: }
893: }
894:
895: if ((*s_etat_processus).y2_lines == d_vrai)
896: {
897: if (fprintf((*s_etat_processus).entree_standard,
898: "set grid y2tics\n") < 0)
899: {
900: (*s_etat_processus).erreur_systeme = d_es_processus;
901: return;
902: }
903: }
904:
905: if ((*s_etat_processus).z2_lines == d_vrai)
906: {
907: if (fprintf((*s_etat_processus).entree_standard,
908: "set grid z2tics\n") < 0)
909: {
910: (*s_etat_processus).erreur_systeme = d_es_processus;
911: return;
912: }
913: }
914:
915: if ((*s_etat_processus).mx_lines == d_vrai)
916: {
917: if (fprintf((*s_etat_processus).entree_standard,
918: "set grid mxtics\n") < 0)
919: {
920: (*s_etat_processus).erreur_systeme = d_es_processus;
921: return;
922: }
923: }
924:
925: if ((*s_etat_processus).my_lines == d_vrai)
926: {
927: if (fprintf((*s_etat_processus).entree_standard,
928: "set grid mytics\n") < 0)
929: {
930: (*s_etat_processus).erreur_systeme = d_es_processus;
931: return;
932: }
933: }
934:
935: if ((*s_etat_processus).mz_lines == d_vrai)
936: {
937: if (fprintf((*s_etat_processus).entree_standard,
938: "set grid mztics\n") < 0)
939: {
940: (*s_etat_processus).erreur_systeme = d_es_processus;
941: return;
942: }
943: }
944:
945: if ((*s_etat_processus).mx2_lines == d_vrai)
946: {
947: if (fprintf((*s_etat_processus).entree_standard,
948: "set grid mx2tics\n") < 0)
949: {
950: (*s_etat_processus).erreur_systeme = d_es_processus;
951: return;
952: }
953: }
954:
955: if ((*s_etat_processus).my2_lines == d_vrai)
956: {
957: if (fprintf((*s_etat_processus).entree_standard,
958: "set grid my2tics\n") < 0)
959: {
960: (*s_etat_processus).erreur_systeme = d_es_processus;
961: return;
962: }
963: }
964:
965: if ((*s_etat_processus).mz2_lines == d_vrai)
966: {
967: if (fprintf((*s_etat_processus).entree_standard,
968: "set grid mz2tics\n") < 0)
969: {
970: (*s_etat_processus).erreur_systeme = d_es_processus;
971: return;
972: }
973: }
974:
975: if ((strcmp((*l_fichier_courant).type, "FONCTION") == 0) ||
976: (strcmp((*l_fichier_courant).type, "PARAMETRIQUE") == 0) ||
977: (strcmp((*l_fichier_courant).type, "POINTS") == 0) ||
978: (strcmp((*l_fichier_courant).type, "HISTOGRAMME") == 0) ||
979: (strcmp((*l_fichier_courant).type, "TABLE TRACANTE") == 0)
980: || (strcmp((*l_fichier_courant).type, "COURBES DE NIVEAU")
981: == 0) ||
982: (strcmp((*l_fichier_courant).type, "GRILLE 3D") == 0))
983: {
984: if (fprintf((*s_etat_processus).entree_standard,
985: "set grid\n") < 0)
986: {
987: (*s_etat_processus).erreur_systeme = d_es_processus;
988: return;
989: }
990: }
991: else if (strcmp((*l_fichier_courant).type, "POLAIRE") == 0)
992: {
993: if (fprintf((*s_etat_processus).entree_standard,
994: "set xtics axis nomirror\n") < 0)
995: {
996: (*s_etat_processus).erreur_systeme = d_es_processus;
997: return;
998: }
999:
1000: if (fprintf((*s_etat_processus).entree_standard,
1001: "set ytics axis nomirror\n") < 0)
1002: {
1003: (*s_etat_processus).erreur_systeme = d_es_processus;
1004: return;
1005: }
1006:
1007: if (fprintf((*s_etat_processus).entree_standard,
1008: "set grid polar\n") < 0)
1009: {
1010: (*s_etat_processus).erreur_systeme = d_es_processus;
1011: return;
1012: }
1013:
1014: if (fprintf((*s_etat_processus).entree_standard,
1015: "set size square\n") < 0)
1016: {
1017: (*s_etat_processus).erreur_systeme = d_es_processus;
1018: return;
1019: }
1020:
1021: if (fprintf((*s_etat_processus).entree_standard,
1022: "unset x2tics\n") < 0)
1023: {
1024: (*s_etat_processus).erreur_systeme = d_es_processus;
1025: return;
1026: }
1027:
1028: if (fprintf((*s_etat_processus).entree_standard,
1029: "unset y2tics\n") < 0)
1030: {
1031: (*s_etat_processus).erreur_systeme = d_es_processus;
1032: return;
1033: }
1034:
1035: if (fprintf((*s_etat_processus).entree_standard,
1036: "unset z2tics\n") < 0)
1037: {
1038: (*s_etat_processus).erreur_systeme = d_es_processus;
1039: return;
1040: }
1041:
1042: if (fprintf((*s_etat_processus).entree_standard,
1043: "unset mx2tics\n") < 0)
1044: {
1045: (*s_etat_processus).erreur_systeme = d_es_processus;
1046: return;
1047: }
1048:
1049: if (fprintf((*s_etat_processus).entree_standard,
1050: "unset my2tics\n") < 0)
1051: {
1052: (*s_etat_processus).erreur_systeme = d_es_processus;
1053: return;
1054: }
1055:
1056: if (fprintf((*s_etat_processus).entree_standard,
1057: "unset mz2tics\n") < 0)
1058: {
1059: (*s_etat_processus).erreur_systeme = d_es_processus;
1060: return;
1061: }
1062: }
1063: }
1064:
1065: l_fichier_courant = (*l_fichier_courant).suivant;
1066: }
1067:
1068: /*
1069: * Gestion des noms des axes
1070: */
1071:
1072: if (fprintf((*s_etat_processus).entree_standard,
1073: "set xlabel \"%s\"\n", (*s_etat_processus).label_x) < 0)
1074: {
1075: (*s_etat_processus).erreur_systeme = d_es_processus;
1076: return;
1077: }
1078:
1079: if (fprintf((*s_etat_processus).entree_standard,
1080: "set ylabel \"%s\"\n", (*s_etat_processus).label_y) < 0)
1081: {
1082: (*s_etat_processus).erreur_systeme = d_es_processus;
1083: return;
1084: }
1085:
1086: if (fprintf((*s_etat_processus).entree_standard,
1087: "set zlabel \"%s\"\n", (*s_etat_processus).label_z) < 0)
1088: {
1089: (*s_etat_processus).erreur_systeme = d_es_processus;
1090: return;
1091: }
1092:
1093:
1094: /*
1095: * Gestion des échelles automatiques
1096: */
1097:
1098: if ((*s_etat_processus).echelle_automatique_x == d_vrai)
1099: {
1100: if (fprintf((*s_etat_processus).entree_standard,
1101: "set autoscale x\n") < 0)
1102: {
1103: (*s_etat_processus).erreur_systeme = d_es_processus;
1104: return;
1105: }
1106: }
1107: else
1108: {
1109: if (fprintf((*s_etat_processus).entree_standard,
1110: "unset autoscale x\n") < 0)
1111: {
1112: (*s_etat_processus).erreur_systeme = d_es_processus;
1113: return;
1114: }
1115:
1116: if (fprintf((*s_etat_processus).entree_standard, "set xrange [%f:%f]\n",
1117: (*s_etat_processus).x_min, (*s_etat_processus).x_max) < 0)
1118: {
1119: (*s_etat_processus).erreur_systeme = d_es_processus;
1120: return;
1121: }
1122: }
1123:
1124: if ((*s_etat_processus).echelle_automatique_x2 == d_vrai)
1125: {
1126: if (fprintf((*s_etat_processus).entree_standard,
1127: "set autoscale x2\n") < 0)
1128: {
1129: (*s_etat_processus).erreur_systeme = d_es_processus;
1130: return;
1131: }
1132: }
1133: else
1134: {
1135: if (fprintf((*s_etat_processus).entree_standard,
1136: "unset autoscale x2\n") < 0)
1137: {
1138: (*s_etat_processus).erreur_systeme = d_es_processus;
1139: return;
1140: }
1141:
1142: if (fprintf((*s_etat_processus).entree_standard,
1143: "set x2range [%f:%f]\n",
1144: (*s_etat_processus).x2_min, (*s_etat_processus).x2_max) < 0)
1145: {
1146: (*s_etat_processus).erreur_systeme = d_es_processus;
1147: return;
1148: }
1149: }
1150:
1151: if ((*s_etat_processus).echelle_automatique_y == d_vrai)
1152: {
1153: if (fprintf((*s_etat_processus).entree_standard,
1154: "set autoscale y\n") < 0)
1155: {
1156: (*s_etat_processus).erreur_systeme = d_es_processus;
1157: return;
1158: }
1159: }
1160: else
1161: {
1162: if (fprintf((*s_etat_processus).entree_standard,
1163: "unset autoscale y\n") < 0)
1164: {
1165: (*s_etat_processus).erreur_systeme = d_es_processus;
1166: return;
1167: }
1168:
1169: if (fprintf((*s_etat_processus).entree_standard, "set yrange [%f:%f]\n",
1170: (*s_etat_processus).y_min, (*s_etat_processus).y_max) < 0)
1171: {
1172: (*s_etat_processus).erreur_systeme = d_es_processus;
1173: return;
1174: }
1175: }
1176:
1177: if ((*s_etat_processus).echelle_automatique_y2 == d_vrai)
1178: {
1179: if (fprintf((*s_etat_processus).entree_standard,
1180: "set autoscale y2\n") < 0)
1181: {
1182: (*s_etat_processus).erreur_systeme = d_es_processus;
1183: return;
1184: }
1185: }
1186: else
1187: {
1188: if (fprintf((*s_etat_processus).entree_standard,
1189: "unset autoscale y2\n") < 0)
1190: {
1191: (*s_etat_processus).erreur_systeme = d_es_processus;
1192: return;
1193: }
1194:
1195: if (fprintf((*s_etat_processus).entree_standard,
1196: "set y2range [%f:%f]\n",
1197: (*s_etat_processus).y2_min, (*s_etat_processus).y2_max) < 0)
1198: {
1199: (*s_etat_processus).erreur_systeme = d_es_processus;
1200: return;
1201: }
1202: }
1203:
1204: if ((*s_etat_processus).echelle_automatique_z == d_vrai)
1205: {
1206: if (fprintf((*s_etat_processus).entree_standard,
1207: "set autoscale z\n") < 0)
1208: {
1209: (*s_etat_processus).erreur_systeme = d_es_processus;
1210: return;
1211: }
1212: }
1213: else
1214: {
1215: if (fprintf((*s_etat_processus).entree_standard,
1216: "unset autoscale z\n") < 0)
1217: {
1218: (*s_etat_processus).erreur_systeme = d_es_processus;
1219: return;
1220: }
1221:
1222: if (fprintf((*s_etat_processus).entree_standard, "set zrange [%f:%f]\n",
1223: (*s_etat_processus).z_min, (*s_etat_processus).z_max) < 0)
1224: {
1225: (*s_etat_processus).erreur_systeme = d_es_processus;
1226: return;
1227: }
1228: }
1229:
1230: if ((*s_etat_processus).echelle_automatique_z2 == d_vrai)
1231: {
1232: if (fprintf((*s_etat_processus).entree_standard,
1233: "set autoscale z2\n") < 0)
1234: {
1235: (*s_etat_processus).erreur_systeme = d_es_processus;
1236: return;
1237: }
1238: }
1239: else
1240: {
1241: if (fprintf((*s_etat_processus).entree_standard,
1242: "unset autoscale z2\n") < 0)
1243: {
1244: (*s_etat_processus).erreur_systeme = d_es_processus;
1245: return;
1246: }
1247:
1248: if (fprintf((*s_etat_processus).entree_standard,
1249: "set z2range [%f:%f]\n",
1250: (*s_etat_processus).z_min, (*s_etat_processus).z_max) < 0)
1251: {
1252: (*s_etat_processus).erreur_systeme = d_es_processus;
1253: return;
1254: }
1255: }
1256:
1257: /*
1258: * Position du point de vue
1259: */
1260:
1261: theta = (*s_etat_processus).point_de_vue_theta;
1262: phi = (*s_etat_processus).point_de_vue_phi;
1263:
1264: conversion_radians_vers_degres(&theta);
1265: conversion_radians_vers_degres(&phi);
1266:
1267: if (theta < 0)
1268: {
1269: theta = 0;
1270: }
1271: else if (theta > 360)
1272: {
1273: theta = 360;
1274: }
1275:
1276: if (phi < 0)
1277: {
1278: phi = 0;
1279: }
1280: else if (phi > 180)
1281: {
1282: phi = 180;
1283: }
1284:
1285: if (fprintf((*s_etat_processus).entree_standard,
1286: "set view %f,%f,1,%f\n", phi, theta,
1287: (*s_etat_processus).echelle_3D) < 0)
1288: {
1289: (*s_etat_processus).erreur_systeme = d_es_processus;
1290: return;
1291: }
1292:
1293: /*
1294: * Gestion des échelles logarithmiques
1295: */
1296:
1297: if ((*s_etat_processus).echelle_log_x == d_vrai)
1298: {
1299: if (fprintf((*s_etat_processus).entree_standard,
1300: "set logscale x\n") < 0)
1301: {
1302: (*s_etat_processus).erreur_systeme = d_es_processus;
1303: return;
1304: }
1305: }
1306: else
1307: {
1308: if (fprintf((*s_etat_processus).entree_standard,
1309: "unset logscale x\n") < 0)
1310: {
1311: (*s_etat_processus).erreur_systeme = d_es_processus;
1312: return;
1313: }
1314: }
1315:
1316: if ((*s_etat_processus).echelle_log_y == d_vrai)
1317: {
1318: if (fprintf((*s_etat_processus).entree_standard,
1319: "set logscale y\n") < 0)
1320: {
1321: (*s_etat_processus).erreur_systeme = d_es_processus;
1322: return;
1323: }
1324: }
1325: else
1326: {
1327: if (fprintf((*s_etat_processus).entree_standard,
1328: "unset logscale y\n") < 0)
1329: {
1330: (*s_etat_processus).erreur_systeme = d_es_processus;
1331: return;
1332: }
1333: }
1334:
1335: if ((*s_etat_processus).echelle_log_z == d_vrai)
1336: {
1337: if (fprintf((*s_etat_processus).entree_standard,
1338: "set logscale z\n") < 0)
1339: {
1340: (*s_etat_processus).erreur_systeme = d_es_processus;
1341: return;
1342: }
1343: }
1344: else
1345: {
1346: if (fprintf((*s_etat_processus).entree_standard,
1347: "unset logscale z\n") < 0)
1348: {
1349: (*s_etat_processus).erreur_systeme = d_es_processus;
1350: return;
1351: }
1352: }
1353:
1354: if ((*s_etat_processus).echelle_log_x2 == d_vrai)
1355: {
1356: if (fprintf((*s_etat_processus).entree_standard,
1357: "set logscale x2\n") < 0)
1358: {
1359: (*s_etat_processus).erreur_systeme = d_es_processus;
1360: return;
1361: }
1362: }
1363: else
1364: {
1365: if (fprintf((*s_etat_processus).entree_standard,
1366: "unset logscale x2\n") < 0)
1367: {
1368: (*s_etat_processus).erreur_systeme = d_es_processus;
1369: return;
1370: }
1371: }
1372:
1373: if ((*s_etat_processus).echelle_log_y2 == d_vrai)
1374: {
1375: if (fprintf((*s_etat_processus).entree_standard,
1376: "set logscale y2\n") < 0)
1377: {
1378: (*s_etat_processus).erreur_systeme = d_es_processus;
1379: return;
1380: }
1381: }
1382: else
1383: {
1384: if (fprintf((*s_etat_processus).entree_standard,
1385: "unset logscale y2\n") < 0)
1386: {
1387: (*s_etat_processus).erreur_systeme = d_es_processus;
1388: return;
1389: }
1390: }
1391:
1392: if ((*s_etat_processus).echelle_log_z2 == d_vrai)
1393: {
1394: if (fprintf((*s_etat_processus).entree_standard,
1395: "set logscale z2\n") < 0)
1396: {
1397: (*s_etat_processus).erreur_systeme = d_es_processus;
1398: return;
1399: }
1400: }
1401: else
1402: {
1403: if (fprintf((*s_etat_processus).entree_standard,
1404: "unset logscale z2\n") < 0)
1405: {
1406: (*s_etat_processus).erreur_systeme = d_es_processus;
1407: return;
1408: }
1409: }
1410:
1411: /*
1412: * Gestion de la souris
1413: */
1414:
1415: if ((*s_etat_processus).souris_active == d_vrai)
1416: {
1417: if (fprintf((*s_etat_processus).entree_standard,
1418: "set mouse\n") < 0)
1419: {
1420: (*s_etat_processus).erreur_systeme = d_es_processus;
1421: return;
1422: }
1423: }
1424: else
1425: {
1426: if (fprintf((*s_etat_processus).entree_standard,
1427: "unset mouse\n") < 0)
1428: {
1429: (*s_etat_processus).erreur_systeme = d_es_processus;
1430: return;
1431: }
1432: }
1433:
1434: /*
1435: * Affichage des tracés
1436: */
1437:
1438: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
1439:
1440: if (strlen((*s_etat_processus).legende) > 0)
1441: {
1442: if (fprintf((*s_etat_processus).entree_standard,
1443: "set key outside autotitle title \"%s\"\n",
1444: (*s_etat_processus).legende) < 0)
1445: {
1446: (*s_etat_processus).erreur_systeme = d_es_processus;
1447: return;
1448: }
1449: }
1450: else
1451: {
1452: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
1453:
1454: while(l_fichier_courant != NULL)
1455: {
1456: if ((*l_fichier_courant).legende != NULL)
1457: {
1458: break;
1459: }
1460:
1461: l_fichier_courant = (*l_fichier_courant).suivant;
1462: }
1463:
1464: if (l_fichier_courant == NULL)
1465: {
1466: if (fprintf((*s_etat_processus).entree_standard, "unset key\n") < 0)
1467: {
1468: (*s_etat_processus).erreur_systeme = d_es_processus;
1469: return;
1470: }
1471: }
1472: else
1473: {
1474: if (fprintf((*s_etat_processus).entree_standard,
1475: "set key outside autotitle\n") < 0)
1476: {
1477: (*s_etat_processus).erreur_systeme = d_es_processus;
1478: return;
1479: }
1480: }
1481: }
1482:
1483: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
1484:
1485: if (l_fichier_courant != NULL)
1486: {
1487: if ((*l_fichier_courant).dimensions == 2)
1488: {
1489: if (strcmp((*l_fichier_courant).type, "HISTOGRAMME") == 0)
1490: {
1491: if (fprintf((*s_etat_processus).entree_standard,
1492: "set boxwidth %d\n",
1493: ds_gnuplot_option_largeur_histogramme) < 0)
1494: {
1495: (*s_etat_processus).erreur_systeme = d_es_processus;
1496: return;
1497: }
1498: }
1499:
1500: if (fprintf((*s_etat_processus).entree_standard, "%s ",
1501: ds_gnuplot_commande_trace_2D) < 0)
1502: {
1503: (*s_etat_processus).erreur_systeme = d_es_processus;
1504: return;
1505: }
1506: }
1507: else
1508: {
1509: if (strcmp((*l_fichier_courant).type, "GRILLE 3D") == 0)
1510: {
1511: if (fprintf((*s_etat_processus).entree_standard,
1512: "set hidden3d\n") < 0)
1513: {
1514: (*s_etat_processus).erreur_systeme = d_es_processus;
1515: return;
1516: }
1517: }
1518: else
1519: {
1520: if (fprintf((*s_etat_processus).entree_standard,
1521: "unset hidden3d\n") < 0)
1522: {
1523: (*s_etat_processus).erreur_systeme = d_es_processus;
1524: return;
1525: }
1526: }
1527:
1528: if (fprintf((*s_etat_processus).entree_standard, "%s ",
1529: ds_gnuplot_commande_trace_3D) < 0)
1530: {
1531: (*s_etat_processus).erreur_systeme = d_es_processus;
1532: return;
1533: }
1534: }
1535: }
1536:
1537: while(l_fichier_courant != NULL)
1538: {
1539: if ((strcmp((*l_fichier_courant).type, "FONCTION") == 0) ||
1540: (strcmp((*l_fichier_courant).type, "PARAMETRIQUE") == 0) ||
1541: (strcmp((*l_fichier_courant).type, "POLAIRE") == 0) ||
1542: (strcmp((*l_fichier_courant).type, "COURBES DE NIVEAU") == 0))
1543: {
1544: if (fprintf((*s_etat_processus).entree_standard,
1545: "\"%s\" axes %s %s",
1546: (*l_fichier_courant).nom,
1547: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1548: ds_gnuplot_option_2D) < 0)
1549: {
1550: (*s_etat_processus).erreur_systeme = d_es_processus;
1551: return;
1552: }
1553: }
1554: else if (strcmp((*l_fichier_courant).type, "POINTS") == 0)
1555: {
1556: if (fprintf((*s_etat_processus).entree_standard,
1557: "\"%s\" axes %s %s",
1558: (*l_fichier_courant).nom,
1559: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1560: ds_gnuplot_option_nuages) < 0)
1561: {
1562: (*s_etat_processus).erreur_systeme = d_es_processus;
1563: return;
1564: }
1565: }
1566: else if (strcmp((*l_fichier_courant).type, "HISTOGRAMME") == 0)
1567: {
1568: if (fprintf((*s_etat_processus).entree_standard,
1569: "\"%s\" axes %s %s",
1570: (*l_fichier_courant).nom,
1571: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1572: ds_gnuplot_option_histogramme)
1573: < 0)
1574: {
1575: (*s_etat_processus).erreur_systeme = d_es_processus;
1576: return;
1577: }
1578: }
1579: else if (strcmp((*l_fichier_courant).type, "TABLE TRACANTE") == 0)
1580: {
1581: if (fprintf((*s_etat_processus).entree_standard,
1582: "\"%s\" axes %s %s",
1583: (*l_fichier_courant).nom,
1584: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1585: ds_gnuplot_option_table_tracante)
1586: < 0)
1587: {
1588: (*s_etat_processus).erreur_systeme = d_es_processus;
1589: return;
1590: }
1591: }
1592: else if (strcmp((*l_fichier_courant).type, "DESSIN") == 0)
1593: {
1594: if (fprintf((*s_etat_processus).entree_standard,
1595: "\"%s\" axes %s %s",
1596: (*l_fichier_courant).nom,
1597: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1598: ds_gnuplot_option_table_tracante)
1599: < 0)
1600: {
1601: (*s_etat_processus).erreur_systeme = d_es_processus;
1602: return;
1603: }
1604: }
1605: else if (strcmp((*l_fichier_courant).type, "GRILLE 3D") == 0)
1606: {
1607: if (fprintf((*s_etat_processus).entree_standard, "\"%s\" %s",
1608: (*l_fichier_courant).nom, ds_gnuplot_option_3D) < 0)
1609: {
1610: (*s_etat_processus).erreur_systeme = d_es_processus;
1611: return;
1612: }
1613: }
1614:
1615: if ((*l_fichier_courant).legende == NULL)
1616: {
1617: if (fprintf((*s_etat_processus).entree_standard, " notitle") < 0)
1618: {
1619: (*s_etat_processus).erreur_systeme = d_es_processus;
1620: return;
1621: }
1622: }
1623: else
1624: {
1625: if (fprintf((*s_etat_processus).entree_standard, " title \"%s\"",
1626: (*l_fichier_courant).legende) < 0)
1627: {
1628: (*s_etat_processus).erreur_systeme = d_es_processus;
1629: return;
1630: }
1631: }
1632:
1633: if (fflush((*s_etat_processus).entree_standard) != 0)
1634: {
1635: (*s_etat_processus).erreur_systeme = d_es_processus;
1636: return;
1637: }
1638:
1639: l_fichier_courant = (*l_fichier_courant).suivant;
1640:
1641: if (l_fichier_courant != NULL)
1642: {
1643: if (fprintf((*s_etat_processus).entree_standard, ", ") < 0)
1644: {
1645: (*s_etat_processus).erreur_systeme = d_es_processus;
1646: return;
1647: }
1648: }
1649: }
1650:
1651: if (fprintf((*s_etat_processus).entree_standard, "\n") < 0)
1652: {
1653: (*s_etat_processus).erreur_systeme = d_es_processus;
1654: return;
1655: }
1656:
1657: if (fflush((*s_etat_processus).entree_standard) != 0)
1658: {
1659: (*s_etat_processus).erreur_systeme = d_es_processus;
1660: return;
1661: }
1662:
1663: if (persistance == 'I')
1664: {
1665: if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
1666: {
1667: (*s_etat_processus).erreur_systeme = d_es_processus;
1668: return;
1669: }
1670:
1671: if (fflush((*s_etat_processus).entree_standard) != 0)
1672: {
1673: (*s_etat_processus).erreur_systeme = d_es_processus;
1674: return;
1675: }
1676:
1677: if (pclose((*s_etat_processus).entree_standard) == -1)
1678: {
1679: (*s_etat_processus).erreur_systeme = d_es_processus;
1680: return;
1681: }
1682:
1683: (*s_etat_processus).entree_standard = entree_standard;
1684:
1685: /*
1686: * Création, le cas échéant, du fichier d'impression
1687: */
1688:
1689: if ((*s_etat_processus).nom_fichier_impression == NULL)
1690: {
1691: if ((fichier_impression =
1692: creation_fichier_tex(s_etat_processus)) == NULL)
1693: {
1694: return;
1695: }
1696: }
1697: else
1698: {
1699: if ((fichier_impression = fopen((*s_etat_processus)
1700: .nom_fichier_impression, "a")) == NULL)
1701: {
1702: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1703: return;
1704: }
1705: }
1706:
1707: if (fflush(NULL) != 0)
1708: {
1709: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1710: return;
1711: }
1712:
1713: if ((fichier_image = fopen(nom_fichier, "r")) == NULL)
1714: {
1715: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1716: return;
1717: }
1718:
1719: if (tex_fprintf(s_etat_processus, fichier_impression,
1720: "\\begin{figure}[hp]\n") < 0)
1721: {
1722: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1723: return;
1724: }
1725:
1726: while((caractere = getc(fichier_image)) != EOF)
1727: {
1728: if (putc(caractere, fichier_impression) == EOF)
1729: {
1730: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1731: return;
1732: }
1733: }
1734:
1735: if (fclose(fichier_image) != 0)
1736: {
1737: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1738: return;
1739: }
1740:
1741: if (strlen((*s_etat_processus).titre) > 0)
1742: {
1743: if (tex_fprintf(s_etat_processus, fichier_impression,
1744: "\\caption{%s}\n", (*s_etat_processus).titre) < 0)
1745: {
1746: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1747: return;
1748: }
1749: }
1750:
1751: if (tex_fprintf(s_etat_processus, fichier_impression,
1752: "\\end{figure}\n") < 0)
1753: {
1754: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1755: return;
1756: }
1757:
1758: if (fclose(fichier_impression) != 0)
1759: {
1760: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1761: return;
1762: }
1763:
1764: if (destruction_fichier(nom_fichier) == d_erreur)
1765: {
1766: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1767: return;
1768: }
1769:
1770: free(nom_fichier);
1771: }
1772: else if (persistance == 'E')
1773: {
1774: if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
1775: {
1776: (*s_etat_processus).erreur_systeme = d_es_processus;
1777: return;
1778: }
1779:
1780: if (fflush((*s_etat_processus).entree_standard) != 0)
1781: {
1782: (*s_etat_processus).erreur_systeme = d_es_processus;
1783: return;
1784: }
1785:
1786: if (pclose((*s_etat_processus).entree_standard) == -1)
1787: {
1788: (*s_etat_processus).erreur_systeme = d_es_processus;
1789: return;
1790: }
1791:
1792: (*s_etat_processus).entree_standard = entree_standard;
1793: }
1794: else if (entree_standard != NULL)
1795: {
1796: if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
1797: {
1798: (*s_etat_processus).erreur_systeme = d_es_processus;
1799: return;
1800: }
1801:
1802: if (fflush((*s_etat_processus).entree_standard) != 0)
1803: {
1804: (*s_etat_processus).erreur_systeme = d_es_processus;
1805: return;
1806: }
1807:
1808: if (pclose((*s_etat_processus).entree_standard) == -1)
1809: {
1810: (*s_etat_processus).erreur_systeme = d_es_processus;
1811: return;
1812: }
1813:
1814: (*s_etat_processus).entree_standard = entree_standard;
1815: }
1816:
1817: return;
1818: }
1819:
1820: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interface_gnuplot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src