1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.12
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 ((*s_etat_processus).rpl_home == NULL)
270: {
271: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
272: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
273: == NULL)
274: {
275: (*s_etat_processus).erreur_systeme =
276: d_es_allocation_memoire;
277: return;
278: }
279:
280: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
281: ds_gnuplot_commande);
282: }
283: else
284: {
285: if ((commande_gnuplot = malloc((strlen(
286: (*s_etat_processus).rpl_home) + 6 +
287: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
288: == NULL)
289: {
290: (*s_etat_processus).erreur_systeme =
291: d_es_allocation_memoire;
292: return;
293: }
294:
295: sprintf(commande_gnuplot, "%s/bin/%s",
296: (*s_etat_processus).rpl_home, ds_gnuplot_commande);
297: }
298: #else
299: if ((commande_gnuplot = malloc((1 +
300: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
301: == NULL)
302: {
303: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
304: return;
305: }
306:
307: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
308: #endif
309:
310: if (((*s_etat_processus).entree_standard =
311: popen(commande_gnuplot, "w")) == NULL)
312: {
313: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
314: return;
315: }
316:
317: free(commande_gnuplot);
318:
319: if (fprintf((*s_etat_processus).entree_standard,
320: "%s\n", ds_gnuplot_terminal_defaut) < 0)
321: {
322: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
323: return;
324: }
325: }
326:
327: if (strlen((*s_etat_processus).titre) > 0)
328: {
329: if (fprintf((*s_etat_processus).entree_standard,
330: "set title \"%s\"\n", (*s_etat_processus).titre) < 0)
331: {
332: (*s_etat_processus).erreur_systeme = d_es_processus;
333: return;
334: }
335: }
336: }
337: else if (persistance == 'E') /* Ecran */
338: {
339: entree_standard = (*s_etat_processus).entree_standard;
340:
341: #if FORCE_GNUPLOT_PATH
342: if ((*s_etat_processus).rpl_home == NULL)
343: {
344: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
345: strlen(ds_gnuplot_commande_persistante)) *
346: sizeof(unsigned char))) == NULL)
347: {
348: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
349: return;
350: }
351:
352: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
353: ds_gnuplot_commande_persistante);
354: }
355: else
356: {
357: if ((commande_gnuplot = malloc((strlen(
358: (*s_etat_processus).rpl_home) + 6 +
359: strlen(ds_gnuplot_commande_persistante)) *
360: sizeof(unsigned char))) == NULL)
361: {
362: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
363: return;
364: }
365:
366: sprintf(commande_gnuplot, "%s/bin/%s", (*s_etat_processus).rpl_home,
367: ds_gnuplot_commande_persistante);
368: }
369: #else
370: if ((commande_gnuplot = malloc((1 +
371: strlen(ds_gnuplot_commande_persistante)) *
372: sizeof(unsigned char))) == NULL)
373: {
374: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
375: return;
376: }
377:
378: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande_persistante);
379: #endif
380:
381: if (((*s_etat_processus).entree_standard =
382: popen(commande_gnuplot, "w")) == NULL)
383: {
384: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
385: return;
386: }
387:
388: free(commande_gnuplot);
389:
390: if (fprintf((*s_etat_processus).entree_standard,
391: "%s\n", ds_gnuplot_terminal_defaut) < 0)
392: {
393: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
394: return;
395: }
396:
397: if (strlen((*s_etat_processus).titre) > 0)
398: {
399: if (fprintf((*s_etat_processus).entree_standard,
400: "set title \"%s\"\n", (*s_etat_processus).titre) < 0)
401: {
402: (*s_etat_processus).erreur_systeme = d_es_processus;
403: return;
404: }
405: }
406: }
407: else if (persistance == 'I') /* Imprimante */
408: {
409: entree_standard = (*s_etat_processus).entree_standard;
410:
411: #ifdef FORCE_GNUPLOT_PATH
412: if ((*s_etat_processus).rpl_home == NULL)
413: {
414: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
415: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
416: == NULL)
417: {
418: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
419: return;
420: }
421:
422: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
423: ds_gnuplot_commande);
424: }
425: else
426: {
427: if ((commande_gnuplot = malloc((strlen((*s_etat_processus).rpl_home)
428: + 6 + strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
429: == NULL)
430: {
431: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
432: return;
433: }
434:
435: sprintf(commande_gnuplot, "%s/bin/%s", (*s_etat_processus).rpl_home,
436: ds_gnuplot_commande);
437: }
438: #else
439: if ((commande_gnuplot = malloc((1 +
440: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
441: == NULL)
442: {
443: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
444: return;
445: }
446:
447: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
448: #endif
449:
450: if (((*s_etat_processus).entree_standard =
451: popen(commande_gnuplot, "w")) == NULL)
452: {
453: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
454: return;
455: }
456:
457: free(commande_gnuplot);
458:
459: if (fprintf((*s_etat_processus).entree_standard,
460: "%s\n", ds_gnuplot_terminal_defaut) < 0)
461: {
462: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
463: return;
464: }
465:
466: if ((nom_fichier = creation_nom_fichier(s_etat_processus,
467: (*s_etat_processus).chemin_fichiers_temporaires)) == NULL)
468: {
469: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
470: return;
471: }
472:
473: if (fprintf((*s_etat_processus).entree_standard,
474: "set terminal latex\n") < 0)
475: {
476: (*s_etat_processus).erreur_systeme = d_es_processus;
477: return;
478: }
479:
480: if (fprintf((*s_etat_processus).entree_standard, "set output \"%s\"\n",
481: nom_fichier) < 0)
482: {
483: (*s_etat_processus).erreur_systeme = d_es_processus;
484: return;
485: }
486: }
487: else /* persistance == 'F' comme fichier */
488: {
489: entree_standard = (*s_etat_processus).entree_standard;
490:
491: #ifdef FORCE_GNUPLOT_PATH
492: if ((*s_etat_processus).rpl_home == NULL)
493: {
494: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
495: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
496: == NULL)
497: {
498: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
499: return;
500: }
501:
502: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
503: ds_gnuplot_commande);
504: }
505: else
506: {
507: if ((commande_gnuplot = malloc((strlen((*s_etat_processus).rpl_home)
508: + 6 + strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
509: == NULL)
510: {
511: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
512: return;
513: }
514:
515: sprintf(commande_gnuplot, "%s/bin/%s", (*s_etat_processus).rpl_home,
516: ds_gnuplot_commande);
517: }
518: #else
519: if ((commande_gnuplot = malloc((1 +
520: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
521: == NULL)
522: {
523: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
524: return;
525: }
526:
527: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
528: #endif
529:
530: if (((*s_etat_processus).entree_standard =
531: popen(commande_gnuplot, "w")) == NULL)
532: {
533: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
534: return;
535: }
536:
537: free(commande_gnuplot);
538:
539: if (fprintf((*s_etat_processus).entree_standard, "set terminal %s\n",
540: (*s_etat_processus).type_fichier_gnuplot) < 0)
541: {
542: (*s_etat_processus).erreur_systeme = d_es_processus;
543: return;
544: }
545:
546: if (fprintf((*s_etat_processus).entree_standard, "set output \"%s\"\n",
547: (*s_etat_processus).nom_fichier_gnuplot) < 0)
548: {
549: (*s_etat_processus).erreur_systeme = d_es_processus;
550: return;
551: }
552:
553: free((*s_etat_processus).nom_fichier_gnuplot);
554: free((*s_etat_processus).type_fichier_gnuplot);
555:
556: (*s_etat_processus).nom_fichier_gnuplot = NULL;
557: (*s_etat_processus).type_fichier_gnuplot = NULL;
558:
559: if (strlen((*s_etat_processus).titre) > 0)
560: {
561: if (fprintf((*s_etat_processus).entree_standard,
562: "set title \"%s\"\n", (*s_etat_processus).titre) < 0)
563: {
564: (*s_etat_processus).erreur_systeme = d_es_processus;
565: return;
566: }
567: }
568: }
569:
570: /*
571: * Affichace des marques
572: */
573:
574: l_marque = (*s_etat_processus).s_marques;
575:
576: while(l_marque != NULL)
577: {
578: if (fprintf((*s_etat_processus).entree_standard,
579: "set label \"%s\" at %s point front offset 0.2,0.2\n",
580: (*l_marque).label, (*l_marque).position) < 0)
581: {
582: (*s_etat_processus).erreur_systeme = d_es_processus;
583: return;
584: }
585:
586: l_marque = (*l_marque).suivant;
587: }
588:
589: /*
590: * Affichage, le cas échéant, des graduations
591: */
592:
593: if ((*s_etat_processus).x_tics < 0)
594: {
595: if (fprintf((*s_etat_processus).entree_standard, "unset xtics\n") < 0)
596: {
597: (*s_etat_processus).erreur_systeme = d_es_processus;
598: return;
599: }
600: }
601: else if ((*s_etat_processus).x_tics == 0)
602: {
603: if (fprintf((*s_etat_processus).entree_standard,
604: "set xtics autofreq\n") < 0)
605: {
606: (*s_etat_processus).erreur_systeme = d_es_processus;
607: return;
608: }
609: }
610: else
611: {
612: if (fprintf((*s_etat_processus).entree_standard, "set xtics %f\n",
613: (*s_etat_processus).x_tics) < 0)
614: {
615: (*s_etat_processus).erreur_systeme = d_es_processus;
616: return;
617: }
618: }
619:
620: if ((*s_etat_processus).mx_tics < 0)
621: {
622: if (fprintf((*s_etat_processus).entree_standard, "unset mxtics\n") < 0)
623: {
624: (*s_etat_processus).erreur_systeme = d_es_processus;
625: return;
626: }
627: }
628: else if ((*s_etat_processus).mx_tics == 0)
629: {
630: if (fprintf((*s_etat_processus).entree_standard,
631: "set mxtics default\n") < 0)
632: {
633: (*s_etat_processus).erreur_systeme = d_es_processus;
634: return;
635: }
636: }
637: else
638: {
639: if (fprintf((*s_etat_processus).entree_standard, "set mxtics %lld\n",
640: (*s_etat_processus).mx_tics) < 0)
641: {
642: (*s_etat_processus).erreur_systeme = d_es_processus;
643: return;
644: }
645: }
646:
647: if ((*s_etat_processus).y_tics < 0)
648: {
649: if (fprintf((*s_etat_processus).entree_standard, "unset ytics\n") < 0)
650: {
651: (*s_etat_processus).erreur_systeme = d_es_processus;
652: return;
653: }
654: }
655: else if ((*s_etat_processus).y_tics == 0)
656: {
657: if (fprintf((*s_etat_processus).entree_standard,
658: "set ytics autofreq\n") < 0)
659: {
660: (*s_etat_processus).erreur_systeme = d_es_processus;
661: return;
662: }
663: }
664: else
665: {
666: if (fprintf((*s_etat_processus).entree_standard, "set ytics %f\n",
667: (*s_etat_processus).y_tics) < 0)
668: {
669: (*s_etat_processus).erreur_systeme = d_es_processus;
670: return;
671: }
672: }
673:
674: if ((*s_etat_processus).my_tics < 0)
675: {
676: if (fprintf((*s_etat_processus).entree_standard, "unset mytics\n") < 0)
677: {
678: (*s_etat_processus).erreur_systeme = d_es_processus;
679: return;
680: }
681: }
682: else if ((*s_etat_processus).my_tics == 0)
683: {
684: if (fprintf((*s_etat_processus).entree_standard,
685: "set mytics default\n") < 0)
686: {
687: (*s_etat_processus).erreur_systeme = d_es_processus;
688: return;
689: }
690: }
691: else
692: {
693: if (fprintf((*s_etat_processus).entree_standard, "set mytics %lld\n",
694: (*s_etat_processus).my_tics) < 0)
695: {
696: (*s_etat_processus).erreur_systeme = d_es_processus;
697: return;
698: }
699: }
700:
701: if ((*s_etat_processus).z_tics < 0)
702: {
703: if (fprintf((*s_etat_processus).entree_standard, "unset ztics\n") < 0)
704: {
705: (*s_etat_processus).erreur_systeme = d_es_processus;
706: return;
707: }
708: }
709: else if ((*s_etat_processus).z_tics == 0)
710: {
711: if (fprintf((*s_etat_processus).entree_standard,
712: "set ztics autofreq\n") < 0)
713: {
714: (*s_etat_processus).erreur_systeme = d_es_processus;
715: return;
716: }
717: }
718: else
719: {
720: if (fprintf((*s_etat_processus).entree_standard, "set ztics %f\n",
721: (*s_etat_processus).z_tics) < 0)
722: {
723: (*s_etat_processus).erreur_systeme = d_es_processus;
724: return;
725: }
726: }
727:
728: if ((*s_etat_processus).mz_tics < 0)
729: {
730: if (fprintf((*s_etat_processus).entree_standard, "unset mztics\n") < 0)
731: {
732: (*s_etat_processus).erreur_systeme = d_es_processus;
733: return;
734: }
735: }
736: else if ((*s_etat_processus).mz_tics == 0)
737: {
738: if (fprintf((*s_etat_processus).entree_standard,
739: "set mztics default\n") < 0)
740: {
741: (*s_etat_processus).erreur_systeme = d_es_processus;
742: return;
743: }
744: }
745: else
746: {
747: if (fprintf((*s_etat_processus).entree_standard, "set mztics %lld\n",
748: (*s_etat_processus).mz_tics) < 0)
749: {
750: (*s_etat_processus).erreur_systeme = d_es_processus;
751: return;
752: }
753: }
754:
755: if ((*s_etat_processus).x2_tics < 0)
756: {
757: if (fprintf((*s_etat_processus).entree_standard, "unset x2tics\n") < 0)
758: {
759: (*s_etat_processus).erreur_systeme = d_es_processus;
760: return;
761: }
762: }
763: else if ((*s_etat_processus).x2_tics == 0)
764: {
765: if (fprintf((*s_etat_processus).entree_standard,
766: "set x2tics autofreq\n") < 0)
767: {
768: (*s_etat_processus).erreur_systeme = d_es_processus;
769: return;
770: }
771: }
772: else
773: {
774: if (fprintf((*s_etat_processus).entree_standard, "set x2tics %f\n",
775: (*s_etat_processus).x2_tics) < 0)
776: {
777: (*s_etat_processus).erreur_systeme = d_es_processus;
778: return;
779: }
780: }
781:
782: if ((*s_etat_processus).mx2_tics < 0)
783: {
784: if (fprintf((*s_etat_processus).entree_standard, "unset mx2tics\n") < 0)
785: {
786: (*s_etat_processus).erreur_systeme = d_es_processus;
787: return;
788: }
789: }
790: else if ((*s_etat_processus).mx2_tics == 0)
791: {
792: if (fprintf((*s_etat_processus).entree_standard,
793: "set mx2tics default\n") < 0)
794: {
795: (*s_etat_processus).erreur_systeme = d_es_processus;
796: return;
797: }
798: }
799: else
800: {
801: if (fprintf((*s_etat_processus).entree_standard, "set mx2tics %lld\n",
802: (*s_etat_processus).mx2_tics) < 0)
803: {
804: (*s_etat_processus).erreur_systeme = d_es_processus;
805: return;
806: }
807: }
808:
809: if ((*s_etat_processus).y2_tics < 0)
810: {
811: if (fprintf((*s_etat_processus).entree_standard, "unset y2tics\n") < 0)
812: {
813: (*s_etat_processus).erreur_systeme = d_es_processus;
814: return;
815: }
816: }
817: else if ((*s_etat_processus).y2_tics == 0)
818: {
819: if (fprintf((*s_etat_processus).entree_standard,
820: "set y2tics autofreq\n") < 0)
821: {
822: (*s_etat_processus).erreur_systeme = d_es_processus;
823: return;
824: }
825: }
826: else
827: {
828: if (fprintf((*s_etat_processus).entree_standard, "set y2tics %f\n",
829: (*s_etat_processus).y2_tics) < 0)
830: {
831: (*s_etat_processus).erreur_systeme = d_es_processus;
832: return;
833: }
834: }
835:
836: if ((*s_etat_processus).my2_tics < 0)
837: {
838: if (fprintf((*s_etat_processus).entree_standard, "unset my2tics\n") < 0)
839: {
840: (*s_etat_processus).erreur_systeme = d_es_processus;
841: return;
842: }
843: }
844: else if ((*s_etat_processus).my2_tics == 0)
845: {
846: if (fprintf((*s_etat_processus).entree_standard,
847: "set my2tics default\n") < 0)
848: {
849: (*s_etat_processus).erreur_systeme = d_es_processus;
850: return;
851: }
852: }
853: else
854: {
855: if (fprintf((*s_etat_processus).entree_standard, "set my2tics %lld\n",
856: (*s_etat_processus).my2_tics) < 0)
857: {
858: (*s_etat_processus).erreur_systeme = d_es_processus;
859: return;
860: }
861: }
862:
863: if ((*s_etat_processus).z2_tics < 0)
864: {
865: if (fprintf((*s_etat_processus).entree_standard, "unset z2tics\n") < 0)
866: {
867: (*s_etat_processus).erreur_systeme = d_es_processus;
868: return;
869: }
870: }
871: else if ((*s_etat_processus).z2_tics == 0)
872: {
873: if (fprintf((*s_etat_processus).entree_standard,
874: "set z2tics autofreq\n") < 0)
875: {
876: (*s_etat_processus).erreur_systeme = d_es_processus;
877: return;
878: }
879: }
880: else
881: {
882: if (fprintf((*s_etat_processus).entree_standard, "set z2tics %f\n",
883: (*s_etat_processus).z2_tics) < 0)
884: {
885: (*s_etat_processus).erreur_systeme = d_es_processus;
886: return;
887: }
888: }
889:
890: if ((*s_etat_processus).mz2_tics < 0)
891: {
892: if (fprintf((*s_etat_processus).entree_standard, "unset mz2tics\n") < 0)
893: {
894: (*s_etat_processus).erreur_systeme = d_es_processus;
895: return;
896: }
897: }
898: else if ((*s_etat_processus).mz2_tics == 0)
899: {
900: if (fprintf((*s_etat_processus).entree_standard,
901: "set mz2tics default\n") < 0)
902: {
903: (*s_etat_processus).erreur_systeme = d_es_processus;
904: return;
905: }
906: }
907: else
908: {
909: if (fprintf((*s_etat_processus).entree_standard, "set mz2tics %lld\n",
910: (*s_etat_processus).mz2_tics) < 0)
911: {
912: (*s_etat_processus).erreur_systeme = d_es_processus;
913: return;
914: }
915: }
916:
917: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
918:
919: while(l_fichier_courant != NULL)
920: {
921: if ((*l_fichier_courant).presence_axes == d_vrai)
922: {
923: if ((*s_etat_processus).x_lines == d_vrai)
924: {
925: if (fprintf((*s_etat_processus).entree_standard,
926: "set grid xtics\n") < 0)
927: {
928: (*s_etat_processus).erreur_systeme = d_es_processus;
929: return;
930: }
931: }
932:
933: if ((*s_etat_processus).y_lines == d_vrai)
934: {
935: if (fprintf((*s_etat_processus).entree_standard,
936: "set grid ytics\n") < 0)
937: {
938: (*s_etat_processus).erreur_systeme = d_es_processus;
939: return;
940: }
941: }
942:
943: if ((*s_etat_processus).z_lines == d_vrai)
944: {
945: if (fprintf((*s_etat_processus).entree_standard,
946: "set grid ztics\n") < 0)
947: {
948: (*s_etat_processus).erreur_systeme = d_es_processus;
949: return;
950: }
951: }
952:
953: if ((*s_etat_processus).x2_lines == d_vrai)
954: {
955: if (fprintf((*s_etat_processus).entree_standard,
956: "set grid x2tics\n") < 0)
957: {
958: (*s_etat_processus).erreur_systeme = d_es_processus;
959: return;
960: }
961: }
962:
963: if ((*s_etat_processus).y2_lines == d_vrai)
964: {
965: if (fprintf((*s_etat_processus).entree_standard,
966: "set grid y2tics\n") < 0)
967: {
968: (*s_etat_processus).erreur_systeme = d_es_processus;
969: return;
970: }
971: }
972:
973: if ((*s_etat_processus).z2_lines == d_vrai)
974: {
975: if (fprintf((*s_etat_processus).entree_standard,
976: "set grid z2tics\n") < 0)
977: {
978: (*s_etat_processus).erreur_systeme = d_es_processus;
979: return;
980: }
981: }
982:
983: if ((*s_etat_processus).mx_lines == d_vrai)
984: {
985: if (fprintf((*s_etat_processus).entree_standard,
986: "set grid mxtics\n") < 0)
987: {
988: (*s_etat_processus).erreur_systeme = d_es_processus;
989: return;
990: }
991: }
992:
993: if ((*s_etat_processus).my_lines == d_vrai)
994: {
995: if (fprintf((*s_etat_processus).entree_standard,
996: "set grid mytics\n") < 0)
997: {
998: (*s_etat_processus).erreur_systeme = d_es_processus;
999: return;
1000: }
1001: }
1002:
1003: if ((*s_etat_processus).mz_lines == d_vrai)
1004: {
1005: if (fprintf((*s_etat_processus).entree_standard,
1006: "set grid mztics\n") < 0)
1007: {
1008: (*s_etat_processus).erreur_systeme = d_es_processus;
1009: return;
1010: }
1011: }
1012:
1013: if ((*s_etat_processus).mx2_lines == d_vrai)
1014: {
1015: if (fprintf((*s_etat_processus).entree_standard,
1016: "set grid mx2tics\n") < 0)
1017: {
1018: (*s_etat_processus).erreur_systeme = d_es_processus;
1019: return;
1020: }
1021: }
1022:
1023: if ((*s_etat_processus).my2_lines == d_vrai)
1024: {
1025: if (fprintf((*s_etat_processus).entree_standard,
1026: "set grid my2tics\n") < 0)
1027: {
1028: (*s_etat_processus).erreur_systeme = d_es_processus;
1029: return;
1030: }
1031: }
1032:
1033: if ((*s_etat_processus).mz2_lines == d_vrai)
1034: {
1035: if (fprintf((*s_etat_processus).entree_standard,
1036: "set grid mz2tics\n") < 0)
1037: {
1038: (*s_etat_processus).erreur_systeme = d_es_processus;
1039: return;
1040: }
1041: }
1042:
1043: if ((strcmp((*l_fichier_courant).type, "FONCTION") == 0) ||
1044: (strcmp((*l_fichier_courant).type, "PARAMETRIQUE") == 0) ||
1045: (strcmp((*l_fichier_courant).type, "POINTS") == 0) ||
1046: (strcmp((*l_fichier_courant).type, "HISTOGRAMME") == 0) ||
1047: (strcmp((*l_fichier_courant).type, "TABLE TRACANTE") == 0)
1048: || (strcmp((*l_fichier_courant).type, "COURBES DE NIVEAU")
1049: == 0) ||
1050: (strcmp((*l_fichier_courant).type, "GRILLE 3D") == 0))
1051: {
1052: if (fprintf((*s_etat_processus).entree_standard,
1053: "set grid\n") < 0)
1054: {
1055: (*s_etat_processus).erreur_systeme = d_es_processus;
1056: return;
1057: }
1058: }
1059: else if (strcmp((*l_fichier_courant).type, "POLAIRE") == 0)
1060: {
1061: if (fprintf((*s_etat_processus).entree_standard,
1062: "set xtics axis nomirror\n") < 0)
1063: {
1064: (*s_etat_processus).erreur_systeme = d_es_processus;
1065: return;
1066: }
1067:
1068: if (fprintf((*s_etat_processus).entree_standard,
1069: "set ytics axis nomirror\n") < 0)
1070: {
1071: (*s_etat_processus).erreur_systeme = d_es_processus;
1072: return;
1073: }
1074:
1075: if (fprintf((*s_etat_processus).entree_standard,
1076: "set grid polar\n") < 0)
1077: {
1078: (*s_etat_processus).erreur_systeme = d_es_processus;
1079: return;
1080: }
1081:
1082: if (fprintf((*s_etat_processus).entree_standard,
1083: "set size square\n") < 0)
1084: {
1085: (*s_etat_processus).erreur_systeme = d_es_processus;
1086: return;
1087: }
1088:
1089: if (fprintf((*s_etat_processus).entree_standard,
1090: "unset x2tics\n") < 0)
1091: {
1092: (*s_etat_processus).erreur_systeme = d_es_processus;
1093: return;
1094: }
1095:
1096: if (fprintf((*s_etat_processus).entree_standard,
1097: "unset y2tics\n") < 0)
1098: {
1099: (*s_etat_processus).erreur_systeme = d_es_processus;
1100: return;
1101: }
1102:
1103: if (fprintf((*s_etat_processus).entree_standard,
1104: "unset z2tics\n") < 0)
1105: {
1106: (*s_etat_processus).erreur_systeme = d_es_processus;
1107: return;
1108: }
1109:
1110: if (fprintf((*s_etat_processus).entree_standard,
1111: "unset mx2tics\n") < 0)
1112: {
1113: (*s_etat_processus).erreur_systeme = d_es_processus;
1114: return;
1115: }
1116:
1117: if (fprintf((*s_etat_processus).entree_standard,
1118: "unset my2tics\n") < 0)
1119: {
1120: (*s_etat_processus).erreur_systeme = d_es_processus;
1121: return;
1122: }
1123:
1124: if (fprintf((*s_etat_processus).entree_standard,
1125: "unset mz2tics\n") < 0)
1126: {
1127: (*s_etat_processus).erreur_systeme = d_es_processus;
1128: return;
1129: }
1130: }
1131: }
1132:
1133: l_fichier_courant = (*l_fichier_courant).suivant;
1134: }
1135:
1136: /*
1137: * Gestion des noms des axes
1138: */
1139:
1140: if (fprintf((*s_etat_processus).entree_standard,
1141: "set xlabel \"%s\"\n", (*s_etat_processus).label_x) < 0)
1142: {
1143: (*s_etat_processus).erreur_systeme = d_es_processus;
1144: return;
1145: }
1146:
1147: if (fprintf((*s_etat_processus).entree_standard,
1148: "set ylabel \"%s\"\n", (*s_etat_processus).label_y) < 0)
1149: {
1150: (*s_etat_processus).erreur_systeme = d_es_processus;
1151: return;
1152: }
1153:
1154: if (fprintf((*s_etat_processus).entree_standard,
1155: "set zlabel \"%s\"\n", (*s_etat_processus).label_z) < 0)
1156: {
1157: (*s_etat_processus).erreur_systeme = d_es_processus;
1158: return;
1159: }
1160:
1161:
1162: /*
1163: * Gestion des échelles automatiques
1164: */
1165:
1166: if ((*s_etat_processus).echelle_automatique_x == d_vrai)
1167: {
1168: if (fprintf((*s_etat_processus).entree_standard,
1169: "set autoscale x\n") < 0)
1170: {
1171: (*s_etat_processus).erreur_systeme = d_es_processus;
1172: return;
1173: }
1174: }
1175: else
1176: {
1177: if (fprintf((*s_etat_processus).entree_standard,
1178: "unset autoscale x\n") < 0)
1179: {
1180: (*s_etat_processus).erreur_systeme = d_es_processus;
1181: return;
1182: }
1183:
1184: if (fprintf((*s_etat_processus).entree_standard, "set xrange [%f:%f]\n",
1185: (*s_etat_processus).x_min, (*s_etat_processus).x_max) < 0)
1186: {
1187: (*s_etat_processus).erreur_systeme = d_es_processus;
1188: return;
1189: }
1190: }
1191:
1192: if ((*s_etat_processus).echelle_automatique_x2 == d_vrai)
1193: {
1194: if (fprintf((*s_etat_processus).entree_standard,
1195: "set autoscale x2\n") < 0)
1196: {
1197: (*s_etat_processus).erreur_systeme = d_es_processus;
1198: return;
1199: }
1200: }
1201: else
1202: {
1203: if (fprintf((*s_etat_processus).entree_standard,
1204: "unset autoscale x2\n") < 0)
1205: {
1206: (*s_etat_processus).erreur_systeme = d_es_processus;
1207: return;
1208: }
1209:
1210: if (fprintf((*s_etat_processus).entree_standard,
1211: "set x2range [%f:%f]\n",
1212: (*s_etat_processus).x2_min, (*s_etat_processus).x2_max) < 0)
1213: {
1214: (*s_etat_processus).erreur_systeme = d_es_processus;
1215: return;
1216: }
1217: }
1218:
1219: if ((*s_etat_processus).echelle_automatique_y == d_vrai)
1220: {
1221: if (fprintf((*s_etat_processus).entree_standard,
1222: "set autoscale y\n") < 0)
1223: {
1224: (*s_etat_processus).erreur_systeme = d_es_processus;
1225: return;
1226: }
1227: }
1228: else
1229: {
1230: if (fprintf((*s_etat_processus).entree_standard,
1231: "unset autoscale y\n") < 0)
1232: {
1233: (*s_etat_processus).erreur_systeme = d_es_processus;
1234: return;
1235: }
1236:
1237: if (fprintf((*s_etat_processus).entree_standard, "set yrange [%f:%f]\n",
1238: (*s_etat_processus).y_min, (*s_etat_processus).y_max) < 0)
1239: {
1240: (*s_etat_processus).erreur_systeme = d_es_processus;
1241: return;
1242: }
1243: }
1244:
1245: if ((*s_etat_processus).echelle_automatique_y2 == d_vrai)
1246: {
1247: if (fprintf((*s_etat_processus).entree_standard,
1248: "set autoscale y2\n") < 0)
1249: {
1250: (*s_etat_processus).erreur_systeme = d_es_processus;
1251: return;
1252: }
1253: }
1254: else
1255: {
1256: if (fprintf((*s_etat_processus).entree_standard,
1257: "unset autoscale y2\n") < 0)
1258: {
1259: (*s_etat_processus).erreur_systeme = d_es_processus;
1260: return;
1261: }
1262:
1263: if (fprintf((*s_etat_processus).entree_standard,
1264: "set y2range [%f:%f]\n",
1265: (*s_etat_processus).y2_min, (*s_etat_processus).y2_max) < 0)
1266: {
1267: (*s_etat_processus).erreur_systeme = d_es_processus;
1268: return;
1269: }
1270: }
1271:
1272: if ((*s_etat_processus).echelle_automatique_z == d_vrai)
1273: {
1274: if (fprintf((*s_etat_processus).entree_standard,
1275: "set autoscale z\n") < 0)
1276: {
1277: (*s_etat_processus).erreur_systeme = d_es_processus;
1278: return;
1279: }
1280: }
1281: else
1282: {
1283: if (fprintf((*s_etat_processus).entree_standard,
1284: "unset autoscale z\n") < 0)
1285: {
1286: (*s_etat_processus).erreur_systeme = d_es_processus;
1287: return;
1288: }
1289:
1290: if (fprintf((*s_etat_processus).entree_standard, "set zrange [%f:%f]\n",
1291: (*s_etat_processus).z_min, (*s_etat_processus).z_max) < 0)
1292: {
1293: (*s_etat_processus).erreur_systeme = d_es_processus;
1294: return;
1295: }
1296: }
1297:
1298: if ((*s_etat_processus).echelle_automatique_z2 == d_vrai)
1299: {
1300: if (fprintf((*s_etat_processus).entree_standard,
1301: "set autoscale z2\n") < 0)
1302: {
1303: (*s_etat_processus).erreur_systeme = d_es_processus;
1304: return;
1305: }
1306: }
1307: else
1308: {
1309: if (fprintf((*s_etat_processus).entree_standard,
1310: "unset autoscale z2\n") < 0)
1311: {
1312: (*s_etat_processus).erreur_systeme = d_es_processus;
1313: return;
1314: }
1315:
1316: if (fprintf((*s_etat_processus).entree_standard,
1317: "set z2range [%f:%f]\n",
1318: (*s_etat_processus).z_min, (*s_etat_processus).z_max) < 0)
1319: {
1320: (*s_etat_processus).erreur_systeme = d_es_processus;
1321: return;
1322: }
1323: }
1324:
1325: /*
1326: * Position du point de vue
1327: */
1328:
1329: theta = (*s_etat_processus).point_de_vue_theta;
1330: phi = (*s_etat_processus).point_de_vue_phi;
1331:
1332: conversion_radians_vers_degres(&theta);
1333: conversion_radians_vers_degres(&phi);
1334:
1335: if (theta < 0)
1336: {
1337: theta = 0;
1338: }
1339: else if (theta > 360)
1340: {
1341: theta = 360;
1342: }
1343:
1344: if (phi < 0)
1345: {
1346: phi = 0;
1347: }
1348: else if (phi > 180)
1349: {
1350: phi = 180;
1351: }
1352:
1353: if (fprintf((*s_etat_processus).entree_standard,
1354: "set view %f,%f,1,%f\n", phi, theta,
1355: (*s_etat_processus).echelle_3D) < 0)
1356: {
1357: (*s_etat_processus).erreur_systeme = d_es_processus;
1358: return;
1359: }
1360:
1361: /*
1362: * Gestion des échelles logarithmiques
1363: */
1364:
1365: if ((*s_etat_processus).echelle_log_x == d_vrai)
1366: {
1367: if (fprintf((*s_etat_processus).entree_standard,
1368: "set logscale x\n") < 0)
1369: {
1370: (*s_etat_processus).erreur_systeme = d_es_processus;
1371: return;
1372: }
1373: }
1374: else
1375: {
1376: if (fprintf((*s_etat_processus).entree_standard,
1377: "unset logscale x\n") < 0)
1378: {
1379: (*s_etat_processus).erreur_systeme = d_es_processus;
1380: return;
1381: }
1382: }
1383:
1384: if ((*s_etat_processus).echelle_log_y == d_vrai)
1385: {
1386: if (fprintf((*s_etat_processus).entree_standard,
1387: "set logscale y\n") < 0)
1388: {
1389: (*s_etat_processus).erreur_systeme = d_es_processus;
1390: return;
1391: }
1392: }
1393: else
1394: {
1395: if (fprintf((*s_etat_processus).entree_standard,
1396: "unset logscale y\n") < 0)
1397: {
1398: (*s_etat_processus).erreur_systeme = d_es_processus;
1399: return;
1400: }
1401: }
1402:
1403: if ((*s_etat_processus).echelle_log_z == d_vrai)
1404: {
1405: if (fprintf((*s_etat_processus).entree_standard,
1406: "set logscale z\n") < 0)
1407: {
1408: (*s_etat_processus).erreur_systeme = d_es_processus;
1409: return;
1410: }
1411: }
1412: else
1413: {
1414: if (fprintf((*s_etat_processus).entree_standard,
1415: "unset logscale z\n") < 0)
1416: {
1417: (*s_etat_processus).erreur_systeme = d_es_processus;
1418: return;
1419: }
1420: }
1421:
1422: if ((*s_etat_processus).echelle_log_x2 == d_vrai)
1423: {
1424: if (fprintf((*s_etat_processus).entree_standard,
1425: "set logscale x2\n") < 0)
1426: {
1427: (*s_etat_processus).erreur_systeme = d_es_processus;
1428: return;
1429: }
1430: }
1431: else
1432: {
1433: if (fprintf((*s_etat_processus).entree_standard,
1434: "unset logscale x2\n") < 0)
1435: {
1436: (*s_etat_processus).erreur_systeme = d_es_processus;
1437: return;
1438: }
1439: }
1440:
1441: if ((*s_etat_processus).echelle_log_y2 == d_vrai)
1442: {
1443: if (fprintf((*s_etat_processus).entree_standard,
1444: "set logscale y2\n") < 0)
1445: {
1446: (*s_etat_processus).erreur_systeme = d_es_processus;
1447: return;
1448: }
1449: }
1450: else
1451: {
1452: if (fprintf((*s_etat_processus).entree_standard,
1453: "unset logscale y2\n") < 0)
1454: {
1455: (*s_etat_processus).erreur_systeme = d_es_processus;
1456: return;
1457: }
1458: }
1459:
1460: if ((*s_etat_processus).echelle_log_z2 == d_vrai)
1461: {
1462: if (fprintf((*s_etat_processus).entree_standard,
1463: "set logscale z2\n") < 0)
1464: {
1465: (*s_etat_processus).erreur_systeme = d_es_processus;
1466: return;
1467: }
1468: }
1469: else
1470: {
1471: if (fprintf((*s_etat_processus).entree_standard,
1472: "unset logscale z2\n") < 0)
1473: {
1474: (*s_etat_processus).erreur_systeme = d_es_processus;
1475: return;
1476: }
1477: }
1478:
1479: /*
1480: * Gestion de la souris
1481: */
1482:
1483: if ((*s_etat_processus).souris_active == d_vrai)
1484: {
1485: if (fprintf((*s_etat_processus).entree_standard,
1486: "set mouse\n") < 0)
1487: {
1488: (*s_etat_processus).erreur_systeme = d_es_processus;
1489: return;
1490: }
1491: }
1492: else
1493: {
1494: if (fprintf((*s_etat_processus).entree_standard,
1495: "unset mouse\n") < 0)
1496: {
1497: (*s_etat_processus).erreur_systeme = d_es_processus;
1498: return;
1499: }
1500: }
1501:
1502: /*
1503: * Affichage des tracés
1504: */
1505:
1506: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
1507:
1508: if (strlen((*s_etat_processus).legende) > 0)
1509: {
1510: if (fprintf((*s_etat_processus).entree_standard,
1511: "set key outside autotitle title \"%s\"\n",
1512: (*s_etat_processus).legende) < 0)
1513: {
1514: (*s_etat_processus).erreur_systeme = d_es_processus;
1515: return;
1516: }
1517: }
1518: else
1519: {
1520: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
1521:
1522: while(l_fichier_courant != NULL)
1523: {
1524: if ((*l_fichier_courant).legende != NULL)
1525: {
1526: break;
1527: }
1528:
1529: l_fichier_courant = (*l_fichier_courant).suivant;
1530: }
1531:
1532: if (l_fichier_courant == NULL)
1533: {
1534: if (fprintf((*s_etat_processus).entree_standard, "unset key\n") < 0)
1535: {
1536: (*s_etat_processus).erreur_systeme = d_es_processus;
1537: return;
1538: }
1539: }
1540: else
1541: {
1542: if (fprintf((*s_etat_processus).entree_standard,
1543: "set key outside autotitle\n") < 0)
1544: {
1545: (*s_etat_processus).erreur_systeme = d_es_processus;
1546: return;
1547: }
1548: }
1549: }
1550:
1551: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
1552:
1553: if (l_fichier_courant != NULL)
1554: {
1555: if ((*l_fichier_courant).dimensions == 2)
1556: {
1557: if (strcmp((*l_fichier_courant).type, "HISTOGRAMME") == 0)
1558: {
1559: if (fprintf((*s_etat_processus).entree_standard,
1560: "set boxwidth %d\n",
1561: ds_gnuplot_option_largeur_histogramme) < 0)
1562: {
1563: (*s_etat_processus).erreur_systeme = d_es_processus;
1564: return;
1565: }
1566: }
1567:
1568: if (fprintf((*s_etat_processus).entree_standard, "%s ",
1569: ds_gnuplot_commande_trace_2D) < 0)
1570: {
1571: (*s_etat_processus).erreur_systeme = d_es_processus;
1572: return;
1573: }
1574: }
1575: else
1576: {
1577: if (strcmp((*l_fichier_courant).type, "GRILLE 3D") == 0)
1578: {
1579: if (fprintf((*s_etat_processus).entree_standard,
1580: "set hidden3d\n") < 0)
1581: {
1582: (*s_etat_processus).erreur_systeme = d_es_processus;
1583: return;
1584: }
1585: }
1586: else
1587: {
1588: if (fprintf((*s_etat_processus).entree_standard,
1589: "unset hidden3d\n") < 0)
1590: {
1591: (*s_etat_processus).erreur_systeme = d_es_processus;
1592: return;
1593: }
1594: }
1595:
1596: if (fprintf((*s_etat_processus).entree_standard, "%s ",
1597: ds_gnuplot_commande_trace_3D) < 0)
1598: {
1599: (*s_etat_processus).erreur_systeme = d_es_processus;
1600: return;
1601: }
1602: }
1603: }
1604:
1605: while(l_fichier_courant != NULL)
1606: {
1607: if ((strcmp((*l_fichier_courant).type, "FONCTION") == 0) ||
1608: (strcmp((*l_fichier_courant).type, "PARAMETRIQUE") == 0) ||
1609: (strcmp((*l_fichier_courant).type, "POLAIRE") == 0) ||
1610: (strcmp((*l_fichier_courant).type, "COURBES DE NIVEAU") == 0))
1611: {
1612: if (fprintf((*s_etat_processus).entree_standard,
1613: "\"%s\" axes %s %s",
1614: (*l_fichier_courant).nom,
1615: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1616: ds_gnuplot_option_2D) < 0)
1617: {
1618: (*s_etat_processus).erreur_systeme = d_es_processus;
1619: return;
1620: }
1621: }
1622: else if (strcmp((*l_fichier_courant).type, "POINTS") == 0)
1623: {
1624: if (fprintf((*s_etat_processus).entree_standard,
1625: "\"%s\" axes %s %s",
1626: (*l_fichier_courant).nom,
1627: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1628: ds_gnuplot_option_nuages) < 0)
1629: {
1630: (*s_etat_processus).erreur_systeme = d_es_processus;
1631: return;
1632: }
1633: }
1634: else if (strcmp((*l_fichier_courant).type, "HISTOGRAMME") == 0)
1635: {
1636: if (fprintf((*s_etat_processus).entree_standard,
1637: "\"%s\" axes %s %s",
1638: (*l_fichier_courant).nom,
1639: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1640: ds_gnuplot_option_histogramme)
1641: < 0)
1642: {
1643: (*s_etat_processus).erreur_systeme = d_es_processus;
1644: return;
1645: }
1646: }
1647: else if (strcmp((*l_fichier_courant).type, "TABLE TRACANTE") == 0)
1648: {
1649: if (fprintf((*s_etat_processus).entree_standard,
1650: "\"%s\" axes %s %s",
1651: (*l_fichier_courant).nom,
1652: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1653: ds_gnuplot_option_table_tracante)
1654: < 0)
1655: {
1656: (*s_etat_processus).erreur_systeme = d_es_processus;
1657: return;
1658: }
1659: }
1660: else if (strcmp((*l_fichier_courant).type, "DESSIN") == 0)
1661: {
1662: if (fprintf((*s_etat_processus).entree_standard,
1663: "\"%s\" axes %s %s",
1664: (*l_fichier_courant).nom,
1665: ((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
1666: ds_gnuplot_option_table_tracante)
1667: < 0)
1668: {
1669: (*s_etat_processus).erreur_systeme = d_es_processus;
1670: return;
1671: }
1672: }
1673: else if (strcmp((*l_fichier_courant).type, "GRILLE 3D") == 0)
1674: {
1675: if (fprintf((*s_etat_processus).entree_standard, "\"%s\" %s",
1676: (*l_fichier_courant).nom, ds_gnuplot_option_3D) < 0)
1677: {
1678: (*s_etat_processus).erreur_systeme = d_es_processus;
1679: return;
1680: }
1681: }
1682:
1683: if ((*l_fichier_courant).legende == NULL)
1684: {
1685: if (fprintf((*s_etat_processus).entree_standard, " notitle") < 0)
1686: {
1687: (*s_etat_processus).erreur_systeme = d_es_processus;
1688: return;
1689: }
1690: }
1691: else
1692: {
1693: if (fprintf((*s_etat_processus).entree_standard, " title \"%s\"",
1694: (*l_fichier_courant).legende) < 0)
1695: {
1696: (*s_etat_processus).erreur_systeme = d_es_processus;
1697: return;
1698: }
1699: }
1700:
1701: if (fflush((*s_etat_processus).entree_standard) != 0)
1702: {
1703: (*s_etat_processus).erreur_systeme = d_es_processus;
1704: return;
1705: }
1706:
1707: l_fichier_courant = (*l_fichier_courant).suivant;
1708:
1709: if (l_fichier_courant != NULL)
1710: {
1711: if (fprintf((*s_etat_processus).entree_standard, ", ") < 0)
1712: {
1713: (*s_etat_processus).erreur_systeme = d_es_processus;
1714: return;
1715: }
1716: }
1717: }
1718:
1719: if (fprintf((*s_etat_processus).entree_standard, "\n") < 0)
1720: {
1721: (*s_etat_processus).erreur_systeme = d_es_processus;
1722: return;
1723: }
1724:
1725: if (fflush((*s_etat_processus).entree_standard) != 0)
1726: {
1727: (*s_etat_processus).erreur_systeme = d_es_processus;
1728: return;
1729: }
1730:
1731: if (persistance == 'I')
1732: {
1733: if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
1734: {
1735: (*s_etat_processus).erreur_systeme = d_es_processus;
1736: return;
1737: }
1738:
1739: if (fflush((*s_etat_processus).entree_standard) != 0)
1740: {
1741: (*s_etat_processus).erreur_systeme = d_es_processus;
1742: return;
1743: }
1744:
1745: if (pclose((*s_etat_processus).entree_standard) == -1)
1746: {
1747: (*s_etat_processus).erreur_systeme = d_es_processus;
1748: return;
1749: }
1750:
1751: (*s_etat_processus).entree_standard = entree_standard;
1752:
1753: /*
1754: * Création, le cas échéant, du fichier d'impression
1755: */
1756:
1757: if ((*s_etat_processus).nom_fichier_impression == NULL)
1758: {
1759: if ((fichier_impression =
1760: creation_fichier_tex(s_etat_processus)) == NULL)
1761: {
1762: return;
1763: }
1764: }
1765: else
1766: {
1767: if ((fichier_impression = fopen((*s_etat_processus)
1768: .nom_fichier_impression, "a")) == NULL)
1769: {
1770: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1771: return;
1772: }
1773: }
1774:
1775: if (fflush(NULL) != 0)
1776: {
1777: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1778: return;
1779: }
1780:
1781: if ((fichier_image = fopen(nom_fichier, "r")) == NULL)
1782: {
1783: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1784: return;
1785: }
1786:
1787: if (tex_fprintf(s_etat_processus, fichier_impression,
1788: "\\begin{figure}[hp]\n") < 0)
1789: {
1790: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1791: return;
1792: }
1793:
1794: while((caractere = getc(fichier_image)) != EOF)
1795: {
1796: if (putc(caractere, fichier_impression) == EOF)
1797: {
1798: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1799: return;
1800: }
1801: }
1802:
1803: if (fclose(fichier_image) != 0)
1804: {
1805: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1806: return;
1807: }
1808:
1809: if (strlen((*s_etat_processus).titre) > 0)
1810: {
1811: if (tex_fprintf(s_etat_processus, fichier_impression,
1812: "\\caption{%s}\n", (*s_etat_processus).titre) < 0)
1813: {
1814: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1815: return;
1816: }
1817: }
1818:
1819: if (tex_fprintf(s_etat_processus, fichier_impression,
1820: "\\end{figure}\n") < 0)
1821: {
1822: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1823: return;
1824: }
1825:
1826: if (fclose(fichier_impression) != 0)
1827: {
1828: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1829: return;
1830: }
1831:
1832: if (destruction_fichier(nom_fichier) == d_erreur)
1833: {
1834: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1835: return;
1836: }
1837:
1838: free(nom_fichier);
1839: }
1840: else if (persistance == 'E')
1841: {
1842: if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
1843: {
1844: (*s_etat_processus).erreur_systeme = d_es_processus;
1845: return;
1846: }
1847:
1848: if (fflush((*s_etat_processus).entree_standard) != 0)
1849: {
1850: (*s_etat_processus).erreur_systeme = d_es_processus;
1851: return;
1852: }
1853:
1854: if (pclose((*s_etat_processus).entree_standard) == -1)
1855: {
1856: (*s_etat_processus).erreur_systeme = d_es_processus;
1857: return;
1858: }
1859:
1860: (*s_etat_processus).entree_standard = entree_standard;
1861: }
1862: else if (entree_standard != NULL)
1863: {
1864: if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
1865: {
1866: (*s_etat_processus).erreur_systeme = d_es_processus;
1867: return;
1868: }
1869:
1870: if (fflush((*s_etat_processus).entree_standard) != 0)
1871: {
1872: (*s_etat_processus).erreur_systeme = d_es_processus;
1873: return;
1874: }
1875:
1876: if (pclose((*s_etat_processus).entree_standard) == -1)
1877: {
1878: (*s_etat_processus).erreur_systeme = d_es_processus;
1879: return;
1880: }
1881:
1882: (*s_etat_processus).entree_standard = entree_standard;
1883: }
1884:
1885: return;
1886: }
1887:
1888: // 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