1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.32
4: Copyright (C) 1989-2020 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24: #include "gnuplot-conv.h"
25:
26:
27: /*
28: ================================================================================
29: Fonction 'appel_gnuplot'
30: ================================================================================
31: Entrées : persistance 'E' écran, 'N' normal, 'I' impression, 'F' fichier
32: --------------------------------------------------------------------------------
33: Sorties : néant
34: --------------------------------------------------------------------------------
35: Effets de bord : néant
36: ================================================================================
37: */
38:
39: #ifdef OS2
40: static unsigned char *
41: ajout_shell(unsigned char *commande)
42: {
43: unsigned char *tampon;
44:
45: if ((tampon = malloc((strlen(BOURNE_SHELL) + 5 + strlen(commande) + 2) *
46: sizeof(unsigned char))) == NULL)
47: {
48: return(NULL);
49: }
50:
51: sprintf(tampon, "%s -c \"%s\"", BOURNE_SHELL, commande);
52: free(commande);
53: return(tampon);
54: }
55: #endif
56:
57: void
58: appel_gnuplot(struct_processus *s_etat_processus, unsigned char persistance)
59: {
60: file *entree_standard;
61: file *fichier_destination;
62: file *fichier_image;
63: file *fichier_impression;
64: file *fichier_source;
65:
66: int caractere;
67:
68: logical1 adequation_fichier;
69:
70: long compteur_nombre_fichiers;
71:
72: real8 phi;
73: real8 theta;
74:
75: struct_fichier_graphique *l_ancienne_base_liste;
76: struct_fichier_graphique *l_base_liste;
77: struct_fichier_graphique *l_fichier_courant;
78:
79: struct_marque *l_marque;
80:
81: unsigned char *nom_fichier;
82: unsigned char *commande_gnuplot;
83:
84: # ifndef GNUPLOT_SUPPORT
85: if ((*s_etat_processus).langue == 'F')
86: {
87: printf("+++Attention : Support de GnuPlot non compilé !\n");
88: }
89: else
90: {
91: printf("+++Warning : GnuPlot not available !\n");
92: }
93:
94: fflush(stdout);
95:
96: return;
97: # endif
98:
99: /*
100: * Comptage du nombre des fichiers et superposition le cas échéant
101: */
102:
103: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
104: compteur_nombre_fichiers = 0;
105: nom_fichier = NULL;
106:
107: while(l_fichier_courant != NULL)
108: {
109: compteur_nombre_fichiers++;
110: l_fichier_courant = (*l_fichier_courant).suivant;
111: }
112:
113: if (compteur_nombre_fichiers > ds_gnuplot_nombre_max_fichiers)
114: {
115: if ((*s_etat_processus).langue == 'F')
116: {
117: printf("+++Attention : Réduction du nombre de plans\n");
118: }
119: else
120: {
121: printf("+++Warning : Graphical depth reduction\n");
122: }
123:
124: l_base_liste = (*s_etat_processus).fichiers_graphiques;
125: (*s_etat_processus).fichiers_graphiques = NULL;
126:
127: while(l_base_liste != NULL)
128: {
129: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
130: adequation_fichier = d_faux;
131:
132: while(l_fichier_courant != NULL)
133: {
134: if ((strcmp((*l_fichier_courant).type, (*l_base_liste).type)
135: == 0) && ((*l_fichier_courant).systeme_axes ==
136: (*l_base_liste).systeme_axes))
137: {
138: adequation_fichier = d_vrai;
139: break;
140: }
141:
142: l_fichier_courant = (*l_fichier_courant).suivant;
143: }
144:
145: if (adequation_fichier == d_vrai)
146: {
147: if ((fichier_source = fopen((*l_base_liste).nom, "r"))
148: == NULL)
149: {
150: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
151: return;
152: }
153:
154: if ((fichier_destination = fopen((*l_fichier_courant).nom,
155: "a")) == NULL)
156: {
157: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
158: return;
159: }
160:
161: if (fprintf(fichier_destination, "\n") < 0)
162: {
163: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
164: return;
165: }
166:
167: while((caractere = getc(fichier_source)) != EOF)
168: {
169: if (putc(caractere, fichier_destination) == EOF)
170: {
171: (*s_etat_processus).erreur_systeme =
172: d_es_erreur_fichier;
173: return;
174: }
175: }
176:
177: if (fclose(fichier_source) != 0)
178: {
179: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
180: return;
181: }
182:
183: if (fclose(fichier_destination) != 0)
184: {
185: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
186: return;
187: }
188:
189: if (((*l_fichier_courant).presence_axes == d_vrai) ||
190: ((*l_base_liste).presence_axes == d_vrai))
191: {
192: (*l_fichier_courant).presence_axes = d_vrai;
193: }
194: else
195: {
196: (*l_fichier_courant).presence_axes = d_faux;
197: }
198:
199: if (destruction_fichier((*l_base_liste).nom) == d_erreur)
200: {
201: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
202: return;
203: }
204:
205: free((*l_base_liste).nom);
206:
207: if ((*l_base_liste).legende != NULL)
208: {
209: free((*l_base_liste).legende);
210: }
211: }
212: else
213: {
214: l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
215:
216: if (l_fichier_courant == NULL)
217: {
218: if (((*s_etat_processus).fichiers_graphiques =
219: (struct_fichier_graphique *) malloc(
220: sizeof(struct_fichier_graphique))) == NULL)
221: {
222: (*s_etat_processus).erreur_systeme =
223: d_es_allocation_memoire;
224: return;
225: }
226:
227: (*(*s_etat_processus).fichiers_graphiques).suivant = NULL;
228: (*(*s_etat_processus).fichiers_graphiques).nom =
229: (*l_base_liste).nom;
230: (*(*s_etat_processus).fichiers_graphiques).legende = NULL;
231: (*(*s_etat_processus).fichiers_graphiques).presence_axes =
232: (*l_base_liste).presence_axes;
233: strcpy((*(*s_etat_processus).fichiers_graphiques).type,
234: (*l_base_liste).type);
235: (*(*s_etat_processus).fichiers_graphiques).dimensions =
236: (*l_base_liste).dimensions;
237: (*(*s_etat_processus).fichiers_graphiques).systeme_axes =
238: (*l_base_liste).systeme_axes;
239: }
240: else
241: {
242: while((*l_fichier_courant).suivant != NULL)
243: {
244: l_fichier_courant = (*l_fichier_courant).suivant;
245: }
246:
247: if (((*l_fichier_courant).suivant =
248: (struct_fichier_graphique *) malloc(
249: sizeof(struct_fichier_graphique))) == NULL)
250: {
251: (*s_etat_processus).erreur_systeme =
252: d_es_allocation_memoire;
253: return;
254: }
255:
256: l_fichier_courant = (*l_fichier_courant).suivant;
257:
258: (*l_fichier_courant).suivant = NULL;
259: (*l_fichier_courant).nom = (*l_base_liste).nom;
260: (*l_fichier_courant).legende = NULL;
261: (*l_fichier_courant).presence_axes = d_faux;
262: strcpy((*l_fichier_courant).type, (*l_base_liste).type);
263: (*l_fichier_courant).dimensions =
264: (*l_base_liste).dimensions;
265: (*l_fichier_courant).systeme_axes =
266: (*l_base_liste).systeme_axes;
267: }
268: }
269:
270: l_ancienne_base_liste = l_base_liste;
271: l_base_liste = (*l_base_liste).suivant;
272: free(l_ancienne_base_liste);
273: }
274: }
275:
276: /*
277: * Traitement du cas où l'afficheur n'est pas persistant
278: */
279:
280: if (persistance == 'N')
281: {
282: entree_standard = NULL;
283:
284: if ((*s_etat_processus).entree_standard == NULL)
285: {
286: #ifdef FORCE_GNUPLOT_PATH
287: if ((*s_etat_processus).rpl_home == NULL)
288: {
289: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
290: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
291: == NULL)
292: {
293: (*s_etat_processus).erreur_systeme =
294: d_es_allocation_memoire;
295: return;
296: }
297:
298: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
299: ds_gnuplot_commande);
300: }
301: else
302: {
303: if ((commande_gnuplot = malloc((strlen(
304: (*s_etat_processus).rpl_home) + 6 +
305: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
306: == NULL)
307: {
308: (*s_etat_processus).erreur_systeme =
309: d_es_allocation_memoire;
310: return;
311: }
312:
313: sprintf(commande_gnuplot, "%s/bin/%s",
314: (*s_etat_processus).rpl_home, ds_gnuplot_commande);
315: }
316: #else
317: if ((commande_gnuplot = malloc((1 +
318: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
319: == NULL)
320: {
321: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
322: return;
323: }
324:
325: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
326: #endif
327:
328: #ifdef OS2
329: if ((commande_gnuplot = ajout_shell(commande_gnuplot)) == NULL)
330: {
331: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
332: return;
333: }
334: #endif
335:
336: if (((*s_etat_processus).entree_standard =
337: popen(commande_gnuplot, "w")) == NULL)
338: {
339: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
340: return;
341: }
342:
343: free(commande_gnuplot);
344:
345: if (fprintf((*s_etat_processus).entree_standard,
346: "%s\n", ds_gnuplot_terminal_defaut) < 0)
347: {
348: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
349: return;
350: }
351: }
352:
353: if (strlen((*s_etat_processus).titre) > 0)
354: {
355: if (fprintf((*s_etat_processus).entree_standard,
356: "set title \"%s\"\n", (*s_etat_processus).titre) < 0)
357: {
358: (*s_etat_processus).erreur_systeme = d_es_processus;
359: return;
360: }
361: }
362: }
363: else if (persistance == 'E') /* Ecran */
364: {
365: entree_standard = (*s_etat_processus).entree_standard;
366:
367: #if FORCE_GNUPLOT_PATH
368: if ((*s_etat_processus).rpl_home == NULL)
369: {
370: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
371: strlen(ds_gnuplot_commande_persistante)) *
372: sizeof(unsigned char))) == NULL)
373: {
374: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
375: return;
376: }
377:
378: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
379: ds_gnuplot_commande_persistante);
380: }
381: else
382: {
383: if ((commande_gnuplot = malloc((strlen(
384: (*s_etat_processus).rpl_home) + 6 +
385: strlen(ds_gnuplot_commande_persistante)) *
386: sizeof(unsigned char))) == NULL)
387: {
388: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
389: return;
390: }
391:
392: sprintf(commande_gnuplot, "%s/bin/%s", (*s_etat_processus).rpl_home,
393: ds_gnuplot_commande_persistante);
394: }
395: #else
396: if ((commande_gnuplot = malloc((1 +
397: strlen(ds_gnuplot_commande_persistante)) *
398: sizeof(unsigned char))) == NULL)
399: {
400: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
401: return;
402: }
403:
404: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande_persistante);
405: #endif
406:
407: #ifdef OS2
408: if ((commande_gnuplot = ajout_shell(commande_gnuplot)) == NULL)
409: {
410: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
411: return;
412: }
413: #endif
414:
415: if (((*s_etat_processus).entree_standard =
416: popen(commande_gnuplot, "w")) == NULL)
417: {
418: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
419: return;
420: }
421:
422: free(commande_gnuplot);
423:
424: if (fprintf((*s_etat_processus).entree_standard,
425: "%s\n", ds_gnuplot_terminal_defaut) < 0)
426: {
427: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
428: return;
429: }
430:
431: if (strlen((*s_etat_processus).titre) > 0)
432: {
433: if (fprintf((*s_etat_processus).entree_standard,
434: "set title \"%s\"\n", (*s_etat_processus).titre) < 0)
435: {
436: (*s_etat_processus).erreur_systeme = d_es_processus;
437: return;
438: }
439: }
440: }
441: else if (persistance == 'I') /* Imprimante */
442: {
443: entree_standard = (*s_etat_processus).entree_standard;
444:
445: #ifdef FORCE_GNUPLOT_PATH
446: if ((*s_etat_processus).rpl_home == NULL)
447: {
448: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
449: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
450: == NULL)
451: {
452: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
453: return;
454: }
455:
456: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
457: ds_gnuplot_commande);
458: }
459: else
460: {
461: if ((commande_gnuplot = malloc((strlen((*s_etat_processus).rpl_home)
462: + 6 + strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
463: == NULL)
464: {
465: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
466: return;
467: }
468:
469: sprintf(commande_gnuplot, "%s/bin/%s", (*s_etat_processus).rpl_home,
470: ds_gnuplot_commande);
471: }
472: #else
473: if ((commande_gnuplot = malloc((1 +
474: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
475: == NULL)
476: {
477: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
478: return;
479: }
480:
481: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
482: #endif
483:
484: #ifdef OS2
485: if ((commande_gnuplot = ajout_shell(commande_gnuplot)) == NULL)
486: {
487: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
488: return;
489: }
490: #endif
491:
492: if (((*s_etat_processus).entree_standard =
493: popen(commande_gnuplot, "w")) == NULL)
494: {
495: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
496: return;
497: }
498:
499: free(commande_gnuplot);
500:
501: if (fprintf((*s_etat_processus).entree_standard,
502: "%s\n", ds_gnuplot_terminal_defaut) < 0)
503: {
504: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
505: return;
506: }
507:
508: if ((nom_fichier = creation_nom_fichier(s_etat_processus,
509: (*s_etat_processus).chemin_fichiers_temporaires)) == NULL)
510: {
511: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
512: return;
513: }
514:
515: if (fprintf((*s_etat_processus).entree_standard,
516: "set terminal latex\n") < 0)
517: {
518: (*s_etat_processus).erreur_systeme = d_es_processus;
519: return;
520: }
521:
522: if (fprintf((*s_etat_processus).entree_standard, "set output \"%s\"\n",
523: nom_fichier) < 0)
524: {
525: (*s_etat_processus).erreur_systeme = d_es_processus;
526: return;
527: }
528: }
529: else /* persistance == 'F' comme fichier */
530: {
531: entree_standard = (*s_etat_processus).entree_standard;
532:
533: #ifdef FORCE_GNUPLOT_PATH
534: if ((*s_etat_processus).rpl_home == NULL)
535: {
536: if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
537: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
538: == NULL)
539: {
540: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
541: return;
542: }
543:
544: sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
545: ds_gnuplot_commande);
546: }
547: else
548: {
549: if ((commande_gnuplot = malloc((strlen((*s_etat_processus).rpl_home)
550: + 6 + strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
551: == NULL)
552: {
553: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
554: return;
555: }
556:
557: sprintf(commande_gnuplot, "%s/bin/%s", (*s_etat_processus).rpl_home,
558: ds_gnuplot_commande);
559: }
560: #else
561: if ((commande_gnuplot = malloc((1 +
562: strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
563: == NULL)
564: {
565: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
566: return;
567: }
568:
569: sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
570: #endif
571:
572: #ifdef OS2
573: if ((commande_gnuplot = ajout_shell(commande_gnuplot)) == NULL)
574: {
575: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
576: return;
577: }
578: #endif
579:
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:
1837: if (tex_fprintf(s_etat_processus, fichier_impression,
1838: "\\begin{figure}[hp]\n") < 0)
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:
1853: if (fclose(fichier_image) != 0)
1854: {
1855: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1856: return;
1857: }
1858:
1859: if (strlen((*s_etat_processus).titre) > 0)
1860: {
1861: if (tex_fprintf(s_etat_processus, fichier_impression,
1862: "\\caption{%s}\n", (*s_etat_processus).titre) < 0)
1863: {
1864: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1865: return;
1866: }
1867: }
1868:
1869: if (tex_fprintf(s_etat_processus, fichier_impression,
1870: "\\end{figure}\n") < 0)
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
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interface_gnuplot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src