source: SH_SHM/trunk/source/newgraph/psch.c @ 341

Revision 341, 20.2 KB checked in by marcus, 9 years ago (diff)

r180 | walther | 2011-03-09 16:27:03 +0100 (Mi, 09 Mär 2011) | 3 lines

Merging most of the changes from marcus' branch. For full details please see
http://www.seismic-handler.org/portal/log/SH_SHM/branches/marcus?revs=101-106,123-171

Line 
1
2/* file PSCH.C
3 *      ======
4 *
5 * version 14, 5-Apr-2006
6 *
7 * PostScript channel for graphics output module
8 * K. Stammler, 20-JUN-1991
9 */
10
11/* #define BSD */
12
13
14#include <stdio.h>
15#include <string.h>
16#include BASECNST
17#include BC_SYSBASE
18#include "graphbas.h"
19#include "psusrdef.h"
20#include "pserrors.h"
21
22#ifdef BSD
23#include <sys/time.h>
24#endif
25
26
27/* global constants */
28#define PSC_MAXSTYLE 10
29        /* maximum number of different line styles */
30#define DEFAULTWIDTH 100.0
31        /* default width of user coo */
32#define DEFAULTHEIGHT 100.0
33        /* default height of user coo */
34#define DEFAULTPLOTW 25.9
35#define DEFAULTPLOTH 19.5
36        /* default plot size */
37#define MAXDEFSTYLE 6
38        /* number of default styles */
39#define DOTSPERCM 118.11 /*28.35*/
40        /* resolution of printer */
41
42#define PSFILENAME "HC_TMP"
43        /* PostScript file */
44#define PSHEADER "header.ps"
45        /* default PostScript header file */
46
47
48/* global variable */
49static char psv_outputdir[BC_FILELTH+1];  /* output directory */
50static char psv_inputdir[BC_FILELTH+1];   /* input directory */
51
52
53/* global variables */
54static BOOLEAN psv_isinit;    /* calcomp is initialised */
55static PSOUT   psv_width;     /* width of display */
56static PSOUT   psv_height;    /* heigth of display */
57static PSOUT   psv_xoffset;   /* x-offset */
58static PSOUT   psv_yoffset;   /* y-offset */
59static float   psv_trafo_xf;  /* trafo x-factor */
60static float   psv_trafo_yf;  /* trafo y-factor */
61static PSOUT   psv_trafo_xo;  /* x-offset */
62static PSOUT   psv_trafo_yo;  /* y-offset */
63static BOOLEAN psv_arrayswap=FALSE;      /* swap arrayplot coo's */
64static int     psv_currstyle; /* currently used style */
65static float   psv_csize[PSC_MAXSTYLE];  /* character sizes (units of height) */
66static float   psv_lwidth[PSC_MAXSTYLE]; /* line widths */
67static FILE    *psv_pf;       /* pointer to PostScript file */
68static BOOLEAN psv_move=FALSE;/* moveto buffer is not empty */
69static GBC_COO psv_move_x;    /* moveto x-coo */
70static GBC_COO psv_move_y;    /* moveto y-coo */
71
72static char    psv_currpsf[BC_FILELTH+1];   /* name of active PS file */
73static int     psv_strokenum=5000; /* max number of lineto's between stroke's */
74static char    psv_headerfile[BC_FILELTH+1]=PSHEADER; /* PS header file */
75
76/* prototypes of local routines */
77void psh_trafo( GBC_COO ux, GBC_COO uy, PSOUT *dx, PSOUT *dy );
78void psh_create_hcname( char name[] );
79void psh_insertheader( FILE *ps );
80void psh_closepsf( FILE *ps );
81void psh_changestyle( int style );
82
83/*----------------------------------------------------------------------------*/
84
85
86
87void ps_init( int attribs, PSOUT xlo, PSOUT ylo, PSOUT width, PSOUT height,
88        STATUS *status )
89
90/* initialises PostScript channel
91 *
92 * parameters of routine
93 * int        attribs;        input; attributes
94 * PSOUT      xlo, ylo;       input; offset of output
95 * PSOUT      width, height;  input; size of output
96 * STATUS     *status;        output; return status
97 */
98{
99        /* local variables */
100        int      i;      /* counter */
101        FILE     *fp;    /* file pointer */
102
103        /* executable code */
104
105        if  (attribs == 0)  {
106                ;                  /* just to access attrib once */
107        } /*endif*/
108
109        xlo *= DOTSPERCM; ylo *= DOTSPERCM; width *= DOTSPERCM; height *= DOTSPERCM;
110
111        if  (*psv_currpsf == '\0')  {
112                if  (strlen(psv_currpsf)+strlen(PSFILENAME)+8 > BC_FILELTH)  {
113                        *status = PSE_STROVFL;
114                        return;
115                } /*endif*/
116                /* search for existing files */
117                i = 0;
118                FOREVER  {
119                        sprintf( psv_currpsf, "%s%s%05d.ps", psv_outputdir, PSFILENAME, i );
120                        fp = fopen( psv_currpsf, "r" );
121                        if  (fp == NULL)  break;
122                        fclose( fp );
123                        i++;
124                } /*endfor*/
125        } /*endif*/
126
127        if  ((width <= 0.0) || (height <= 0.0))  {
128                *status = PSE_ILPAR;
129                return;
130        } /*endif*/
131
132        if  (psv_isinit)  ps_exit();
133
134        psv_xoffset = xlo;
135        psv_yoffset = ylo;
136        psv_width = width;
137        psv_height = height;
138
139        psv_currstyle = 0;
140        for  (i=0; i<PSC_MAXSTYLE; i++)
141                if  (psv_csize[i] == 0.0)
142                        psv_csize[i] = 40.0;
143        for  (i=0; i<PSC_MAXSTYLE; i++)
144                if  (psv_lwidth[i] == 0.0)
145                        psv_lwidth[i] = 0.4;
146
147        /* open PostScript file */
148        psv_pf = sy_fopen( psv_currpsf, "w" );
149        if  (psv_pf == NULL)  {
150                *status = PSE_FOPNWR;
151                return;
152        } /*endif*/
153        psv_isinit = TRUE;
154        psv_move = FALSE;
155
156        psh_insertheader( psv_pf );
157        ps_setcoo( 0., 0., DEFAULTWIDTH, DEFAULTHEIGHT, status );
158
159} /* end of ps_init */
160
161
162
163/*----------------------------------------------------------------------------*/
164
165
166
167void ps_exit( void )
168
169/* exits PostScript channel
170 *
171 * no parameters
172 */
173{
174        /* executable code */
175
176        if  (!psv_isinit)  return;
177        fclose( psv_pf );
178        sy_fdelete( psv_currpsf );
179        psv_isinit = FALSE;
180
181} /* end of ps_exit */
182
183
184
185/*----------------------------------------------------------------------------*/
186
187
188
189void ps_resize( PSOUT xlo, PSOUT ylo, PSOUT width, PSOUT height,
190        STATUS *status )
191
192/* resizes output of calcomp
193 *
194 * parameters of routine
195 * PSOUT      xlo, ylo;       input; offset of output
196 * PSOUT      width, height;  input; size of output
197 * STATUS     *status;        output; return status
198 */
199{
200        /* executable code */
201
202        xlo *= DOTSPERCM; ylo *= DOTSPERCM; width *= DOTSPERCM; height *= DOTSPERCM;
203
204        if  ((width <= 0.0) || (height <= 0.0))  {
205                *status = PSE_ILPAR;
206                return;
207        } /*endif*/
208
209        if  (!psv_isinit)  ps_init( 0, 0.0, 0.0, DEFAULTPLOTW, DEFAULTPLOTH, status);
210
211        psv_xoffset = xlo;
212        psv_yoffset = ylo;
213        psv_width = width;
214        psv_height = height;
215
216} /* end of ps_resize */
217
218
219
220/*----------------------------------------------------------------------------*/
221
222
223
224void ps_erase( void )
225
226/* clears calcomp output channel
227 *
228 * no parameters
229 */
230{
231        /* local variables */
232        int      dmy=0;
233
234        /* executable code */
235
236        if  (psv_isinit)  {
237                fseek( psv_pf, 0L, 0 );
238                psh_insertheader( psv_pf );
239                psv_currstyle = 0;
240        } else {
241                ps_init( 0, 0.0, 0.0, DEFAULTPLOTW, DEFAULTPLOTH, &dmy );
242        } /*endif*/
243        psv_move = FALSE;
244
245} /* end of ps_erase */
246
247
248
249/*----------------------------------------------------------------------------*/
250
251
252
253void ps_setcoo( GBC_COO x, GBC_COO y, GBC_COO w, GBC_COO h, STATUS *status )
254
255/* sets user coordinates
256 *
257 * parameters of routine
258 * GBC_COO    x, y;     input; offset
259 * GBC_COO    w, h;     input; size
260 * STATUS     *status;  output; return status
261 */
262{
263        /* executable code */
264
265        if  ((w <= 0.0) || (h <= 0.0))  {
266                *status = PSE_ILPAR;
267                return;
268        } /*endif*/
269
270        if  (!psv_isinit)  ps_init( 0, 0.0, 0.0, DEFAULTPLOTW, DEFAULTPLOTH, status);
271
272        psv_trafo_xf = psv_width / w;
273        psv_trafo_yf = psv_height / h;
274        psv_trafo_xo = psv_xoffset - x*psv_trafo_xf;
275        psv_trafo_yo = psv_yoffset - y*psv_trafo_yf;
276
277} /* end of ps_setcoo */
278
279
280
281/*----------------------------------------------------------------------------*/
282
283
284
285void ps_moveto( GBC_COO x, GBC_COO y )
286
287/* moves to position (x,y) in user coordinates
288 *
289 * parameters of routine
290 * GBC_COO    x, y;    input; position
291 */
292{
293        /* local variables */
294        STATUS   dmy=0;    /* scratch */
295
296        /* executable code */
297
298        if  (!psv_isinit)  ps_init( 0, 0.0, 0.0, DEFAULTPLOTW, DEFAULTPLOTH, &dmy );
299
300        psv_move_x = x;
301        psv_move_y = y;
302        psv_move = TRUE;
303
304} /* end of ps_moveto */
305
306
307
308/*----------------------------------------------------------------------------*/
309
310
311
312void ps_drawto( int style, GBC_COO x, GBC_COO y )
313
314/* draws to position (x,y) in user coordinates
315 *
316 * parameters of routine
317 * int        style;   input; style parameter
318 * GBC_COO    x, y;    input; position
319 */
320{
321        /* local variables */
322        static int linecnt=0; /* counter of lineto commands */
323        PSOUT    dx, dy;      /* device coordinates */
324        STATUS   dmy=0;       /* scratch */
325
326        /* executable code */
327
328        if  (!psv_isinit)  ps_init( 0, 0.0, 0.0, DEFAULTPLOTW, DEFAULTPLOTH, &dmy );
329
330        if  ((style < 0) || (style >= PSC_MAXSTYLE))  style = 0;
331        if  (style != psv_currstyle)
332                psh_changestyle( style );
333
334        if  (psv_move)  {
335                psh_trafo( psv_move_x, psv_move_y, &dx, &dy );
336                fprintf( psv_pf, "%d %d M\n", Nint(dx), Nint(dy) );
337                psv_move = FALSE;
338                linecnt = 0;
339        } /*endif*/
340
341        psh_trafo( x, y, &dx, &dy );
342        fprintf( psv_pf, "%d %d L\n", Nint(dx), Nint(dy) );
343
344        if  (++linecnt > psv_strokenum)  {
345                fprintf( psv_pf, "stroke\n" );
346                fprintf( psv_pf, "%d %d M\n", Nint(dx), Nint(dy) );
347                linecnt = 0;
348        } /*endif*/
349
350} /* end of ps_drawto */
351
352
353/*----------------------------------------------------------------------------*/
354
355
356
357void ps_arrayplot( int style, long cnt, int red, GBC_COO xoff,
358        GBC_COO xinc, GBC_COO yoff, GBC_COO yarr[], float yzoom, STATUS *status )
359
360/* plots array of data points
361 *
362 * parameters of routine
363 * int        style;       input; style parameter
364 * long       cnt;         input; number of data samples in yarr
365 * int        red;         input; reduction factor
366 * GBC_COO    xoff;        input; x offset
367 * GBC_COO    xinc;        input; x increment
368 * GBC_COO    yoff;        input; y offset
369 * GBC_COO    yarr[];      input; data array
370 * float      yzoom;       input; amplitude zoom factor
371 * STATUS     *status;     output; return status
372 */
373{
374        /* local variables */
375        long     i;          /* sample counter */
376        GBC_COO  cx, cy;     /* current user coordinates */
377        PSOUT    dx, dy;     /* current PS coordinates */
378        long     lcnt;       /* lineto counter */
379
380        /* executable code */
381
382        if  (!psv_isinit)  ps_init( 0, 0.0, 0.0, DEFAULTPLOTW, DEFAULTPLOTH, status);
383
384        if  (style != psv_currstyle)
385                psh_changestyle( style );
386
387        fprintf( psv_pf, "newpath\n" );
388
389        lcnt = 0;
390        if  (psv_arrayswap)  {
391                cx = yoff + (*yarr)*yzoom;
392                cy = xoff;
393                psh_trafo( cx, cy, &dx, &dy );
394                fprintf( psv_pf, "%d %d M\n", Nint(dx), Nint(dy) );
395                for  (i=red; i<cnt; i += red)  {
396                        cx = yoff + yarr[i]*yzoom;
397                        cy = xoff + xinc*(float)i;
398                        psh_trafo( cx, cy, &dx, &dy );
399                        fprintf( psv_pf, "%d %d L\n", Nint(dx), Nint(dy) );
400                        if  (++lcnt > psv_strokenum)  {
401                                fprintf( psv_pf, "stroke\n" );
402                                fprintf( psv_pf, "%d %d M\n", Nint(dx), Nint(dy) );
403                                lcnt = 0;
404                        } /*endif*/
405                } /*endfor*/
406        } else {
407                cx = xoff;
408                cy = yoff + (*yarr)*yzoom;
409                psh_trafo( cx, cy, &dx, &dy );
410                fprintf( psv_pf, "%d %d M\n", Nint(dx), Nint(dy) );
411                for  (i=red; i<cnt; i += red)  {
412                        cx = xoff + xinc*(float)i;
413                        cy = yoff + yarr[i]*yzoom;
414                        psh_trafo( cx, cy, &dx, &dy );
415                        fprintf( psv_pf, "%d %d L\n", Nint(dx), Nint(dy) );
416                        if  (++lcnt > psv_strokenum)  {
417                                fprintf( psv_pf, "stroke\n" );
418                                fprintf( psv_pf, "%d %d M\n", Nint(dx), Nint(dy) );
419                                lcnt = 0;
420                        } /*endif*/
421                } /*endfor*/
422        } /*endif*/
423
424        fprintf( psv_pf, "stroke\n" );
425
426        psv_move = FALSE;
427
428} /* end of ps_arrayplot */
429
430
431
432/*----------------------------------------------------------------------------*/
433
434
435
436void ps_text( int style, GBC_COO x, GBC_COO y, char text[] )
437
438/* prints text at position (x,y)
439 *
440 * parameters of routine
441 * int        style;     input; style parameter (size)
442 * GBC_COO    x, y;      input; text position (user coordinates)
443 * char       text[];    input; text to be printed
444 */
445{
446        /* local variables */
447        PSOUT    dx, dy;   /* device coordinates */
448        /* int      slen; */    /* length of string */
449        /* float    size; */    /* size of output */
450        STATUS   dmy;      /* scratch */
451
452        /* executable code */
453
454        if  (!psv_isinit)  ps_init( 0, 0.0, 0.0, DEFAULTPLOTW, DEFAULTPLOTH, &dmy );
455
456        if  (style < 0)  style = 0;
457        if  (style >= PSC_MAXSTYLE)  style = PSC_MAXSTYLE-1;
458        psh_trafo( x, y, &dx, &dy );
459        /* slen = (int)strlen( text ); */
460        /* size = psv_csize[style] * psv_height; */
461        if  (style != psv_currstyle)
462                psh_changestyle( style );
463        fprintf( psv_pf, "%d %d M\n(%s)\ndrawstr\n", Nint(dx), Nint(dy), text );
464
465} /* end of ps_text */
466
467
468
469/*----------------------------------------------------------------------------*/
470
471
472
473void ps_setstyle( int style, char item[], char value[], STATUS *status )
474
475/* sets style parameter number "style"
476 *
477 * parameters of routine
478 * int        style;     input; number of style
479 * char       item[];    input; name of style attribute
480 * char       value[];   input; new value of style attribute (as string expr.)
481 * STATUS     *status;   output; return status
482 */
483{
484        /* local variables */
485        float    num;      /* scratch */
486        float    r, g, b;  /* colours */
487
488        /* executable code */
489
490        if  ((style < 0) || (style >= PSC_MAXSTYLE))  {
491                *status = PSE_ILSTYLE;
492                return;
493        } /*endif*/
494
495        /* if  (!psv_isinit)  ps_init( 0, 0.0, 0.0, DEFAULTPLOTW, DEFAULTPLOTH, status); */
496
497        if  (strcmp(item,"CHARSIZE") == 0  ||  strcmp(item,"CHARHEIGHT") == 0)  {
498                if  (sscanf(value,"%f",&num) != 1)  {
499                        *status = PSE_ILVALUE;
500                        return;
501                } /*endif*/
502                psv_csize[style] = num*3000.0;
503        } else if  (strcmp(item,"WRMODE") == 0)  {
504        } else if  (strcmp(item,"LINESTYLE") == 0)  {
505                /* not yet implemented */
506        } else if  (strcmp(item,"COLOR") == 0)  {
507                if  (sscanf(value,"%f,%f,%f",&r,&g,&b) != 3)  {
508                        *status = PSE_ILVALUE;
509                        return;
510                } /*endif*/
511                /* not yet implemented */
512        } else if  (strcmp(item,"CHARROT") == 0)  {
513        } else if  (strcmp(item,"FONT") == 0)  {
514        } else if  (strcmp(item,"LINEWIDTH") == 0)  {
515                if  (sscanf(value,"%f",&num) != 1)  {
516                        *status = PSE_ILVALUE;
517                        return;
518                } /*endif*/
519                psv_lwidth[style] = num*1.8;
520        } else if  (strcmp(item,"LINEPATTERN") == 0)  {
521        } else if  (strcmp(item,"CHARSIZE_ATARI") == 0)  {
522        } else if  (strcmp(item,"TEXTEFFECTS") == 0)  {
523        } else {
524                *status = PSE_UKITEM;
525                return;
526        } /*endif*/
527
528} /* end of ps_setstyle */
529
530
531
532/*----------------------------------------------------------------------------*/
533
534
535
536void ps_set_outputdir( char dir[], STATUS *status )
537
538/* sets scratch directory
539 *
540 * parameters of routine
541 * char      dir[];     input; new directory name of scratch path
542 * STATUS    *status;   output; return status
543 */
544{
545        /* executable code */
546
547        if  (strlen(dir) > BC_FILELTH)  {
548                *status = PSE_STROVFL;
549                return;
550        } /*endif*/
551        strcpy( psv_outputdir, dir );
552
553} /* end of ps_set_outputdir */
554
555
556
557/*----------------------------------------------------------------------------*/
558
559
560
561void ps_set_inputdir( char dir[], STATUS *status )
562
563/* sets scratch directory
564 *
565 * parameters of routine
566 * char      dir[];     input; new directory name
567 * STATUS    *status;   output; return status
568 */
569{
570        /* executable code */
571
572        if  (strlen(dir) > BC_FILELTH)  {
573                *status = PSE_STROVFL;
574                return;
575        } /*endif*/
576        strcpy( psv_inputdir, dir );
577
578} /* end of ps_set_inputdir */
579
580
581
582/*----------------------------------------------------------------------------*/
583
584
585
586void ps_prepare( STATUS *status )
587
588/* prepares hardcopy
589 *
590 * parameters of routine
591 * STATUS     *status;    output; return status
592 */
593{
594        /* local variables */
595
596        /* executable code */
597
598        ps_erase();
599        if  (Severe(status))  return;  /* just to use status */
600
601} /* end of ps_prepare */
602
603
604
605/*----------------------------------------------------------------------------*/
606
607
608
609void ps_cleanup( char outf[], STATUS *status )
610
611/* finishes hardcopy
612 *
613 * parameters of routine
614 * char       outf[];     output; output filename
615 * STATUS     *status;    output; return status
616 */
617{
618        /* local variables */
619        char     hcname[BC_LINELTH+1];    /* name of hardcopy file */
620        char     str[BC_LINELTH+1];       /* scratch string */
621        /* char     cmd[BC_LINELTH+1]; */      /* command string */
622
623        /* executable code */
624
625        if  (!psv_isinit)  ps_init( 0, 0.0, 0.0, DEFAULTPLOTW, DEFAULTPLOTH, status);
626
627        /* close PostScript file */
628        psh_closepsf( psv_pf );
629
630        /* create hardcopy name */
631        psh_create_hcname( hcname );
632
633        strcpy( str, psv_outputdir );
634        strcat( str, hcname );
635        sy_fdelete( str );
636        sy_frename( psv_currpsf, str );
637        if  (outf != NULL)  strcpy( outf, str );
638
639        /* open PostScript file */
640        psv_pf = sy_fopen( psv_currpsf, "w" );
641        if  (psv_pf == NULL)  {
642                *status = PSE_FOPNWR;
643                return;
644        } /*endif*/
645        psh_insertheader( psv_pf );
646        psv_currstyle = 0;    /* reset style block number */
647
648} /* end of ps_cleanup */
649
650
651
652/*----------------------------------------------------------------------------*/
653
654
655
656void ps_setpar( char item[], char value[], STATUS *status )
657
658/* sets hardcopy parameters
659 *
660 * parameters of routine
661 * char       item[];     input; item to be set
662 * char       value[];    input; new value of item
663 * STATUS     *status;    output; return status
664 */
665{
666        /* executable code */
667
668        if  (strlen(value) > BC_LINELTH)  {
669                *status = PSE_STROVFL;
670                return;
671        } /*endif*/
672
673        if  (strcmp(item,"PRINT_CMD") == 0)  {
674                /* strcpy( psv_printfmt, value ) */;
675        } else if  (strcmp(item,"STROKE") == 0)  {
676                sscanf( value, "%d", &psv_strokenum );
677        } else if  (strcmp(item,"PSHEADER") == 0)  {
678                if  (strlen(value) < BC_FILELTH)
679                        strcpy( psv_headerfile, value );
680        } else {
681                *status = PSE_UKHCITEM;
682                return;
683        } /*endif*/
684
685} /* end of ps_setpar */
686
687
688
689/*----------------------------------------------------------------------------*/
690
691
692
693void ps_arrayswap( BOOLEAN on_off )
694
695/* switches array-swap on ot off
696 *
697 * parameter of routine
698 * BOOLEAN   on_off;     TRUE=on, FALSE=off
699 */
700{
701        /* executable code */
702
703        psv_arrayswap = on_off;
704
705} /* end of ps_arrayswap */
706
707
708
709/*----------------------------------------------------------------------------*/
710/*                            local routines                                  */
711/*----------------------------------------------------------------------------*/
712
713
714
715void psh_trafo( GBC_COO ux, GBC_COO uy, PSOUT *dx, PSOUT *dy )
716
717/* transforms user coordinates (ux,uy) to device coordinates (dx,dy)
718 *
719 * parameters of routine
720 * GBC_COO    ux, uy;     input; user coordinates
721 * PSOUT      dx, dy;     output; device coordinates
722 */
723{
724        /* executable code */
725
726        *dx = ux * psv_trafo_xf + psv_trafo_xo;
727        *dy = uy * psv_trafo_yf + psv_trafo_yo;
728
729} /* end of psh_trafo */
730
731
732
733/*----------------------------------------------------------------------------*/
734
735
736
737void psh_create_hcname( char name[] )
738
739/* creates hardcopy filename
740 *
741 * parameters of routine
742 * char       name[];      output; filename created
743 */
744{
745        /* local variables */
746        static int   hc_count=0;   /* hardcopy counter */
747
748        /* executable code */
749
750        strcpy( name, "HC" );
751        sprintf( name+2, "%03d", ++hc_count );
752        strcat( name, ".ps" );
753
754} /* end of psh_create_filename */
755
756
757
758/*----------------------------------------------------------------------------*/
759
760
761void psh_insertheader( FILE *ps )
762
763/* inserts header to PostScript file
764 *
765 * parameter of routine
766 * FILE      *ps;     input; PostScript file to insert header
767 */
768{
769        /* local variables */
770        FILE     *hf;                     /* header file */
771        char     line[BC_LONGSTRLTH+1];   /* current line */
772        char     timestr[BC_LINELTH+1];   /* time string */
773#   ifdef BSD
774        char     *tstr;
775        struct timeval date;
776        struct tm *p;
777#   endif
778
779        /* executable code */
780
781#   ifdef BSD
782        if  (time(&date) == -1)  {
783                strcpy( timestr, "--- no system time available ---" );
784        } else {
785                gettimeofday( &date, NULL );
786                p = localtime( &date.tv_sec );
787                tstr = asctime( p );
788                sprintf( timestr, "%.6s %.4s %.8s", tstr+4, tstr+20, tstr+11 );
789        } /*endif*/
790#   else
791                strcpy( timestr, "                                              " );
792#   endif
793
794        fprintf( ps, "%%! PS-Adobe-2.0 EPSF -1.2\n" );
795        fprintf( ps, "%%%% Creator: SH (SeismicHandler)\n" );
796        fprintf( ps, "%%%% For: Hardcopy of graphic window\n" );
797        fprintf( ps, "%%%% Title: SH Hardcopy\n" );
798        fprintf( ps, "%%%% Creation Date: %s\n", timestr );
799        fprintf( ps, "%%%% Bounding Box: \n" );
800        fprintf( ps, "%%%% EndComments\n" );
801        fprintf( ps, "%%%% \n" );
802        fprintf( ps, "%%%% BeginDictSet\n" );
803
804        strcpy( line, psv_inputdir );
805        strcat( line, psv_headerfile );
806        hf = sy_fopen( line, "r" );
807        if  (hf == NULL)  {
808                fprintf( ps, "%%%%\n%%%% no header file available\n%%%%\n" );
809                printf( "-->  error opening header file\n" );
810                return;
811        } /*endif*/
812
813        while  (fgets(line,BC_LONGSTRLTH,hf) != NULL)
814                fputs( line, ps );
815
816        fclose( hf );
817        fprintf( ps, "%%%% EndDictSet\n" );
818        fprintf( ps, "\n%%%% BeginDocument\n" );
819        fprintf( ps, "newpath\n" );
820
821} /* end of psh_insertheader */
822
823
824
825/*----------------------------------------------------------------------------*/
826
827
828void psh_closepsf( FILE *ps )
829
830/* closes hardcopy file
831 *
832 * parameter of routine
833 * FILE      *ps;      input; pointer to hardcopy file
834 */
835{
836
837        /* executable code */
838
839        fprintf( ps, "stroke\n" );
840        fprintf( ps, "endpage\n" );
841        fprintf( ps, "%% EndDocument\n" );
842        fclose( ps );
843
844} /* end of psh_closepsf */
845
846
847
848/*----------------------------------------------------------------------------*/
849
850
851void psh_changestyle( int style )
852
853/* changes the current style
854 *
855 * parameters of routine
856 * int        style;      input; new style number
857 */
858{
859        /* executable code */
860
861        if  (style < 0)  style = 0;
862        if  (style >= PSC_MAXSTYLE)  style = 0;
863        psv_currstyle = style;
864        fprintf( psv_pf, "stroke\n" );
865        fprintf( psv_pf, "newpath\n" );
866        fprintf( psv_pf, "%f setlinewidth\n", psv_lwidth[style] );
867        fprintf( psv_pf, "/Courier findfont %f scalefont setfont\n",
868                psv_csize[style] );
869
870} /* end of psh_changestyle */
871
872
873
874/*----------------------------------------------------------------------------*/
Note: See TracBrowser for help on using the repository browser.