← Back to branch summary

~ubuntu-branches/ubuntu/wily/eso-midas/wily-proposed

« back to all changes in this revision

Viewing changes to libsrc/agl/pscrdrv.c

  • Committer: Package Import Robot
  • Author(s): Ole Streicher
  • Date: 2014-04-22 14:44:58 UTC
  • Revision ID: package-import@ubuntu.com-20140422144458-okiwi1assxkkiz39
Tags: upstream-13.09pl1.2+dfsg
Import upstream version 13.09pl1.2+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
libsrc/agl/pscrdrv.c
 
1
/*===========================================================================
 
2
  Copyright (C) 1995-2009 European Southern Observatory (ESO)
 
3
 
 
4
  This program is free software; you can redistribute it and/or 
 
5
  modify it under the terms of the GNU General Public License as 
 
6
  published by the Free Software Foundation; either version 2 of 
 
7
  the License, or (at your option) any later version.
 
8
 
 
9
  This program is distributed in the hope that it will be useful,
 
10
  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
  GNU General Public License for more details.
 
13
 
 
14
  You should have received a copy of the GNU General Public 
 
15
  License along with this program; if not, write to the Free 
 
16
  Software Foundation, Inc., 675 Massachusetts Ave, Cambridge, 
 
17
  MA 02139, USA.
 
18
 
 
19
  Correspondence concerning ESO-MIDAS should be addressed as follows:
 
20
        Internet e-mail: midas@eso.org
 
21
        Postal address: European Southern Observatory
 
22
                        Data Management Division 
 
23
                        Karl-Schwarzschild-Strasse 2
 
24
                        D 85748 Garching bei Muenchen 
 
25
                        GERMANY
 
26
===========================================================================*/
 
27
 
 
28
/*
 
29
 * HEADER : pscrdrv.c      - Vers 3.6.010  - Jul 1994 -  L. Fini, OAA
 
30
 *
 
31
 * 
 
32
 * 090416       last modif
 
33
 *
 
34
 */
 
35
 
 
36
 
 
37
/*****************************************************************************/
 
38
/* AGL PostScript driver - L. Fini Jun 1987                                  */
 
39
/*                       - L. Fini Oct 1991 (Color support added)            */
 
40
 
 
41
/* This driver is based on a FORTRAN version provided by Alco Blom for       */
 
42
/* AGL V. 2.1                                                                */
 
43
 
 
44
/* This driver allows selection of landscape(default) and Portrait mode by   */
 
45
/* means of the USRAUX portion of the device definition string.              */
 
46
 
 
47
/* Output orientation and size default to landscape A4. Different selection  */
 
48
/* can be made when the first viewport is opened onto the device by means of */
 
49
/* format specifications characters with the following meanings:             */
 
50
 
 
51
/*       p    :  portrait                                                    */
 
52
/*       l    :  landscape                                                   */
 
53
/*       3    :  A3                                                          */
 
54
/*       4    :  A4                                                          */
 
55
/*       u    :  US-legal                                                    */
 
56
 
 
57
 
 
58
/* The selection characters are to be appendend to the device name, separa-  */
 
59
/* ted by a point as in the following examples:                              */
 
60
 
 
61
/*         iv=AG_VDEF("ps.p:",.......)      selects portrait A4              */
 
62
/*                     or                                                    */
 
63
/*         iv=AG_VDEF("ps.p4:",.......)     selects portrait A4              */
 
64
 
 
65
/*         iv=AG_VDEF("ps.pu:",.......)     selects portrait US-legal        */
 
66
 
 
67
/*         iv=AG_VDEF("ps.3:",.......)      selects portrait A3              */
 
68
/*                     or                                                    */
 
69
/*         iv=AG_VDEF("ps.l3:",.......)     selects landscape A3             */
 
70
 
 
71
/* (the characters: p,l,3,4,u can be put in any number and sequence. The     */
 
72
/*  last encountered only will take effect)                                  */
 
73
 
 
74
#include <aglsys.h>
 
75
 
 
76
#include <agl.h>
 
77
#include <aglerror.h>
 
78
#include <agldcom.h>
 
79
#include <agldcaps.h>
 
80
 
 
81
 
 
82
/*                                                                           */
 
83
/*  The following entry points have been defined:                            */
 
84
/*                                                                           */
 
85
/*  Function    Entry point                                                  */
 
86
/*                                                                           */
 
87
/*  Initialize  AGLINPS0                                                     */
 
88
/*  Cursor en.  AGLCUPS0                                                     */
 
89
/*  Erase       AGLERPS0                                                     */
 
90
/*  Escape      AGLESPS0                                                     */
 
91
/*  Polyline    AGLPLPS0                                                     */
 
92
/*  Finish      AGLTEPS0                                                     */
 
93
/*  Flush buff. AGLSEPS0                                                     */
 
94
/*                                                                           */
 
95
 
 
96
 
 
97
/*  device parameters definition                                             */
 
98
 
 
99
#define VERSCODE 36                     /* Declare driver version            */
 
100
 
 
101
#define A4      1
 
102
#define A3      2
 
103
#define USLEGAL 3
 
104
 
 
105
#define PSFLAGS  SEPALPHA | EXECOMMND | SETBACKGR
 
106
#define PSMAXLWIDTH 4
 
107
 
 
108
#define PSBLACK         0       /* Bot index and grayscale value          */
 
109
#define PSWHITE         1       /* Bot index and grayscale value          */
 
110
#define PSRED           2
 
111
#define PSGREEN         3
 
112
#define PSBLUE          4
 
113
#define PSYELLOW        5
 
114
#define PSMAGENTA       6
 
115
#define PSCYAN          7
 
116
 
 
117
#define TRUE  1
 
118
#define FALSE 0
 
119
 
 
120
#define CVTX(x)  ((int)((x)*xfact))+1
 
121
#define CVTY(y)  ((int)((y)*yfact))+1
 
122
 
 
123
 
 
124
/* To allow for good resolution with small file length the driver uses      */
 
125
/*  an arbitrary set of coordinates so that numbers are never greater than  */
 
126
/* 10000 for A4 format. The PostScript scale factor is then used to adjust  */
 
127
/* for standard PostScript coordinates (1/72 of an inch). The following     */
 
128
/* values are the required conversion factors.                              */
 
129
 
 
130
 
 
131
/*      US Legal Landscape mode --------------------------+                 */
 
132
/*      US Legal Portrait mode ---------------------+     |                 */
 
133
/*      A3   Landscape mode -------------------+    |     |                 */
 
134
/*      A3   Portrait mode --------------+     |    |     |                 */
 
135
/*      A4   Landscape mode -------+     |     |    |     |                 */
 
136
/*      A4   Portrait mode --+     |     |     |    |     |                 */
 
137
/*                           |     |     |     |    |     |                 */
 
138
static float FACTC[6]  = { 6908, 9999, 9999, 14908,7453, 9817 };
 
139
static float PSCMAXL[6]= { 19.0, 27.5, 27.5, 41.0, 20.5, 27.0 }; 
 
140
static float PSCLENG[6]= { 19.0, 27.5, 27.5, 41.0, 21.0, 27.0 };
 
141
static float PIXCM[6]  = { 363.6364, 
 
142
                                 363.6364,
 
143
                                       363.6364, 
 
144
                                             363.6364, 
 
145
                                                   363.6364, 
 
146
                                                         363.6364 };
 
147
static float CHARF[6]  = { 13.889,                       /* Char. multip.   */
 
148
                                 13.889, 
 
149
                                       13.889, 
 
150
                                             13.889, 
 
151
                                                   13.889, 
 
152
                                                         13.889 };
 
153
 
 
154
static FILE *filpt;
 
155
static int id0, id1;
 
156
static int Size,Sptx,Spty;
 
157
static int rot;
 
158
static double xfact,yfact,xofst,yofst;
 
159
static double xdim,ydim;
 
160
static int page_touch;          /* TRUE when current page has something into */
 
161
static int file_touch;          /* TRUE when current file has something into */
 
162
static int cur_color;
 
163
static int cur_backg;
 
164
static int n_colors;
 
165
 
 
166
static struct {
 
167
                float red;
 
168
                float green;
 
169
                float blue;
 
170
} CTAB[8] =                     {
 
171
                /* PSBLACK      */      { 0.0,  0.0,    0.0 },
 
172
                /* PSWHITE      */      { 1.0,  1.0,    1.0 },
 
173
                /* PSRED        */      { 1.0,  0.0,    0.0 },
 
174
                /* PSGREEN      */      { 0.0,  1.0,    0.0 },
 
175
                /* PSBLUE       */      { 0.0,  0.0,    1.0 },
 
176
                /* PSYELLOW     */      { 1.0,  1.0,    0.0 },
 
177
                /* PSMAGENTA    */      { 1.0,  0.0,    1.0 },
 
178
                /* PSCYAN       */      { 0.0,  1.0,    1.0 } };
 
179
 
 
180
static char *hd0 = "%% Page: 1 1\n";
 
181
static char *hd1 = "/cm { 28.34646 mul } def\n";
 
182
static char *hd2 = "1.0 cm 1.0 cm translate\n";
 
183
static char *hd3_us = "20.5 cm 0 cm translate\n90 rotate\n";
 
184
static char *hd3_a4 = "19.0 cm 0 cm translate\n90 rotate\n";
 
185
static char *hd3_a3 = "27.5 cm 0 cm translate\n90 rotate\n";
 
186
static char *hd4 = "0.077960552 0.077960552 scale\n";
 
187
static char *hd5 = "[] 0 setdash\n";
 
188
static char hd6[] = "1 6 mul setlinewidth\n";
 
189
static char *hd7 = "/m { moveto } def\n";
 
190
static char *hd8 = "/r { rlineto } def\n";
 
191
static char *hd9 = "/l { 8 { rlineto } repeat } def \n";
 
192
static char *hd10 = "/c { { rlineto } repeat } def\n";
 
193
static char *hd11  = "/s { stroke } def\n";
 
194
static char *hd12  = "/n { newpath } def\n";
 
195
static char *hd13  = "2 setlinejoin\n";
 
196
static char *hd14 = "% BEGINNING OF PLOT\n";
 
197
 
 
198
 
 
199
 
 
200
static void showpage(filpt)
 
201
FILE *filpt;
 
202
{
 
203
/*
 
204
static char *show = "showpage   % END OF PAGE\n";
 
205
*/
 
206
static char *trail1 = "showpage\n";
 
207
static char *trail2 = "% END OF PAGE\n";
 
208
static char *trail3 = "%% Trailer\n";
 
209
static char *trail4 = "%% EOF\n";
 
210
 
 
211
/*
 
212
fputs(show,filpt);
 
213
*/
 
214
fputs(trail1,filpt);
 
215
fputs(trail2,filpt);
 
216
fputs(trail3,filpt);
 
217
fputs(trail4,filpt);
 
218
}
 
219
 
 
220
 
 
221
 
 
222
 
 
223
 
 
224
void set_pscolor(color)         /* set up a given color                */
 
225
int color;
 
226
{
 
227
fprintf(filpt,"%f %f %f setrgbcolor\n",CTAB[color].red,
 
228
                                       CTAB[color].green,
 
229
                                       CTAB[color].blue );
 
230
}
 
231
 
 
232
 
 
233
 
 
234
 
 
235
 
 
236
static void fill_area(xmin,xmax,ymin,ymax,color)
 
237
int xmin,xmax;
 
238
int ymin,ymax;
 
239
int color;
 
240
{
 
241
set_pscolor(color);
 
242
 
 
243
fprintf(filpt,"n %d %d moveto\n",xmin,ymin);
 
244
fprintf(filpt,"%d %d lineto\n",xmax,ymin);
 
245
fprintf(filpt,"%d %d lineto\n",xmax,ymax);
 
246
fprintf(filpt,"%d %d lineto\n",xmin,ymax);
 
247
 
 
248
fprintf(filpt,"closepath fill\n");
 
249
 
 
250
set_pscolor(cur_color);
 
251
}
 
252
 
 
253
 
 
254
/*---------------------------------------------------------------------------*/
 
255
void AGLINPS0 (AGLDVCOM)
 
256
struct bufcom *AGLDVCOM;
 
257
{
 
258
  /* static char *in00 = "%!PS-Adobe-3.0 EPSF-3.0\n";
 
259
     static char *in01 = "%%BoundingBox: 28 28 ";
 
260
     static char *in01_a4 = "570 810\n";
 
261
     static char *in01_a3 = "810 1208\n";
 
262
     static char *in01_us = "604 795\n";  
 
263
     static char *in02 = "%! AGL PostScript driver file header - V 3.61\n";
 
264
     static char *in03 = "%%EndComments\n";
 
265
  */
 
266
 
 
267
static char *in00 = "%!PS-Adobe-3.0 EPSF-3.0\n";
 
268
static char *in01 = "%%BoundingBox: 28 28 ";
 
269
static char *in01_a4 = "570 810\n";
 
270
static char *in01_a3 = "810 1208\n";
 
271
static char *in01_us = "604 795\n";  
 
272
static char *in02 = "%% Creator: ESO-MIDAS/AGL AGL version 3.61\n";
 
273
static char *in03 = "%% DocumentNeededResources: font Helvetica\n";
 
274
static char *in04 = "%% LanguageLevel: 1\n";
 
275
static char *in05 = "%% Pages: 1\n";
 
276
static char *in06 = "%% EndComments\n";
 
277
 
 
278
extern void AG_DMSG();
 
279
 
 
280
char auxbuf[PHNAMLNG];
 
281
static char *filnam = "pscrplot";
 
282
char *pt;
 
283
 
 
284
 
 
285
ERRCODE=AGLNOERR;
 
286
 
 
287
switch((int)IBUFFR(0)) {                /* Select function           */
 
288
case 0:                                 /* Hardware initialization   */
 
289
        file_touch=FALSE;
 
290
        page_touch=FALSE;
 
291
  
 
292
        strcpy(auxbuf,filnam);
 
293
        AG_NEWN(auxbuf);
 
294
 
 
295
        if(*auxbuf == '\0') {
 
296
                ERRCODE=DEVOPNSEV;
 
297
                return;
 
298
        }
 
299
 
 
300
        filpt=fopen(auxbuf,"w");
 
301
 
 
302
        if (filpt==NULL) {
 
303
                AG_DMSG("Open error:",auxbuf);
 
304
                ERRCODE=DEVOPNSEV;
 
305
                return;
 
306
        }
 
307
 
 
308
        *hd6 = '1';
 
309
 
 
310
        CHANNEL=0;
 
311
 
 
312
        rot = TRUE;                     /* Select default orientation */
 
313
        Size=A4;                        /* Select default size        */
 
314
 
 
315
        pt=CHARBUF;
 
316
        while(*pt++);                   /* Skip device name          */
 
317
        while(*pt++);                   /* Skip SYSAUX info          */
 
318
                                        /* to Get USRAUX string      */
 
319
        while(*pt) {                    /* Scan selection string     */
 
320
                switch(TOUPPER(*pt)) {
 
321
                case 'P':               /* select portrait mode      */
 
322
                        rot = FALSE;
 
323
                        break;
 
324
                case 'L':               /* select landscape mode     */
 
325
                        rot = TRUE;
 
326
                        break;
 
327
                case '4':
 
328
                        Size=A4;
 
329
                        break;
 
330
                case 'U':
 
331
                        Size=USLEGAL;
 
332
                        break;
 
333
                case '3':
 
334
                        Size=A3;
 
335
                        break;
 
336
                }
 
337
                pt++;
 
338
        }
 
339
        if(rot) {                               /* Select rotation    */
 
340
                AG_DMSG("Mode:","Landscape");
 
341
                id0 = 1;
 
342
                id1 = 0;
 
343
        } else {
 
344
                AG_DMSG("Mode:","Portrait");
 
345
                id0 = 0;
 
346
                id1 = 1;
 
347
        }
 
348
 
 
349
        strcpy(CHARBUF,auxbuf);         /* Copy filename to buffer   */
 
350
        AG_DMSG("Out to:",auxbuf);
 
351
 
 
352
        fputs(in00,filpt);
 
353
        fputs(in01,filpt);
 
354
 
 
355
        switch(Size) {                          /* Select size         */
 
356
        case A4:
 
357
                Sptx = id0;
 
358
                Spty = id1;
 
359
                AG_DMSG("Size:","A4");
 
360
                fputs(in01_a4,filpt);
 
361
                break;
 
362
        case A3:
 
363
                Sptx = id0+2;
 
364
                Spty = id1+2;
 
365
                AG_DMSG("Size:","A3");
 
366
                fputs(in01_a3,filpt);
 
367
                break;
 
368
        case USLEGAL:
 
369
                Sptx = id0+4;
 
370
                Spty = id1+4;
 
371
                AG_DMSG("Size:","US-legal");
 
372
                fputs(in01_us,filpt);
 
373
                break;
 
374
        }
 
375
    
 
376
        /* 
 
377
        fputs(in02,filpt);
 
378
        fputs(in03,filpt);
 
379
        */
 
380
 
 
381
        fputs(in02,filpt);
 
382
        fputs(in03,filpt);
 
383
        fputs(in04,filpt);
 
384
        fputs(in05,filpt);
 
385
        fputs(in06,filpt);
 
386
        
 
387
 
 
388
        fputs(hd0,filpt);
 
389
        fputs(hd1,filpt);
 
390
        fputs(hd2,filpt);
 
391
        if(rot) 
 
392
                switch(Size) {                  /* Select size         */
 
393
                case A4:
 
394
                        fputs(hd3_a4,filpt);
 
395
                        break;
 
396
                case A3:
 
397
                        fputs(hd3_a3,filpt);
 
398
                        break;
 
399
                case USLEGAL:
 
400
                        fputs(hd3_us,filpt);
 
401
                        break;
 
402
                }
 
403
 
 
404
        fputs(hd14,filpt);
 
405
        fputs(hd4,filpt);
 
406
        fputs(hd5,filpt);
 
407
        fputs(hd6,filpt);
 
408
        fputs(hd7,filpt);
 
409
        fputs(hd8,filpt);
 
410
        fputs(hd9,filpt);
 
411
        fputs(hd10,filpt);
 
412
        fputs(hd11,filpt);
 
413
        fputs(hd12,filpt);
 
414
        fputs(hd13,filpt);
 
415
        fputs(hd14,filpt);
 
416
     
 
417
        xdim = (RBUFFR(id0)<PSCMAXL[Sptx]) ? RBUFFR(id0) : PSCMAXL[Sptx];
 
418
        xdim = (xdim<=0.0) ? PSCLENG[Sptx] : xdim;
 
419
        ydim = (RBUFFR(id1)<PSCMAXL[Spty]) ? RBUFFR(id1) : PSCMAXL[Spty];
 
420
        ydim = (ydim<=0.0) ? PSCLENG[Spty] : ydim;
 
421
        xofst = ((PSCMAXL[Sptx]-xdim)*0.5) * FACTC[Sptx];   
 
422
        yofst = ((PSCMAXL[Spty]-ydim)*0.5) * FACTC[Spty];
 
423
        xfact = (xdim/PSCMAXL[Sptx]) * FACTC[Sptx];
 
424
        yfact = (ydim/PSCMAXL[Spty]) * FACTC[Spty];
 
425
        xofst *= FACTC[Sptx];
 
426
        yofst *= FACTC[Spty];
 
427
        break;
 
428
 
 
429
case 1:                                 /* Pass back device characteristics  */
 
430
        *(CHARBUF) = '\0';
 
431
        RBUFFR(0) = xdim;
 
432
        RBUFFR(1) = ydim;
 
433
 
 
434
        IBUFFR(1) = PSFLAGS;
 
435
 
 
436
        n_colors = 7;
 
437
 
 
438
        IBUFFR(2) = n_colors;
 
439
 
 
440
        IBUFFR(3) = xdim*PIXCM[Sptx];
 
441
        IBUFFR(4) = ydim*PIXCM[Spty];
 
442
        IBUFFR(5) = VERSCODE;
 
443
        IBUFFR(6) = PSMAXLWIDTH;
 
444
 
 
445
        cur_color=PSBLACK;
 
446
        cur_backg=PSWHITE;
 
447
 
 
448
        IBUFFR(7) = cur_backg;  /* Default Background */
 
449
        IBUFFR(8) = cur_color;  /* Default foreground */
 
450
        IBUFFR(9) = PSBLACK;
 
451
        IBUFFR(10) = PSRED;
 
452
        IBUFFR(11) = PSGREEN;
 
453
        IBUFFR(12) = PSBLUE;
 
454
        IBUFFR(13) = PSYELLOW;
 
455
        IBUFFR(14) = PSMAGENTA;
 
456
        IBUFFR(15) = PSCYAN;
 
457
        IBUFFR(16) = PSWHITE;
 
458
 
 
459
        RBUFFR(2) = CHARF[Sptx];
 
460
        RBUFFR(3) = 0.0;
 
461
        RBUFFR(4) = 0.0;
 
462
        RBUFFR(5) = 0.0;
 
463
        RBUFFR(6) = PSCLENG[Sptx];
 
464
        RBUFFR(7) = PSCLENG[Spty];
 
465
        RBUFFR(8) = PSCMAXL[Sptx];
 
466
        RBUFFR(9) = PSCMAXL[Spty];
 
467
        break;
 
468
 
 
469
case 2:                                         /* set color                 */
 
470
        ERRCODE=AGLNOERR;
 
471
        cur_color=IBUFFR(1);
 
472
        if((cur_color<0)||(cur_color>n_colors))
 
473
                cur_color=PSBLACK;
 
474
        set_pscolor(cur_color);
 
475
        break;
 
476
 
 
477
case 3:                                         /* set line style            */
 
478
        ERRCODE=AGLNOERR;                       /* Not used since vers. 3.3  */
 
479
        break;
 
480
 
 
481
case 4:                                         /* set line width            */
 
482
        ERRCODE=AGLNOERR;
 
483
        *auxbuf = *hd6;
 
484
        switch((int)IBUFFR(1)) {
 
485
        default:
 
486
        case 0:
 
487
                *hd6 = '1'; 
 
488
                break;
 
489
        case 1:
 
490
                *hd6 = '2'; 
 
491
                break;
 
492
        case 2:
 
493
                *hd6 = '3'; 
 
494
                break;
 
495
        case 3:
 
496
                *hd6 = '4'; 
 
497
                break;
 
498
        case 4:
 
499
                *hd6 = '5'; 
 
500
                break;
 
501
        }
 
502
        if(*auxbuf != *hd6) 
 
503
                fputs(hd6,filpt);
 
504
        break;
 
505
 
 
506
case 6:                                 /* Coordinate roundoff         */
 
507
        break;                  /* Unnecessary for high resol. devices */
 
508
}
 
509
}
 
510
 
 
511
static int cnt=0;
 
512
static int xv[8], yv[8];
 
513
 
 
514
static void trace(filpt,xx,yy)
 
515
FILE *filpt;
 
516
int xx,yy;
 
517
{
 
518
xv[cnt]=xx;
 
519
yv[cnt]=yy;
 
520
cnt++;
 
521
if (cnt==8) {
 
522
        do {
 
523
                cnt--;
 
524
                fprintf(filpt,"%d %d ", xv[cnt], yv[cnt]);
 
525
        } while(cnt);
 
526
        fprintf(filpt,"l\n");
 
527
        cnt=0;
 
528
}
 
529
}
 
530
 
 
531
static void trace_flush(filpt)
 
532
FILE *filpt;
 
533
{
 
534
if (cnt>0) {
 
535
        if(cnt==1)
 
536
                fprintf(filpt,"%d %d r ",xv[0],yv[0]);
 
537
        else {
 
538
                int cnts=cnt;
 
539
                do {
 
540
                        cnt--;
 
541
                        fprintf(filpt,"%d %d ", xv[cnt], yv[cnt]);
 
542
                } while(cnt);
 
543
                fprintf(filpt,"%d c ",cnts);
 
544
        }
 
545
}
 
546
fprintf(filpt,"s\n");
 
547
cnt=0;
 
548
}
 
549
 
 
550
/*---------------------------------------------------------------------------*/
 
551
void AGLPLPS0(AGLDVCOM)
 
552
struct bufcom *AGLDVCOM;
 
553
{
 
554
int n;
 
555
float *vectx, *vecty;
 
556
int xx,yy;
 
557
int x0,y0;
 
558
 
 
559
 
 
560
 
 
561
 
 
562
 
 
563
ERRCODE=AGLNOERR;
 
564
 
 
565
n = NPOINTS;
 
566
vectx = VECTX;
 
567
vecty = VECTY;
 
568
 
 
569
if(cur_color != cur_backg)
 
570
        {
 
571
        page_touch=TRUE;
 
572
        file_touch=TRUE;
 
573
 
 
574
 
 
575
        fprintf(filpt,"n %d %d m\n",            /* Move to first point       */
 
576
                       (x0=CVTX(*vectx++)),
 
577
                       (y0=CVTY(*vecty++)));
 
578
 
 
579
        xx=CVTX(*vectx++)-x0;
 
580
        yy=CVTY(*vecty++)-y0;
 
581
 
 
582
        /* the usual trace_flush doesn't draw anything
 
583
           => missing point on the `i' char. 
 
584
           so we make a 1x1 `filled' square             */
 
585
 
 
586
        if ((n == 2) && (xx == 0) && (yy == 0))
 
587
           {
 
588
           yy = 1;
 
589
           fprintf(filpt,"%d %d ", xx,yy);
 
590
           xx = 1; yy = 0;
 
591
           fprintf(filpt,"%d %d ", xx,yy);
 
592
           xx = 0; yy = -1;
 
593
           fprintf(filpt,"%d %d ", xx,yy);
 
594
           xx = -1; yy = 0;
 
595
           fprintf(filpt,"%d %d ", xx,yy);
 
596
           xx = 1; yy = 1;
 
597
           fprintf(filpt,"%d %d ", xx,yy);
 
598
           xx = -1; yy = 0;
 
599
           fprintf(filpt,"%d %d ", xx,yy);
 
600
           xx = 1; yy = -1;
 
601
           fprintf(filpt,"%d %d ", xx,yy);
 
602
           fprintf(filpt,"7 c ");               /* 7 line segments */
 
603
           fprintf(filpt,"s\n");
 
604
           }
 
605
 
 
606
        else
 
607
           {
 
608
           trace(filpt,xx,yy);                  /* Trace to second point      */
 
609
 
 
610
           x0 += xx; y0 += yy; n--;
 
611
 
 
612
           while(n-- > 1) 
 
613
              {
 
614
              register int xn,yn;
 
615
 
 
616
              xn=CVTX(*vectx++);
 
617
              yn=CVTY(*vecty++);
 
618
              xx= xn-x0;
 
619
              yy= yn-y0;
 
620
 
 
621
              if((0!=xx)||(0!=yy)) 
 
622
                 {
 
623
                 trace(filpt,xx,yy);
 
624
                 x0 = xn;
 
625
                 y0 = yn;
 
626
                 }
 
627
              }
 
628
           }
 
629
 
 
630
        trace_flush(filpt);
 
631
        } 
 
632
}
 
633
 
 
634
 
 
635
/*---------------------------------------------------------------------------*/
 
636
void AGLCUPS0(AGLDVCOM)
 
637
struct bufcom *AGLDVCOM;
 
638
{
 
639
ERRCODE=UNSFEATINF;
 
640
}
 
641
 
 
642
/*---------------------------------------------------------------------------*/
 
643
void AGLERPS0(AGLDVCOM)
 
644
struct bufcom *AGLDVCOM;
 
645
{
 
646
int xmin,xmax,ymin,ymax;
 
647
 
 
648
ERRCODE=AGLNOERR;
 
649
 
 
650
xmin = CVTX(RBUFFR(0)); xmax = CVTX(RBUFFR(1));
 
651
ymin = CVTY(RBUFFR(2)); ymax = CVTY(RBUFFR(3));
 
652
 
 
653
if((xmin==CVTX(0.0))&&(xmax==CVTX(1.0))&&       /* Eject page, if the entire */
 
654
   (ymin==CVTY(0.0))&&(ymax==CVTY(1.0))  ){     /* page is erased            */
 
655
        if(page_touch) {
 
656
                showpage(filpt);
 
657
                page_touch=FALSE;
 
658
        }
 
659
}
 
660
 
 
661
cur_backg = IBUFFR(0);
 
662
 
 
663
if((cur_backg<0)||(cur_backg>n_colors))
 
664
        cur_backg=PSWHITE;
 
665
 
 
666
fill_area(xmin,xmax,ymin,ymax,cur_backg);
 
667
}
 
668
 
 
669
/*---------------------------------------------------------------------------*/
 
670
void AGLESPS0(AGLDVCOM)
 
671
struct bufcom *AGLDVCOM;
 
672
{
 
673
ERRCODE=UNSFEATINF;
 
674
}
 
675
 
 
676
/*---------------------------------------------------------------------------*/
 
677
void AGLSEPS0(AGLDVCOM)
 
678
struct bufcom *AGLDVCOM;
 
679
{
 
680
ERRCODE=AGLNOERR;
 
681
}
 
682
 
 
683
/*---------------------------------------------------------------------------*/
 
684
void AGLTEPS0(AGLDVCOM)
 
685
struct bufcom *AGLDVCOM;
 
686
{
 
687
extern void AG_DMSG();
 
688
 
 
689
showpage(filpt);
 
690
fclose(filpt); filpt=NULL; 
 
691
 
 
692
AG_DMSG("Out file","closed");
 
693
ERRCODE=AGLNOERR;
 
694
CHANNEL=(-1);
 
695
IBUFFR(0)= !file_touch;
 
696
}
 
697