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