← Back to branch summary

~ubuntu-branches/ubuntu/raring/python-scipy/raring-proposed

« back to all changes in this revision

Viewing changes to Lib/sandbox/xplt/src/gist/ps.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-01-07 14:12:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070107141212-mm0ebkh5b37hcpzn
http://bugs.debian.org/402783
* Remove build dependency on python-numpy-dev.
* python-scipy: Depend on python-numpy instead of python-numpy-dev.
* Package builds on other archs than i386. Closes: #402783.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/sandbox/xplt/src/gist/ps.c
 
1
/*
 
2
 * PS.C
 
3
 *
 
4
 * $Id: ps.c 760 2003-08-21 22:22:00Z travo $
 
5
 *
 
6
 * Implement the PostScript engine for GIST.
 
7
 *
 
8
 */
 
9
/*    Copyright (c) 1994.  The Regents of the University of California.
 
10
                    All rights reserved.  */
 
11
 
 
12
#include "pstdio.h"
 
13
#include "ps.h"
 
14
#include "gtext.h"
 
15
 
 
16
extern p_file *GistOpen(const char *name);  /* from gread.c */
 
17
 
 
18
#include "play.h"
 
19
#include <string.h>
 
20
#include <time.h>
 
21
 
 
22
#ifndef CREATE_PS
 
23
#define CREATE_PS(name) p_fopen(name, "w")
 
24
#endif
 
25
 
 
26
static char *psType= "PostScript";
 
27
 
 
28
static char line[80];  /* no lines longer than 78 characters! */
 
29
 
 
30
#define PS_PER_POINT 20
 
31
#define NDC_TO_PS (20.0/ONE_POINT)
 
32
#define DEFAULT_PS_WIDTH (DEFAULT_LINE_WIDTH*NDC_TO_PS)
 
33
#define N_PSFONTS 20
 
34
#define N_PSDASHES 5
 
35
 
 
36
static int PutPrologLine(p_file *file);
 
37
static p_file *CopyProlog(const char *name, const char *title);
 
38
static void InitBB(GpsBBox *bb);
 
39
static void SetPageDefaults(PSEngine *psEngine);
 
40
static void SetPSTransform(GpTransform *toPixels, int landscape);
 
41
static void GetEPSFBox(int landscape, GpsBBox *bb,
 
42
                  int *xll, int *yll, int *xur, int *yur);
 
43
static int PutLine(PSEngine *psEngine);
 
44
static int Append(PSEngine *psEngine, const char *s);
 
45
static int BeginPage(PSEngine *psEngine);
 
46
static int EndClip(PSEngine *psEngine);
 
47
static int BeginClip(PSEngine *psEngine, GpTransform *trans);
 
48
static int EndPage(PSEngine *psEngine);
 
49
static int PutPoints(PSEngine *psEngine, GpPoint *points, long nPoints,
 
50
                     int margin);
 
51
static int ChangePalette(Engine *engine);
 
52
static void Kill(Engine *engine);
 
53
static int Clear(Engine *engine, int always);
 
54
static int Flush(Engine *engine);
 
55
static int SetupColor(PSEngine *psEngine, unsigned long color);
 
56
static int SetupLine(PSEngine *psEngine, GpLineAttribs *gistAl);
 
57
static int CheckClip(PSEngine *psEngine);
 
58
static int DrawLines(Engine *engine, long n, const GpReal *px,
 
59
                     const GpReal *py, int closed, int smooth);
 
60
static int SetupFont(PSEngine *psEngine, GpReal height);
 
61
static int DrawMarkers(Engine *engine, long n, const GpReal *px,
 
62
                       const GpReal *py);
 
63
static int SetupText(PSEngine *psEngine);
 
64
static int DrwText(Engine *engine, GpReal x0, GpReal y0, const char *text);
 
65
static int DrawFill(Engine *engine, long n, const GpReal *px,
 
66
                    const GpReal *py);
 
67
static int DrawCells(Engine *engine, GpReal px, GpReal py, GpReal qx,
 
68
                     GpReal qy, long width, long height, long nColumns,
 
69
                     const GpColor *colors);
 
70
static int DrawDisjoint(Engine *engine, long n, const GpReal *px,
 
71
                        const GpReal *py, const GpReal *qx, const GpReal *qy);
 
72
 
 
73
static int ps_fputs(p_file *file, char *buf);
 
74
 
 
75
/* ------------------------------------------------------------------------ */
 
76
 
 
77
static const char *titleIs;
 
78
static int needUser, needDate;
 
79
static void *pf_stdout = &titleIs;  /* any non-zero address will do */
 
80
 
 
81
static int
 
82
ps_fputs(p_file *file, char *buf)
 
83
{
 
84
  if (file != pf_stdout) return p_fputs(file, buf);
 
85
  if (g_stdout) g_stdout(buf);
 
86
  return 0;
 
87
}
 
88
 
 
89
static int PutPrologLine(p_file *file)
 
90
{
 
91
  if (titleIs && strncmp(line, "%%Title:", 8L)==0) {
 
92
    line[8]= ' ';
 
93
    line[9]= '\0';
 
94
    strncat(line, titleIs, 60L);
 
95
    strcat(line, "\n");
 
96
    titleIs= 0;
 
97
  } else if (needUser && strncmp(line, "%%For:", 6L)==0) {
 
98
    line[6]= ' ';
 
99
    line[7]= '\0';
 
100
    strncat(line, p_getuser(), 60L);
 
101
    strcat(line, "\n");
 
102
    needUser= 0;
 
103
  } else if (needDate && strncmp(line, "%%CreationDate:", 15L)==0) {
 
104
    time_t t= time((time_t *)0);
 
105
    /* ctime returns 26 chars, e.g.- "Sun Jan  3 15:14:13 1988\n\0" */
 
106
    char *st= (t==-1)? "\n" : ctime(&t);
 
107
    line[15]= ' ';
 
108
    line[16]= '\0';
 
109
    strcat(line, st? st : "\n");
 
110
    needDate= 0;
 
111
  }
 
112
  return ps_fputs(file, line);
 
113
}
 
114
 
 
115
static p_file *CopyProlog(const char *name, const char *title)
 
116
{
 
117
  p_file *psps= GistOpen("ps.ps");
 
118
  p_file *file= strcmp(name, "*stdout*")? CREATE_PS(name) : pf_stdout;
 
119
  if (!psps) strcpy(gistError, "unable to open PostScript prolog ps.ps");
 
120
  if (!file) strcpy(gistError, "unable to create PostScript output file");
 
121
 
 
122
  if (psps && file) {
 
123
    titleIs= title;
 
124
    needUser= needDate= 1;
 
125
    for (;;) {
 
126
      if (!p_fgets(psps, line, 79) || PutPrologLine(file)<0) {
 
127
        if (file!=pf_stdout) p_fclose(file);
 
128
        file= 0;
 
129
        strcpy(gistError, "bad PostScript prolog format in ps.ps??");
 
130
        break;
 
131
      }
 
132
      if (strncmp(line, "%%EndSetup", 10L)==0) break;
 
133
    }
 
134
 
 
135
  } else if (file) {
 
136
    if (file!=pf_stdout) p_fclose(file);
 
137
    file= 0;
 
138
  }
 
139
 
 
140
  if (psps) p_fclose(psps);
 
141
  return file;
 
142
}
 
143
 
 
144
static void InitBB(GpsBBox *bb)
 
145
{
 
146
  bb->xll= bb->yll= 0x7ff0;
 
147
  bb->xur= bb->yur= 0;
 
148
}
 
149
 
 
150
static void SetPageDefaults(PSEngine *psEngine)
 
151
{
 
152
  /* Set current state to match state set by GI procedure in ps.ps */
 
153
  psEngine->curClip= 0;
 
154
  psEngine->curColor= P_FG;
 
155
  psEngine->curType= L_SOLID;
 
156
  psEngine->curWidth= 1.0;
 
157
  psEngine->curFont= T_COURIER;
 
158
  psEngine->curHeight= 12.0*ONE_POINT;
 
159
  psEngine->curAlignH= TH_LEFT;
 
160
  psEngine->curAlignV= TV_BASE;
 
161
  psEngine->curOpaque= 0;
 
162
  InitBB(&psEngine->pageBB);
 
163
}
 
164
 
 
165
static void SetPSTransform(GpTransform *toPixels, int landscape)
 
166
{
 
167
  /* PostScript thinks an 8.5-by-11 inch page is 612-by-792 points */
 
168
  toPixels->window.xmin= toPixels->window.ymin= 0.0;
 
169
  if (landscape) {
 
170
    toPixels->window.xmax= 15840.0;
 
171
    toPixels->window.ymax= 12240.0;
 
172
  } else {
 
173
    toPixels->window.xmax= 12240.0;
 
174
    toPixels->window.ymax= 15840.0;
 
175
  }
 
176
  toPixels->viewport.xmin= toPixels->viewport.ymin= 0.0;
 
177
  toPixels->viewport.xmax= toPixels->window.xmax*(1.0/NDC_TO_PS);
 
178
  toPixels->viewport.ymax= toPixels->window.ymax*(1.0/NDC_TO_PS);
 
179
}
 
180
 
 
181
static void GetEPSFBox(int landscape, GpsBBox *bb,
 
182
                       int *xll, int *yll, int *xur, int *yur)
 
183
{
 
184
  /* Transform bounding box to
 
185
     Document Structure Comment coordinates for use as EPSF file */
 
186
  int xl, yl, xu, yu;
 
187
 
 
188
  if (bb->xll < bb->xur) {
 
189
    /* this is a valid bounding box */
 
190
    xl= bb->xll/PS_PER_POINT;
 
191
    yl= bb->yll/PS_PER_POINT;
 
192
    xu= 1+(bb->xur-1)/PS_PER_POINT;
 
193
    yu= 1+(bb->yur-1)/PS_PER_POINT;
 
194
 
 
195
  } else {
 
196
    /* this is not a valid bounding box, return whole page */
 
197
    xl= yl= 0;
 
198
    xu= 612;    /* In PostScript, 1 inch is exactly 72 points */
 
199
    yu= 792;
 
200
  }
 
201
 
 
202
  if (landscape) {
 
203
    *xll= 612-yu;  *yll= xl;
 
204
    *xur= 612-yl;  *yur= xu;
 
205
  } else {
 
206
    *xll= xl;  *yll= yl;
 
207
    *xur= xu;  *yur= yu;
 
208
  }
 
209
}
 
210
 
 
211
static int PutLine(PSEngine *psEngine)
 
212
{
 
213
  p_file *file= psEngine->file;
 
214
  char *line= psEngine->line;
 
215
  long nchars= psEngine->nchars;
 
216
 
 
217
  if (!file) {
 
218
    if (psEngine->closed) return 1;
 
219
    file= psEngine->file= CopyProlog(psEngine->filename, psEngine->e.name);
 
220
    if (!file) { psEngine->closed= 1;  return 1; }
 
221
    psEngine->currentPage= 1;
 
222
    SetPageDefaults(psEngine);
 
223
    InitBB(&psEngine->docBB);
 
224
  }
 
225
 
 
226
  line[nchars++]= '\n';
 
227
  line[nchars]= '\0';
 
228
  if (ps_fputs(file, line)<0) {
 
229
    if (file!=pf_stdout) p_fclose(file);
 
230
    psEngine->file= 0;
 
231
    psEngine->closed= 1;
 
232
    strcpy(gistError, "p_fputs failed writing PostScript file");
 
233
    return 1;
 
234
  }
 
235
  line[0]= '\0';
 
236
  psEngine->nchars= 0;
 
237
  return 0;
 
238
}
 
239
 
 
240
static int Append(PSEngine *psEngine, const char *s)
 
241
{
 
242
  long len= s? strlen(s) : 0;
 
243
  long nchars= psEngine->nchars;
 
244
  char *line= psEngine->line;
 
245
 
 
246
  if (nchars+1+len>78) {
 
247
    if (PutLine(psEngine)) return 1;
 
248
    nchars= 0;
 
249
  } else if (nchars>0) {
 
250
    line[nchars++]= ' ';
 
251
  }
 
252
  strcpy(line+nchars, s);
 
253
  psEngine->nchars= nchars+len;
 
254
 
 
255
  return 0;
 
256
}
 
257
 
 
258
static int BeginPage(PSEngine *psEngine)
 
259
{
 
260
  int currentPage= psEngine->currentPage;
 
261
 
 
262
  psEngine->e.marked= 1;
 
263
 
 
264
  /* A change in color table can take place only at the beginning
 
265
     of a page.  ChangePalette strobes the palette in the Engine base
 
266
     class part into the PSEngine palette.  */
 
267
  psEngine->nColors= 0;      /* reset to mono mode */
 
268
  ChangePalette((Engine *)psEngine);
 
269
 
 
270
  if (psEngine->nchars && PutLine(psEngine)) return 1;
 
271
  if (PutLine(psEngine)) return 1;
 
272
 
 
273
  sprintf(line, "%%%%Page: %d %d", currentPage, currentPage);
 
274
  if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
275
 
 
276
  if (Append(psEngine, "%%PageBoundingBox: (atend)") ||
 
277
      PutLine(psEngine)) return 1;
 
278
 
 
279
  if (Append(psEngine, "GistPrimitives begin /PG save def GI") ||
 
280
      PutLine(psEngine)) return 1;
 
281
 
 
282
  /* Set transform viewport to reflect current page orientation */
 
283
  if (psEngine->landscape != psEngine->e.landscape) {
 
284
    SetPSTransform(&psEngine->e.transform, psEngine->e.landscape);
 
285
    psEngine->landscape= psEngine->e.landscape;
 
286
  }
 
287
  if (psEngine->landscape) {
 
288
    if (Append(psEngine, "LAND") ||
 
289
        PutLine(psEngine)) return 1;
 
290
  }
 
291
 
 
292
  if (psEngine->e.colorMode && psEngine->e.palette &&
 
293
      psEngine->e.nColors>0) {
 
294
    int i, nColors= psEngine->e.nColors;
 
295
    GpColorCell *palette= psEngine->e.palette;
 
296
    long color;
 
297
    sprintf(line, "%d CT", nColors);
 
298
    if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
299
    for (i=0 ; i<nColors ; i++) {
 
300
      color= P_R(palette[i])<<16 | P_G(palette[i])<<8 | P_B(palette[i]);
 
301
      sprintf(line, "%06lx", color);
 
302
      if (Append(psEngine, line)) return 1;
 
303
    }
 
304
    if (psEngine->nchars && PutLine(psEngine)) return 1;
 
305
    psEngine->colorMode= 1;  /* color table has been written */
 
306
    psEngine->nColors= nColors;
 
307
  } else {
 
308
    psEngine->colorMode= 0;  /* NO color table exists on this page */
 
309
    /* But, if there is a palette, still want to use grays */
 
310
    if (psEngine->e.palette && psEngine->e.nColors>0)
 
311
      psEngine->nColors= psEngine->e.nColors;
 
312
  }
 
313
 
 
314
  if (Append(psEngine, "%%EndPageSetup") || PutLine(psEngine)) return 1;
 
315
  return 0;
 
316
}
 
317
 
 
318
static int EndClip(PSEngine *psEngine)
 
319
{
 
320
  if (psEngine->curClip) {
 
321
    if ((psEngine->nchars && PutLine(psEngine)) ||
 
322
        Append(psEngine, "CLOF")) return 1;
 
323
    psEngine->curClip= 0;
 
324
    /* Restore state at time of CLON */
 
325
    psEngine->curColor= psEngine->clipColor;
 
326
    psEngine->curType= psEngine->clipType;
 
327
    psEngine->curWidth= psEngine->clipWidth;
 
328
    psEngine->curFont= psEngine->clipFont;
 
329
    psEngine->curHeight= psEngine->clipHeight;
 
330
  }
 
331
  return 0;
 
332
}
 
333
 
 
334
static int BeginClip(PSEngine *psEngine, GpTransform *trans)
 
335
{
 
336
  GpReal x[2], y[2];
 
337
  GpPoint *points;
 
338
  int xll, yll, xur, yur;
 
339
  GpBox *port= &trans->viewport;
 
340
  GpBox *box= &psEngine->clipBox;
 
341
 
 
342
  if (!psEngine->e.marked && BeginPage(psEngine)) return 1;
 
343
 
 
344
  if (psEngine->curClip) {
 
345
    if (port->xmin==box->xmin && port->xmax==box->xmax &&
 
346
        port->ymin==box->ymin && port->ymax==box->ymax) return 0;
 
347
    if (EndClip(psEngine)) return 1;
 
348
  }
 
349
 
 
350
  x[0]= trans->window.xmin;  x[1]= trans->window.xmax;
 
351
  y[0]= trans->window.ymin;  y[1]= trans->window.ymax;
 
352
 
 
353
  GpIntPoints(&psEngine->e.map, 3, 2, x, y, &points);
 
354
  if (points[0].x > points[1].x) {
 
355
    xll= points[1].x;  xur= points[0].x;
 
356
  } else {
 
357
    xll= points[0].x;  xur= points[1].x;
 
358
  }
 
359
  if (points[0].y > points[1].y) {
 
360
    yll= points[1].y;  yur= points[0].y;
 
361
  } else {
 
362
    yll= points[0].y;  yur= points[1].y;
 
363
  }
 
364
 
 
365
  sprintf(line, "%d %d %d %d CLON", xur-xll, yur-yll, xll, yll);
 
366
  if (Append(psEngine, line)) return 1;
 
367
  psEngine->curClip= 1;
 
368
  *box= *port;
 
369
 
 
370
  /* Must save state at time of CLON, since CLOF does grestore */
 
371
  psEngine->clipColor= psEngine->curColor;
 
372
  psEngine->clipType= psEngine->curType;
 
373
  psEngine->clipWidth= psEngine->curWidth;
 
374
  psEngine->clipFont= psEngine->curFont;
 
375
  psEngine->clipHeight= psEngine->curHeight;
 
376
  /* Note that text alignment/opacity is not affected by grestore */
 
377
 
 
378
  /* Expand page boundary to include clip boundary */
 
379
  if (xll < psEngine->pageBB.xll) psEngine->pageBB.xll= xll;
 
380
  if (yll < psEngine->pageBB.yll) psEngine->pageBB.yll= yll;
 
381
  if (xur > psEngine->pageBB.xur) psEngine->pageBB.xur= xur;
 
382
  if (yur > psEngine->pageBB.yur) psEngine->pageBB.yur= yur;
 
383
  return 0;
 
384
}
 
385
 
 
386
static int EndPage(PSEngine *psEngine)
 
387
{
 
388
  char *line= psEngine->line;
 
389
  int xll, yll, xur, yur;
 
390
 
 
391
  if (EndClip(psEngine)) return 1;
 
392
 
 
393
  if ((psEngine->nchars && PutLine(psEngine)) ||
 
394
      Append(psEngine, "PG restore") || PutLine(psEngine)) return 1;
 
395
  if (Append(psEngine, "showpage") || PutLine(psEngine)) return 1;
 
396
  if (Append(psEngine, "end") || PutLine(psEngine)) return 1;
 
397
  if (Append(psEngine, "%%PageTrailer") || PutLine(psEngine)) return 1;
 
398
 
 
399
  GetEPSFBox(psEngine->e.landscape, &psEngine->pageBB,
 
400
             &xll, &yll, &xur, &yur);
 
401
  if (xll < psEngine->docBB.xll) psEngine->docBB.xll= xll;
 
402
  if (yll < psEngine->docBB.yll) psEngine->docBB.yll= yll;
 
403
  if (xur > psEngine->docBB.xur) psEngine->docBB.xur= xur;
 
404
  if (yur > psEngine->docBB.yur) psEngine->docBB.yur= yur;
 
405
  sprintf(line, "%%%%PageBoundingBox: %d %d %d %d", xll, yll, xur, yur);
 
406
  if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
407
 
 
408
  psEngine->currentPage++;
 
409
  psEngine->e.marked= 0;
 
410
  SetPageDefaults(psEngine);
 
411
  if (psEngine->file!=pf_stdout) p_fflush(psEngine->file);
 
412
  return 0;
 
413
}
 
414
 
 
415
static char hexChar[17]= "0123456789abcdef";
 
416
 
 
417
static int PutPoints(PSEngine *psEngine, GpPoint *points, long nPoints,
 
418
                     int margin)
 
419
{
 
420
  int ix, iy, i;
 
421
  int xll= 0x7ff0, yll= 0x7ff0, xur= 0, yur= 0;
 
422
  char *now, *line= psEngine->line;
 
423
  int perLine, nchars= psEngine->nchars;
 
424
 
 
425
  if (!psEngine->e.marked && BeginPage(psEngine)) return 1;
 
426
 
 
427
  if (nchars<=0) {
 
428
    now= line;
 
429
    perLine= 9;
 
430
  } else if (nchars<70) {
 
431
    now= line+nchars;
 
432
    perLine= (78-nchars)/8;
 
433
  } else {
 
434
    if (PutLine(psEngine)) return 1;
 
435
    nchars= 0;
 
436
    now= line;
 
437
    perLine= 9;
 
438
  }
 
439
 
 
440
  /* Dump the points in hex 9 (72 chars) to a line */
 
441
  while (nPoints>0) {
 
442
    for (i=0 ; i<perLine ; i++) {
 
443
      ix= points->x;
 
444
      iy= points->y;
 
445
      points++;
 
446
      if (ix<0) ix= xll;           /* be sure x in range, set xll, xur */
 
447
      else if (ix>0x7ff0) ix= xur;
 
448
      else if (ix<xll) xll= ix;
 
449
      else if (ix>xur) xur= ix;
 
450
      if (iy<0) iy= yll;           /* be sure y in range, set yll, yur */
 
451
      else if (iy>0x7ff0) iy= yur;
 
452
      else if (iy<yll) yll= iy;
 
453
      else if (iy>yur) yur= iy;
 
454
      *now++= hexChar[ix>>12];
 
455
      *now++= hexChar[(ix>>8)&0xf];
 
456
      *now++= hexChar[(ix>>4)&0xf];
 
457
      *now++= hexChar[ix&0xf];
 
458
      *now++= hexChar[iy>>12];
 
459
      *now++= hexChar[(iy>>8)&0xf];
 
460
      *now++= hexChar[(iy>>4)&0xf];
 
461
      *now++= hexChar[iy&0xf];
 
462
      nchars+= 8;
 
463
      nPoints--;
 
464
      if (nPoints==0) break;
 
465
    }
 
466
    psEngine->nchars= nchars;
 
467
    if (PutLine(psEngine)) return 1;
 
468
    nchars= 0;
 
469
    now= line;
 
470
    perLine= 9;
 
471
  }
 
472
 
 
473
  /* Adjust the bounding box for the current page */
 
474
  if (xll<xur && !psEngine->curClip) {
 
475
    xll-= margin;
 
476
    xur+= margin;
 
477
    yll-= margin;
 
478
    yur+= margin;
 
479
    if (xll<psEngine->pageBB.xll) psEngine->pageBB.xll= xll;
 
480
    if (xur>psEngine->pageBB.xur) psEngine->pageBB.xur= xur;
 
481
    if (yll<psEngine->pageBB.yll) psEngine->pageBB.yll= yll;
 
482
    if (yur>psEngine->pageBB.yur) psEngine->pageBB.yur= yur;
 
483
  }
 
484
 
 
485
  return 0;
 
486
}
 
487
 
 
488
/* ------------------------------------------------------------------------ */
 
489
 
 
490
static int ChangePalette(Engine *engine)
 
491
{
 
492
  PSEngine *psEngine= (PSEngine *)engine;
 
493
  int nColors= engine->nColors;
 
494
 
 
495
  if (nColors<=0 || !engine->palette) {
 
496
    /* new color table is void-- don't allow indexed colors */
 
497
    psEngine->colorMode= 0;
 
498
    psEngine->nColors= 0;
 
499
 
 
500
  } else {
 
501
    /* remember current color mode, then set to mono mode until
 
502
       new color table can be written in BeginPage */
 
503
    psEngine->colorMode= 0;
 
504
    psEngine->nColors= 0;    /* don't index into table before BeginPage */
 
505
  }
 
506
 
 
507
  engine->colorChange= 0;
 
508
  return 256;
 
509
}
 
510
 
 
511
/* ------------------------------------------------------------------------ */
 
512
 
 
513
static char *psFontNames[N_PSFONTS]= {
 
514
  "Courier", "Courier-Bold", "Courier-Oblique", "Courier-BoldOblique",
 
515
  "Times-Roman", "Times-Bold", "Times-Italic", "Times-BoldItalic",
 
516
  "Helvetica", "Helvetica-Bold", "Helvetica-Oblique", "Helvetica-BoldOblique",
 
517
  "Symbol", "Symbol", "Symbol", "Symbol",
 
518
  "NewCenturySchlbk-Roman", "NewCenturySchlbk-Bold",
 
519
  "NewCenturySchlbk-Italic", "NewCenturySchlbk-BoldItalic" };
 
520
 
 
521
static void Kill(Engine *engine)
 
522
{
 
523
  PSEngine *psEngine= (PSEngine *)engine;
 
524
  long fonts= psEngine->fonts;
 
525
  int i, xll, yll, xur, yur;
 
526
  int bad= 0;
 
527
 
 
528
  if (psEngine->e.marked) bad= EndPage(psEngine);
 
529
 
 
530
  if (psEngine->file) {
 
531
    if (!bad) bad= PutLine(psEngine);
 
532
    if (!bad) bad= Append(psEngine, "%%Trailer");
 
533
    if (!bad) bad= PutLine(psEngine);
 
534
 
 
535
    sprintf(line, "%%%%Pages: %d", psEngine->currentPage-1);
 
536
    if (!bad) bad= Append(psEngine, line);
 
537
    if (!bad) bad= PutLine(psEngine);
 
538
 
 
539
    xll= psEngine->docBB.xll;
 
540
    xur= psEngine->docBB.xur;
 
541
    if (xll < xur) {
 
542
      yll= psEngine->docBB.yll;
 
543
      yur= psEngine->docBB.yur;
 
544
    } else {
 
545
      xll= yll= 0;
 
546
      xur= 612;
 
547
      yur= 792;
 
548
    }
 
549
    sprintf(line, "%%%%BoundingBox: %d %d %d %d", xll, yll, xur, yur);
 
550
    if (!bad) bad= Append(psEngine, line);
 
551
    if (!bad) bad= PutLine(psEngine);
 
552
 
 
553
    strcpy(line, "%%DocumentFonts: ");
 
554
    for (i=0 ; i<N_PSFONTS ; i++) {
 
555
      if ((1<<i) & fonts) {
 
556
        strcat(line, psFontNames[i]);
 
557
        if (!bad) bad= Append(psEngine, line);
 
558
        if (!bad) bad= PutLine(psEngine);
 
559
        strcpy(line, "%%+ ");
 
560
      }
 
561
    }
 
562
 
 
563
    if (psEngine->file!=pf_stdout) p_fclose(psEngine->file);
 
564
  }
 
565
  GpDelEngine(engine);
 
566
}
 
567
 
 
568
static int Clear(Engine *engine, int always)
 
569
{
 
570
  PSEngine *psEngine= (PSEngine *)engine;
 
571
  if (always || engine->marked) EndPage(psEngine);
 
572
  engine->marked= 0;
 
573
  return 0;
 
574
}
 
575
 
 
576
static int Flush(Engine *engine)
 
577
{
 
578
  PSEngine *psEngine= (PSEngine *)engine;
 
579
  if (psEngine->file && psEngine->file!=pf_stdout)
 
580
    p_fflush(psEngine->file);
 
581
  return 0;
 
582
}
 
583
 
 
584
/* ------------------------------------------------------------------------ */
 
585
 
 
586
static char *colorCommands[14]= {
 
587
  "BG", "FG", "BLK", "WHT", "RED", "GRN", "BLU", "CYA", "MAG", "YEL",
 
588
  "GYD", "GYC", "GYB", "GYA" };
 
589
 
 
590
static int SetupColor(PSEngine *psEngine, unsigned long color)
 
591
{
 
592
  int nColors= psEngine->nColors;
 
593
 
 
594
  if (!psEngine->e.marked && BeginPage(psEngine)) return 1;
 
595
  if (color==psEngine->curColor) return 0;
 
596
 
 
597
  if (color<240UL) {
 
598
    /* "CI index C"-- "CI" omitted if current color is indexed */
 
599
    unsigned long c;
 
600
    GpColorCell *palette= psEngine->e.palette;
 
601
    if (nColors>0) {
 
602
      if (color>=(unsigned long)nColors) color= nColors-1;
 
603
      if (psEngine->colorMode) c= color;  /* this page has a color table */
 
604
      else c= (P_R(palette[color])+
 
605
               P_G(palette[color])+P_B(palette[color]))/3;  /* mono page */
 
606
    } else {
 
607
      if (color>255) color= 255;
 
608
      c= color;         /* No palette ==> no color table on page */
 
609
    }
 
610
    if (psEngine->curColor>=240UL) {
 
611
      if (Append(psEngine, "CI")) return 1;
 
612
    }
 
613
    sprintf(line, "%ld C", c);
 
614
    if (Append(psEngine, line)) return 1;
 
615
  } else if (color<256UL) {
 
616
    /* standard color command FG, RED, etc. */
 
617
    if (color<P_GRAYA) color= P_FG;
 
618
    if (Append(psEngine, colorCommands[255UL-color])) return 1;
 
619
  } else {
 
620
    sprintf(line, "16#%lx C", color);
 
621
    if (Append(psEngine, line)) return 1;
 
622
  }
 
623
  psEngine->curColor= color;
 
624
 
 
625
  return 0;
 
626
}
 
627
 
 
628
static int SetupLine(PSEngine *psEngine, GpLineAttribs *gistAl)
 
629
{
 
630
  int changeLW= (psEngine->curWidth!=gistAl->width);
 
631
  if (SetupColor(psEngine, gistAl->color)) return 1;
 
632
 
 
633
  if (changeLW) {
 
634
    int lwidth;
 
635
 
 
636
    lwidth= (int)(DEFAULT_PS_WIDTH*gistAl->width);
 
637
    sprintf(line, "%d LW", lwidth);
 
638
    if (Append(psEngine, line)) return 1;
 
639
 
 
640
    psEngine->curWidth= gistAl->width;
 
641
  }
 
642
 
 
643
  /* WARNING--
 
644
     the dash pattern is a function of the line width (see pscom.ps) */
 
645
  if (psEngine->curType!=gistAl->type ||
 
646
      (changeLW && gistAl->type!=L_SOLID)) {
 
647
    int ltype= gistAl->type;
 
648
    if (ltype==L_NONE) return 1;
 
649
 
 
650
    if (ltype<0 || ltype>N_PSDASHES) ltype= L_SOLID;
 
651
    sprintf(line, "%d DSH", ltype-1);
 
652
    if (Append(psEngine, line)) return 1;
 
653
 
 
654
    psEngine->curType= gistAl->type;
 
655
  }
 
656
 
 
657
  return 0;
 
658
}
 
659
 
 
660
static int CheckClip(PSEngine *psEngine)
 
661
{
 
662
  if (gistClip) return BeginClip(psEngine, &gistT);
 
663
  else if (psEngine->curClip) return EndClip(psEngine);
 
664
  return 0;
 
665
}
 
666
 
 
667
static int DrawLines(Engine *engine, long n, const GpReal *px,
 
668
                     const GpReal *py, int closed, int smooth)
 
669
{
 
670
  PSEngine *psEngine= (PSEngine *)engine;
 
671
  GpXYMap *map= &engine->map;
 
672
  long maxPoints= 4050, nPoints;
 
673
  long np= n + (closed?1:0);
 
674
  int firstPass= 1, markEnd= 0;
 
675
  GpPoint firstPoint, *points;
 
676
  int size;
 
677
 
 
678
  if (CheckClip(psEngine)) return 1;
 
679
  if (n<1) return 0;
 
680
  if (SetupLine(psEngine, &gistA.l)) return 1;
 
681
  if (psEngine->curClip) size= 0;
 
682
  else size= (int)(psEngine->curWidth*0.5*DEFAULT_PS_WIDTH);
 
683
 
 
684
  if (np>90) {
 
685
    long nLines= (np-1)/9 + 1;  /* 9 points is 72 characters */
 
686
    if (psEngine->nchars && PutLine(psEngine)) return 1;
 
687
    sprintf(line, "%%%%BeginData: %ld ASCII Lines", nLines+1);
 
688
    if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
689
    markEnd= 1;
 
690
  }
 
691
  sprintf(line, smooth? "%ld LS" : "%ld L", np);
 
692
  if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
693
 
 
694
  while ((nPoints=
 
695
          GpIntPoints(map, maxPoints, n, px, py, &points))) {
 
696
    if (closed) {
 
697
      if (firstPass) {
 
698
        firstPoint= points[0];
 
699
        firstPass= 0;
 
700
      }
 
701
      if (n==nPoints) {
 
702
        n++;
 
703
        points[nPoints++]= firstPoint;
 
704
      }
 
705
    }
 
706
    if (PutPoints(psEngine, points, nPoints, size)) return 1;
 
707
    if (n==nPoints) break;
 
708
    n-= nPoints;
 
709
    px+= nPoints;
 
710
    py+= nPoints;
 
711
  }
 
712
 
 
713
  if (markEnd) {
 
714
    if (Append(psEngine, "%%EndData") || PutLine(psEngine)) return 1;
 
715
  }
 
716
 
 
717
  return 0;
 
718
}
 
719
 
 
720
/* ------------------------------------------------------------------------ */
 
721
 
 
722
static char *psFontCommands[N_PSFONTS]= {
 
723
  "0 Cour", "1 Cour", "2 Cour", "3 Cour",
 
724
  "0 Tims", "1 Tims", "2 Tims", "3 Tims",
 
725
  "0 Helv", "1 Helv", "2 Helv", "3 Helv",
 
726
  "0 Symb", "1 Symb", "2 Symb", "3 Symb",
 
727
  "0 NCen", "1 NCen", "2 NCen", "3 NCen" };
 
728
 
 
729
static int SetupFont(PSEngine *psEngine, GpReal height)
 
730
{
 
731
  int font= gistA.t.font;
 
732
  if (font<0 || font>=N_PSFONTS) font= 0;
 
733
  if (psEngine->curFont!=font ||
 
734
      psEngine->curHeight!=height) {
 
735
    int ptSz= (int)(gistA.t.height*NDC_TO_PS+0.5);
 
736
    int lnSp= ptSz;   /* LnSp same as PtSz for now */
 
737
    if (Append(psEngine, psFontCommands[font])) return 1;
 
738
    sprintf(line, "%d %d FNT", ptSz, lnSp);
 
739
    if (Append(psEngine, line)) return 1;
 
740
    psEngine->curFont= font;
 
741
    psEngine->curHeight= height;
 
742
    psEngine->fonts|= (1<<font);
 
743
  }
 
744
  return 0;
 
745
}
 
746
 
 
747
static int DrawMarkers(Engine *engine, long n, const GpReal *px,
 
748
                       const GpReal *py)
 
749
{
 
750
  PSEngine *psEngine= (PSEngine *)engine;
 
751
  GpXYMap *map= &engine->map;
 
752
  long maxPoints= 4050, nPoints;
 
753
  int type, markEnd= 0;
 
754
  GpPoint *points;
 
755
  int size;
 
756
  char typeString[8];
 
757
 
 
758
  if (n<1 || gistA.m.type<=0) return 0;
 
759
  if (CheckClip(psEngine)) return 1;
 
760
  if (SetupColor(psEngine, gistA.m.color) ||
 
761
      SetupFont(psEngine, gistA.m.size*DEFAULT_MARKER_SIZE)) return 1;
 
762
  if (psEngine->curClip) size= 0;
 
763
  else size= (int)(psEngine->curHeight*NDC_TO_PS);
 
764
 
 
765
  if (gistA.m.type>32 && gistA.m.type<127) {
 
766
    char *now= typeString;
 
767
    *now++= '(';
 
768
    if (gistA.m.type=='(' || gistA.m.type==')' || gistA.m.type=='\\')
 
769
      *now++= '\\';
 
770
    *now++= type= gistA.m.type;
 
771
    *now++= ')';
 
772
    *now++= '\0';
 
773
  } else {
 
774
    if (gistA.m.type<0 || gistA.m.type>M_CROSS) type= M_ASTERISK;
 
775
    else type= gistA.m.type;
 
776
    sprintf(typeString, "%d", type-1);
 
777
  }
 
778
 
 
779
  if (n>90) {
 
780
    long nLines= (n-1)/9 + 1;  /* 9 points is 72 characters */
 
781
    if (psEngine->nchars && PutLine(psEngine)) return 1;
 
782
    sprintf(line, "%%%%BeginData: %ld ASCII Lines", nLines+1);
 
783
    if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
784
    markEnd= 1;
 
785
  }
 
786
  if (Append(psEngine, typeString)) return 1;  /* "(A)" or "1", e.g. */
 
787
  sprintf(line, type<32? "%ld MS" : "%ld M", n);
 
788
  if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
789
 
 
790
  while ((nPoints=
 
791
          GpIntPoints(map, maxPoints, n, px, py, &points))) {
 
792
    if (PutPoints(psEngine, points, nPoints, size)) return 1;
 
793
    if (n==nPoints) break;
 
794
    n-= nPoints;
 
795
    px+= nPoints;
 
796
    py+= nPoints;
 
797
  }
 
798
 
 
799
  if (markEnd) {
 
800
    if (Append(psEngine, "%%EndData") || PutLine(psEngine)) return 1;
 
801
  }
 
802
 
 
803
  return 0;
 
804
}
 
805
 
 
806
/* ------------------------------------------------------------------------ */
 
807
 
 
808
static char *psHCommands[3]= { "/LF", "/CN", "/RT" };
 
809
static char *psVCommands[5]= { "/TP", "/CP", "/HF", "/BA", "/BT" };
 
810
 
 
811
static int SetupText(PSEngine *psEngine)
 
812
{
 
813
  int opq;
 
814
  int h= gistA.t.alignH, v= gistA.t.alignV;
 
815
  GtGetAlignment(&gistA.t, &h, &v);
 
816
 
 
817
  if (SetupColor(psEngine, gistA.t.color)) return 1;
 
818
 
 
819
  if (psEngine->curAlignH!=h || psEngine->curAlignV!=v) {
 
820
    sprintf(line, "%s %s JUS", psHCommands[h-1], psVCommands[v-1]);
 
821
    if (Append(psEngine, line)) return 1;
 
822
    psEngine->curAlignH= h;
 
823
    psEngine->curAlignV= v;
 
824
  }
 
825
 
 
826
  opq= gistA.t.opaque;
 
827
  /* if (gistA.t.orient!=TX_RIGHT) opq= 1; let this be X only limitation */
 
828
  if (psEngine->curOpaque != (opq!=0)) {
 
829
    if (opq) Append(psEngine, "1 OPQ");
 
830
    else if (Append(psEngine, "0 OPQ")) return 1;
 
831
    psEngine->curOpaque= (opq!=0);
 
832
  }
 
833
 
 
834
  if (psEngine->curFont!=gistA.t.font ||
 
835
      psEngine->curHeight!=gistA.t.height) {
 
836
    if (SetupFont(psEngine, gistA.t.height)) return 1;
 
837
  }
 
838
  return 0;
 
839
}
 
840
 
 
841
static int break_line_now(PSEngine *psEngine, char **nw, int *nchs);
 
842
 
 
843
static int DrwText(Engine *engine, GpReal x0, GpReal y0, const char *text)
 
844
{
 
845
  PSEngine *psEngine= (PSEngine *)engine;
 
846
  int ix, iy, nlines;
 
847
  GpReal width, height, lineHeight;
 
848
  GpXYMap *map= &engine->map;
 
849
  GpBox *wind= &engine->transform.window;
 
850
  GpReal xmin, xmax, ymin, ymax;
 
851
  int xll, yll, xur, yur, alignH, alignV;
 
852
  int count, nchars, firstPass;
 
853
  char *now, c;
 
854
  const char *t;
 
855
  int state= 0;
 
856
 
 
857
  if (CheckClip(psEngine) || SetupText(psEngine)) return 1;
 
858
  alignH= psEngine->curAlignH;
 
859
  alignV= psEngine->curAlignV;
 
860
  /* Compute text location in PostScript coordinates.  */
 
861
  x0= map->x.scale*x0 + map->x.offset;
 
862
  y0= map->y.scale*y0 + map->y.offset;
 
863
 
 
864
  /* handle multi-line strings */
 
865
  nlines= GtTextShape(text, &gistA.t, (WidthFunction)0, &width);
 
866
  lineHeight= gistA.t.height * NDC_TO_PS;
 
867
  width*= 0.6*lineHeight;
 
868
  height= lineHeight*(GpReal)nlines;
 
869
 
 
870
  /* Reject if and only if the specified point is off of the current
 
871
     page by more than the approximate size of the text.  Note that
 
872
     the entire block of text is either accepted or rejected --
 
873
     PostScript does the clipping.  */
 
874
  if (wind->xmax>wind->xmin) { xmin= wind->xmin; xmax= wind->xmax; }
 
875
  else { xmin= wind->xmax; xmax= wind->xmin; }
 
876
  if (wind->ymax>wind->ymin) { ymin= wind->ymin; ymax= wind->ymax; }
 
877
  else { ymin= wind->ymax; ymax= wind->ymin; }
 
878
  if (gistA.t.orient==TX_RIGHT || gistA.t.orient==TX_LEFT) {
 
879
    if (x0<xmin-width || x0>xmax+width ||
 
880
        y0<ymin-height || y0>ymax+height) return 0;
 
881
  } else {
 
882
    if (x0<xmin-height || x0>xmax+height ||
 
883
        y0<ymin-width || y0>ymax+width) return 0;
 
884
  }
 
885
 
 
886
  /* Adjust y0 (or x0) to represent topmost line */
 
887
  if (nlines > 1) {
 
888
    if (gistA.t.orient==TX_RIGHT) {
 
889
      if (alignV==TV_BASE || alignV==TV_BOTTOM) y0+= height-lineHeight;
 
890
      if (alignV==TV_HALF) y0+= 0.5*(height-lineHeight);
 
891
    } else if (gistA.t.orient==TX_LEFT) {
 
892
      if (alignV==TV_BASE || alignV==TV_BOTTOM) y0-= height-lineHeight;
 
893
      if (alignV==TV_HALF) y0-= 0.5*(height-lineHeight);
 
894
    } else if (gistA.t.orient==TX_UP) {
 
895
      if (alignV==TV_BASE || alignV==TV_BOTTOM) x0-= height-lineHeight;
 
896
      if (alignV==TV_HALF) x0-= 0.5*(height-lineHeight);
 
897
    } else {
 
898
      if (alignV==TV_BASE || alignV==TV_BOTTOM) x0+= height-lineHeight;
 
899
      if (alignV==TV_HALF) x0+= 0.5*(height-lineHeight);
 
900
    }
 
901
  }
 
902
 
 
903
  ix= (int)x0;
 
904
  iy= (int)y0;
 
905
 
 
906
  /* Guess at the bounding box for the text */
 
907
  if (!psEngine->curClip) {
 
908
    if (gistA.t.orient==TX_RIGHT) {
 
909
 
 
910
      if (alignH==TH_CENTER) x0 -= 0.5*width;
 
911
      else if (alignH==TH_RIGHT) x0 -= width;
 
912
 
 
913
      if (alignV==TV_TOP || alignV==TV_CAP) y0 -= height;
 
914
      else if (alignV==TV_HALF) y0 -= height-0.4*lineHeight;
 
915
      else if (alignV==TV_BASE) y0 -= height-0.8*lineHeight;
 
916
      else if (alignV==TV_BOTTOM) y0 -= height-lineHeight;
 
917
 
 
918
    } else if (gistA.t.orient==TX_LEFT) {
 
919
 
 
920
      if (alignH==TH_CENTER) x0 -= 0.5*width;
 
921
      else if (alignH==TH_LEFT) x0 -= width;
 
922
 
 
923
      if (alignV==TV_HALF) y0 -= .4*lineHeight;
 
924
      else if (alignV==TV_BASE) y0 -= 0.8*lineHeight;
 
925
      else if (alignV==TV_BOTTOM) y0 -= lineHeight;
 
926
 
 
927
    } else if (gistA.t.orient==TX_UP) {
 
928
      
 
929
      if (alignH==TH_CENTER) y0 -= 0.5*width;
 
930
      else if (alignH==TH_RIGHT) y0 -= width;
 
931
 
 
932
      if (alignV==TV_HALF) x0 -= 0.4*lineHeight;
 
933
      else if (alignV==TV_BASE) x0 -= 0.8*lineHeight;
 
934
      else if (alignV==TV_BOTTOM) x0 -= lineHeight;
 
935
 
 
936
    } else { /* TX_DOWN */
 
937
 
 
938
      if (alignH==TH_CENTER) y0 -= 0.5*width;
 
939
      else if (alignH==TH_LEFT) y0 -= width;
 
940
 
 
941
      if (alignV==TV_TOP || alignV==TV_CAP) x0 -= height;
 
942
      else if (alignV==TV_HALF) x0 -= height-0.4*lineHeight;
 
943
      else if (alignV==TV_BASE) x0 -= height-0.8*lineHeight;
 
944
      else if (alignV==TV_BOTTOM) x0 -= height-lineHeight;
 
945
 
 
946
    }
 
947
 
 
948
    if (x0>xmin) xmin= x0;
 
949
    if (x0+width<xmax) xmax= x0+width;
 
950
    if (y0>ymin) ymin= y0;
 
951
    if (y0+height<ymax) ymax= y0+height;    
 
952
 
 
953
    xll= (int)xmin;
 
954
    xur= (int)xmax;
 
955
    yll= (int)ymin;
 
956
    yur= (int)ymax;
 
957
    if (xll<psEngine->pageBB.xll) psEngine->pageBB.xll= xll;
 
958
    if (xur>psEngine->pageBB.xur) psEngine->pageBB.xur= xur;
 
959
    if (yll<psEngine->pageBB.yll) psEngine->pageBB.yll= yll;
 
960
    if (yur>psEngine->pageBB.yur) psEngine->pageBB.yur= yur;
 
961
  }
 
962
 
 
963
  if (nlines>1 || gistA.t.orient!=TX_RIGHT) {
 
964
    if (Append(psEngine, "[")) return 1;
 
965
  }
 
966
 
 
967
  nchars= psEngine->nchars;
 
968
  now= psEngine->line+nchars;
 
969
  firstPass= 1;
 
970
  while ((t= GtNextLine(text, &count, gistA.t.orient)) || firstPass) {
 
971
    text= t;
 
972
    firstPass= 0;
 
973
    state= 0;
 
974
 
 
975
    if (nchars > 70) {
 
976
      psEngine->nchars= nchars;
 
977
      if (PutLine(psEngine)) return 1;
 
978
      nchars= 0;
 
979
      now= psEngine->line;
 
980
    }
 
981
    *now++= ' ';
 
982
    *now++= '(';
 
983
    nchars+= 2;
 
984
 
 
985
    while (count--) {
 
986
      if (nchars>72 && break_line_now(psEngine, &now, &nchars)) return 1;
 
987
 
 
988
      c= *text;
 
989
      if (c>=32 && c<127) {
 
990
        if (gtDoEscapes) {
 
991
          if (c=='!' && count) {
 
992
            c= text[1];  /* peek at next char */
 
993
            if (c=='!' || c=='^' || c=='_') {
 
994
              count--;
 
995
              text++;
 
996
              goto normal;
 
997
            }
 
998
            if (nchars>68 &&
 
999
                break_line_now(psEngine, &now, &nchars)) return 1;
 
1000
            strcpy(now, "\\024");  /* DC4 is ps.ps escape char */
 
1001
            now+= 4;
 
1002
            nchars+= 4;
 
1003
            psEngine->fonts|= (1<<T_SYMBOL);  /* symbol font used */
 
1004
            if (c==']') {
 
1005
              *now++= '^';         /* !] means ^ (perp) in symbol font */
 
1006
              nchars++;
 
1007
              text+= 2;
 
1008
              count--;
 
1009
              continue;
 
1010
            }
 
1011
            goto escape;
 
1012
          } else if (c=='^') {
 
1013
            if (state!=0) {
 
1014
              /* terminate current super or subscript escape */
 
1015
              strcpy(now, "\\021");  /* DC1 is ps.ps escape char */
 
1016
              now+= 4;
 
1017
              nchars+= 4;
 
1018
            }
 
1019
            if (state!=1) {
 
1020
              /* intialize superscript escape */
 
1021
              if (nchars>64 &&
 
1022
                  break_line_now(psEngine, &now, &nchars)) return 1;
 
1023
              strcpy(now, "\\021\\022");  /* DC1DC2 is ps.ps escape seq */
 
1024
              now+= 8;
 
1025
              nchars+= 8;
 
1026
              state= 1;
 
1027
            } else {
 
1028
              state= 0;
 
1029
            }
 
1030
            goto escape;
 
1031
          } else if (c=='_') {
 
1032
            if (state!=0) {
 
1033
              /* terminate current super or subscript escape */
 
1034
              if (nchars>68 &&
 
1035
                  break_line_now(psEngine, &now, &nchars)) return 1;
 
1036
              strcpy(now, "\\021");  /* DC1 is ps.ps escape char */
 
1037
              now+= 4;
 
1038
              nchars+= 4;
 
1039
            }
 
1040
            if (state!=2) {
 
1041
              /* intialize subscript escape */
 
1042
              if (nchars>64 &&
 
1043
                  break_line_now(psEngine, &now, &nchars)) return 1;
 
1044
              strcpy(now, "\\021\\023");  /* DC1DC3 is ps.ps escape seq */
 
1045
              now+= 8;
 
1046
              nchars+= 8;
 
1047
              state= 2;
 
1048
            } else {
 
1049
              state= 0;
 
1050
            }
 
1051
            goto escape;
 
1052
          }
 
1053
        }
 
1054
        /* ordinary printing character */
 
1055
        if (c=='(' || c==')' || c=='\\') {
 
1056
          *now++= '\\';
 
1057
          nchars++;
 
1058
        }
 
1059
      normal:
 
1060
        *now++= c;
 
1061
        nchars++;
 
1062
      } else {
 
1063
        /* non-printing characters rendered as \ooo */
 
1064
        if (c=='\t') {
 
1065
          *now++= '\\';
 
1066
          *now++= 't';
 
1067
          nchars+= 2;
 
1068
        } else if (c<'\021' || c>'\024') {
 
1069
          /* DC1 through DC4 have special meaning in ps.ps, skip them */
 
1070
          sprintf(now, "\\%03o", (int)((unsigned char)c));
 
1071
          now+= 4;
 
1072
          nchars+= 4;
 
1073
        }
 
1074
      }
 
1075
    escape:
 
1076
      text++;
 
1077
    }
 
1078
    if (state!=0) {
 
1079
      /* terminate current super or subscript escape */
 
1080
      strcpy(now, "\\021");  /* DC1 is ps.ps escape char */
 
1081
      now+= 4;
 
1082
      nchars+= 4;
 
1083
    }
 
1084
 
 
1085
    *now++= ')';
 
1086
    nchars++;
 
1087
    *now= '\0';
 
1088
  }
 
1089
  psEngine->nchars= nchars;
 
1090
 
 
1091
  if (gistA.t.orient==TX_RIGHT) {
 
1092
    sprintf(line, nlines>1? "] %d %d TA" : "%d %d T", ix, iy);
 
1093
  } else {
 
1094
    int angle;
 
1095
    if (gistA.t.orient==TX_LEFT) angle= 180;
 
1096
    else if (gistA.t.orient==TX_UP) angle= 90;
 
1097
    else angle= 270;
 
1098
    sprintf(line, "] %d %d %d TR", angle, ix, iy);
 
1099
  }
 
1100
  if (Append(psEngine, line)) return 1;
 
1101
 
 
1102
  return 0;
 
1103
}
 
1104
 
 
1105
static int break_line_now(PSEngine *psEngine, char **nw, int *nchs)
 
1106
{
 
1107
  char *now= *nw;
 
1108
  *now++= '\\';
 
1109
  *now= '\0';
 
1110
  psEngine->nchars= *nchs+1;
 
1111
  if (PutLine(psEngine)) return 1;
 
1112
  *nchs= 0;
 
1113
  *nw= psEngine->line;
 
1114
  return 0;
 
1115
}
 
1116
 
 
1117
/* ------------------------------------------------------------------------ */
 
1118
 
 
1119
static int DrawFill(Engine *engine, long n, const GpReal *px,
 
1120
                    const GpReal *py)
 
1121
{
 
1122
  PSEngine *psEngine= (PSEngine *)engine;
 
1123
  GpXYMap *map= &engine->map;
 
1124
  long maxPoints= 4050, nPoints;
 
1125
  int markEnd= 0;
 
1126
  GpPoint *points;
 
1127
  int value= 0;
 
1128
 
 
1129
  /* For now, only FillSolid style supported */
 
1130
 
 
1131
  if (n<1) return 0;
 
1132
  if (CheckClip(psEngine) || SetupColor(psEngine, gistA.f.color)) return 1;
 
1133
 
 
1134
  if (n>90) {
 
1135
    long nLines= (n-1)/9 + 1;  /* 9 points is 72 characters */
 
1136
    if (psEngine->nchars && PutLine(psEngine)) return 1;
 
1137
    sprintf(line, "%%%%BeginData: %ld ASCII Lines", nLines+1);
 
1138
    if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
1139
    markEnd= 1;
 
1140
  }
 
1141
  if (gistA.e.type==L_NONE) sprintf(line, "%ld F", n);
 
1142
  else sprintf(line, "%ld E", n);
 
1143
  if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
1144
 
 
1145
  while ((nPoints=
 
1146
          GpIntPoints(map, maxPoints, n, px, py, &points))) {
 
1147
    if (PutPoints(psEngine, points, nPoints, 0)) return 1;
 
1148
    if (n==nPoints) break;
 
1149
    n-= nPoints;
 
1150
    px+= nPoints;
 
1151
    py+= nPoints;
 
1152
    value= 1;   /* Polygons with >4050 sides won't be filled correctly */
 
1153
  }
 
1154
  if (gistA.e.type!=L_NONE) {
 
1155
    /* setup for edge (usually different color than fill), then draw it */
 
1156
    if (SetupLine(psEngine, &gistA.e)) return 1;
 
1157
    if (Append(psEngine, "0 E") || PutLine(psEngine)) return 1;
 
1158
  }
 
1159
 
 
1160
  if (markEnd) {
 
1161
    if (Append(psEngine, "%%EndData") || PutLine(psEngine)) return 1;
 
1162
  }
 
1163
 
 
1164
  return value;
 
1165
}
 
1166
 
 
1167
/* ------------------------------------------------------------------------ */
 
1168
 
 
1169
static int DrawCells(Engine *engine, GpReal px, GpReal py, GpReal qx,
 
1170
                     GpReal qy, long width, long height, long nColumns,
 
1171
                     const GpColor *colors)
 
1172
{
 
1173
  PSEngine *psEngine= (PSEngine *)engine;
 
1174
  GpXYMap *map= &psEngine->e.map;
 
1175
  int nColors= psEngine->nColors;
 
1176
  GpColorCell *palette;
 
1177
  int ix, iy, idx, idy, depth;
 
1178
  long i, j, off;
 
1179
  int markEnd= 0;
 
1180
  long nLines;
 
1181
  char *now= psEngine->line;
 
1182
  int nc, ncmax, color, colorMode;
 
1183
 
 
1184
  if (!psEngine->e.marked && BeginPage(psEngine)) return 1;
 
1185
  if (CheckClip(psEngine)) return 1;
 
1186
 
 
1187
  /* Transform corner coordinates, clipping and adjusting width,
 
1188
     height, nColumns, and colors as necessary.  */
 
1189
  width = GpClipCells(&map->x, &px, &qx,
 
1190
                      gistT.window.xmin, gistT.window.xmax, width, &off);
 
1191
  colors += gistA.rgb? 3*off : off;
 
1192
  height = GpClipCells(&map->y, &py, &qy,
 
1193
                       gistT.window.ymin, gistT.window.ymax, height, &off);
 
1194
  colors += gistA.rgb? 3*nColumns*off : nColumns*off;
 
1195
 
 
1196
  if (width<=0 || height<=0) return 0;
 
1197
  ix= (int)px;
 
1198
  iy= (int)py;
 
1199
  idx= (int)(qx-px);
 
1200
  idy= (int)(qy-py);
 
1201
 
 
1202
  /* Set bounding box for image if necessary */
 
1203
  if (!psEngine->curClip) {
 
1204
    GpBox *wind= &engine->transform.window;
 
1205
    GpReal xmin, xmax, ymin, ymax;
 
1206
    int xll, yll, xur, yur;
 
1207
    if (wind->xmax>wind->xmin) { xmin= wind->xmin; xmax= wind->xmax; }
 
1208
    else { xmin= wind->xmax; xmax= wind->xmin; }
 
1209
    if (wind->ymax>wind->ymin) { ymin= wind->ymin; ymax= wind->ymax; }
 
1210
    else { ymin= wind->ymax; ymax= wind->ymin; }
 
1211
 
 
1212
    if (px<qx) {
 
1213
      if (px>xmin) xmin= px;
 
1214
      if (qx<xmax) xmax= qx;
 
1215
    } else {
 
1216
      if (qx>xmin) xmin= qx;
 
1217
      if (px<xmax) xmax= px;
 
1218
    }
 
1219
    if (py<qy) {
 
1220
      if (py>ymin) ymin= py;
 
1221
      if (qy<ymax) ymax= qy;
 
1222
    } else {
 
1223
      if (qy>ymin) ymin= qy;
 
1224
      if (py<ymax) ymax= py;
 
1225
    }
 
1226
 
 
1227
    xll= (int)xmin;
 
1228
    xur= (int)xmax;
 
1229
    yll= (int)ymin;
 
1230
    yur= (int)ymax;
 
1231
    if (xll<psEngine->pageBB.xll) psEngine->pageBB.xll= xll;
 
1232
    if (xur>psEngine->pageBB.xur) psEngine->pageBB.xur= xur;
 
1233
    if (yll<psEngine->pageBB.yll) psEngine->pageBB.yll= yll;
 
1234
    if (yur>psEngine->pageBB.yur) psEngine->pageBB.yur= yur;
 
1235
  }
 
1236
 
 
1237
  /* Use 4 bit depth if the color table is small, otherwise use
 
1238
     8 bit depth.  */
 
1239
  if (nColors>0) {
 
1240
    /* Image value will be either  */
 
1241
    colorMode= psEngine->colorMode;
 
1242
    if (colorMode) {
 
1243
      palette= 0;                     /* palette already written */
 
1244
      if (nColors>16) depth= 8;
 
1245
      else depth= 4;
 
1246
    } else {
 
1247
      palette= psEngine->e.palette;   /* must lookup gray level now */
 
1248
      depth= 8;
 
1249
    }
 
1250
  } else {
 
1251
    /* Must assume image varies over maximum possible range */
 
1252
    colorMode= 1;  /* That is, use index without trying palette lookup */
 
1253
    depth= 8;
 
1254
    palette= 0;
 
1255
  }
 
1256
 
 
1257
  if (gistA.rgb) {
 
1258
    /* Write the 6 arguments to the J procedure */
 
1259
    sprintf(line, "%d %d %d %d %d %d",
 
1260
            (int)width, (int)height, idx, idy, ix, iy);
 
1261
  } else {
 
1262
    /* Write the 7 arguments to the I procedure */
 
1263
    sprintf(line, "%d %d %d %d %d %d %d",
 
1264
            (int)width, (int)height, depth, idx, idy, ix, iy);
 
1265
  }
 
1266
  if (Append(psEngine, line)) return 1;
 
1267
 
 
1268
  if (gistA.rgb) {
 
1269
    nLines= 6*width*height;
 
1270
    ncmax = 72;   /* 12 cells (72 chars) per line */
 
1271
  } else {
 
1272
    nLines= width*height;
 
1273
    depth= (depth==8);
 
1274
    if (depth) nLines*= 2;
 
1275
    else if (nLines&1L) nLines++;
 
1276
    ncmax = 76;   /* Will put 76 or 38 cells per line */
 
1277
  }
 
1278
  nLines= 1+(nLines-1)/ncmax;
 
1279
  if (nLines>10) {
 
1280
    if (psEngine->nchars && PutLine(psEngine)) return 1;
 
1281
    sprintf(line, "%%%%BeginData: %ld ASCII Lines", nLines+1);
 
1282
    if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
1283
    markEnd= 1;
 
1284
  }
 
1285
  if (Append(psEngine, gistA.rgb?"J":"I") || PutLine(psEngine)) return 1;
 
1286
 
 
1287
  i= j= 0;
 
1288
  while (nLines--) {
 
1289
    for (nc=0 ; nc<ncmax ; ) {
 
1290
      if (i>=width) {
 
1291
        height--;
 
1292
        if (height<=0) break;
 
1293
        i= 0;
 
1294
        j+= nColumns;
 
1295
      }
 
1296
      if (gistA.rgb) {
 
1297
        const GpColor *ccell = &colors[3*(i+j)];
 
1298
        now[nc++] = hexChar[ccell[0]>>4];
 
1299
        now[nc++] = hexChar[ccell[0]&0xf];
 
1300
        now[nc++] = hexChar[ccell[1]>>4];
 
1301
        now[nc++] = hexChar[ccell[1]&0xf];
 
1302
        now[nc++] = hexChar[ccell[2]>>4];
 
1303
        now[nc++] = hexChar[ccell[2]&0xf];
 
1304
      } else {
 
1305
        color= colors[i+j];
 
1306
        i++;
 
1307
        if (color>=nColors && nColors>0) color= nColors-1;
 
1308
        if (!colorMode) color= (P_R(palette[color])+
 
1309
                                P_G(palette[color])+P_B(palette[color]))/3;
 
1310
        if (depth) {  /* 2 hex chars per cell */
 
1311
          now[nc++]= hexChar[color>>4];
 
1312
          now[nc++]= hexChar[color&0xf];
 
1313
        } else {      /* 1 hex char per cell */
 
1314
          now[nc++]= hexChar[color];
 
1315
        }
 
1316
      }
 
1317
    }
 
1318
    now[nc]= '\0';
 
1319
    psEngine->nchars= nc;
 
1320
    if (PutLine(psEngine)) return 1;
 
1321
  }
 
1322
 
 
1323
  if (markEnd) {
 
1324
    if (Append(psEngine, "%%EndData") || PutLine(psEngine)) return 1;
 
1325
  }
 
1326
 
 
1327
  return 0;
 
1328
}
 
1329
 
 
1330
/* ------------------------------------------------------------------------ */
 
1331
 
 
1332
static int DrawDisjoint(Engine *engine, long n, const GpReal *px,
 
1333
                        const GpReal *py, const GpReal *qx, const GpReal *qy)
 
1334
{
 
1335
  PSEngine *psEngine= (PSEngine *)engine;
 
1336
  GpXYMap *map= &engine->map;
 
1337
  long maxSegs= 2025, nSegs;
 
1338
  int markEnd= 0;
 
1339
  GpSegment *segs;
 
1340
  int size;
 
1341
 
 
1342
  if (CheckClip(psEngine)) return 1;
 
1343
  if (n<1 || SetupLine(psEngine, &gistA.l)) return 0;
 
1344
  if (psEngine->curClip) size= 0;
 
1345
  else size= (int)(psEngine->curWidth*0.5*DEFAULT_PS_WIDTH);
 
1346
 
 
1347
  if (n>45) {
 
1348
    long nLines= (2*n-1)/9 + 1;  /* 9 points is 72 characters */
 
1349
    if (psEngine->nchars && PutLine(psEngine)) return 1;
 
1350
    sprintf(line, "%%%%BeginData: %ld ASCII Lines", nLines+1);
 
1351
    if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
1352
    markEnd= 1;
 
1353
  }
 
1354
  sprintf(line, "%ld D", n);
 
1355
  if (Append(psEngine, line) || PutLine(psEngine)) return 1;
 
1356
 
 
1357
  while ((nSegs=
 
1358
          GpIntSegs(map, maxSegs, n, px, py, qx, qy, &segs))) {
 
1359
    /* This cast from GpPoint to GpSegment is lazy programming,
 
1360
       but I don't know of any platforms it will not work on... */
 
1361
    if (PutPoints(psEngine, (GpPoint *)segs, 2*nSegs, size)) return 1;
 
1362
    if (n==nSegs) break;
 
1363
    n-= nSegs;
 
1364
    px+= nSegs;
 
1365
    py+= nSegs;
 
1366
    qx+= nSegs;
 
1367
    qy+= nSegs;
 
1368
  }
 
1369
 
 
1370
  if (markEnd) {
 
1371
    if (Append(psEngine, "%%EndData") || PutLine(psEngine)) return 1;
 
1372
  }
 
1373
 
 
1374
  return 0;
 
1375
}
 
1376
 
 
1377
/* ------------------------------------------------------------------------ */
 
1378
 
 
1379
Engine *GpPSEngine(char *name, int landscape, int mode, char *file)
 
1380
{
 
1381
  PSEngine *psEngine;
 
1382
  long flen= file? strlen(file) : 0;
 
1383
  long engineSize= sizeof(PSEngine)+flen+1;
 
1384
  GpTransform toPixels;
 
1385
 
 
1386
  if (flen<=0) return 0;
 
1387
 
 
1388
  SetPSTransform(&toPixels, landscape);
 
1389
 
 
1390
  psEngine=
 
1391
    (PSEngine *)GpNewEngine(engineSize, name, psType, &toPixels, landscape,
 
1392
                            &Kill, &Clear, &Flush, &GpComposeMap,
 
1393
                            &ChangePalette, &DrawLines, &DrawMarkers,
 
1394
                            &DrwText, &DrawFill, &DrawCells,
 
1395
                            &DrawDisjoint);
 
1396
 
 
1397
  if (!psEngine) {
 
1398
    strcpy(gistError, "memory manager failed in GpPSEngine");
 
1399
    return 0;
 
1400
  }
 
1401
 
 
1402
  psEngine->filename= (char *)(psEngine+1);
 
1403
  strcpy(psEngine->filename, file);
 
1404
  psEngine->file= 0;
 
1405
  psEngine->closed= 0;
 
1406
 
 
1407
  SetPageDefaults(psEngine);
 
1408
  psEngine->e.colorMode= mode;
 
1409
  psEngine->colorMode= 0;
 
1410
  psEngine->nColors= 0;
 
1411
 
 
1412
  psEngine->landscape= landscape;
 
1413
  psEngine->docBB.xll= psEngine->docBB.xur=
 
1414
    psEngine->docBB.yll= psEngine->docBB.yur= 0;
 
1415
  psEngine->currentPage= 1;
 
1416
  psEngine->fonts|= (1<<T_COURIER);
 
1417
 
 
1418
  psEngine->clipColor= psEngine->curColor;
 
1419
  psEngine->clipType= psEngine->curType;
 
1420
  psEngine->clipWidth= psEngine->curWidth;
 
1421
  psEngine->clipFont= psEngine->curFont;
 
1422
  psEngine->clipHeight= psEngine->curHeight;
 
1423
 
 
1424
  psEngine->clipBox.xmin= psEngine->clipBox.xmax=
 
1425
    psEngine->clipBox.ymin= psEngine->clipBox.ymax= 0.0;
 
1426
 
 
1427
  psEngine->line[0]= '\0';
 
1428
  psEngine->nchars= 0;
 
1429
 
 
1430
  return (Engine *)psEngine;
 
1431
}
 
1432
 
 
1433
PSEngine *GisPSEngine(Engine *engine)
 
1434
{
 
1435
  return (engine && engine->type==psType)? (PSEngine *)engine : 0;
 
1436
}
 
1437
 
 
1438
/* ------------------------------------------------------------------------ */