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