]> git.saurik.com Git - wxWidgets.git/blob - src/generic/dcpsg.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
1. new wxFFile class - as wxFile but uses fopen/fread/fseek... instead of
[wxWidgets.git] / src / generic / dcpsg.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: dcpsg.cpp
3 // Purpose: Generic wxPostScriptDC implementation
4 // Author: Julian Smart, Robert Roebling, Markus Holzhem
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation
14 #pragma interface
15 #endif
16
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #ifndef WX_PRECOMP
24 #include "wx/setup.h"
25 #include "wx/defs.h"
26 #endif // WX_PRECOMP
27
28 #if wxUSE_PRINTING_ARCHITECTURE
29
30 #if wxUSE_POSTSCRIPT
31
32 #include "wx/dcmemory.h"
33 #include "wx/utils.h"
34 #include "wx/intl.h"
35 #include "wx/filedlg.h"
36 #include "wx/app.h"
37 #include "wx/msgdlg.h"
38 #include "wx/image.h"
39 #include "wx/log.h"
40 #include "wx/generic/dcpsg.h"
41 #include "wx/generic/prntdlgg.h"
42 #include "wx/button.h"
43 #include "wx/stattext.h"
44 #include "wx/radiobox.h"
45 #include "wx/textctrl.h"
46 #include "wx/prntbase.h"
47 #include "wx/paper.h"
48
49 #include <math.h>
50
51 #ifdef __WXMSW__
52
53 #ifdef DrawText
54 #undef DrawText
55 #endif
56
57 #ifdef StartDoc
58 #undef StartDoc
59 #endif
60
61 #ifdef GetCharWidth
62 #undef GetCharWidth
63 #endif
64
65 #ifdef FindWindow
66 #undef FindWindow
67 #endif
68
69 #endif
70
71 //-----------------------------------------------------------------------------
72 // start and end of document/page
73 //-----------------------------------------------------------------------------
74
75 static const char *wxPostScriptHeaderEllipse = "\
76 /ellipsedict 8 dict def\n\
77 ellipsedict /mtrx matrix put\n\
78 /ellipse {\n\
79 ellipsedict begin\n\
80 /endangle exch def\n\
81 /startangle exch def\n\
82 /yrad exch def\n\
83 /xrad exch def\n\
84 /y exch def\n\
85 /x exch def\n\
86 /savematrix mtrx currentmatrix def\n\
87 x y translate\n\
88 xrad yrad scale\n\
89 0 0 1 startangle endangle arc\n\
90 savematrix setmatrix\n\
91 end\n\
92 } def\n\
93 ";
94
95 static const char *wxPostScriptHeaderEllipticArc= "\
96 /ellipticarcdict 8 dict def\n\
97 ellipticarcdict /mtrx matrix put\n\
98 /ellipticarc\n\
99 { ellipticarcdict begin\n\
100 /do_fill exch def\n\
101 /endangle exch def\n\
102 /startangle exch def\n\
103 /yrad exch def\n\
104 /xrad exch def \n\
105 /y exch def\n\
106 /x exch def\n\
107 /savematrix mtrx currentmatrix def\n\
108 x y translate\n\
109 xrad yrad scale\n\
110 do_fill { 0 0 moveto } if\n\
111 0 0 1 startangle endangle arc\n\
112 savematrix setmatrix\n\
113 do_fill { fill }{ stroke } ifelse\n\
114 end\n\
115 } def\n";
116
117 static const char *wxPostScriptHeaderSpline = "\
118 /DrawSplineSection {\n\
119 /y3 exch def\n\
120 /x3 exch def\n\
121 /y2 exch def\n\
122 /x2 exch def\n\
123 /y1 exch def\n\
124 /x1 exch def\n\
125 /xa x1 x2 x1 sub 0.666667 mul add def\n\
126 /ya y1 y2 y1 sub 0.666667 mul add def\n\
127 /xb x3 x2 x3 sub 0.666667 mul add def\n\
128 /yb y3 y2 y3 sub 0.666667 mul add def\n\
129 x1 y1 lineto\n\
130 xa ya xb yb x3 y3 curveto\n\
131 } def\n\
132 ";
133
134 static const char *wxPostScriptHeaderColourImage = "\
135 %% define 'colorimage' if it isn't defined\n\
136 %% ('colortogray' and 'mergeprocs' come from xwd2ps\n\
137 %% via xgrab)\n\
138 /colorimage where %% do we know about 'colorimage'?\n\
139 { pop } %% yes: pop off the 'dict' returned\n\
140 { %% no: define one\n\
141 /colortogray { %% define an RGB->I function\n\
142 /rgbdata exch store %% call input 'rgbdata'\n\
143 rgbdata length 3 idiv\n\
144 /npixls exch store\n\
145 /rgbindx 0 store\n\
146 0 1 npixls 1 sub {\n\
147 grays exch\n\
148 rgbdata rgbindx get 20 mul %% Red\n\
149 rgbdata rgbindx 1 add get 32 mul %% Green\n\
150 rgbdata rgbindx 2 add get 12 mul %% Blue\n\
151 add add 64 idiv %% I = .5G + .31R + .18B\n\
152 put\n\
153 /rgbindx rgbindx 3 add store\n\
154 } for\n\
155 grays 0 npixls getinterval\n\
156 } bind def\n\
157 \n\
158 %% Utility procedure for colorimage operator.\n\
159 %% This procedure takes two procedures off the\n\
160 %% stack and merges them into a single procedure.\n\
161 \n\
162 /mergeprocs { %% def\n\
163 dup length\n\
164 3 -1 roll\n\
165 dup\n\
166 length\n\
167 dup\n\
168 5 1 roll\n\
169 3 -1 roll\n\
170 add\n\
171 array cvx\n\
172 dup\n\
173 3 -1 roll\n\
174 0 exch\n\
175 putinterval\n\
176 dup\n\
177 4 2 roll\n\
178 putinterval\n\
179 } bind def\n\
180 \n\
181 /colorimage { %% def\n\
182 pop pop %% remove 'false 3' operands\n\
183 {colortogray} mergeprocs\n\
184 image\n\
185 } bind def\n\
186 } ifelse %% end of 'false' case\n\
187 ";
188
189 static char wxPostScriptHeaderReencodeISO1[] =
190 "\n/reencodeISO {\n"
191 "dup dup findfont dup length dict begin\n"
192 "{ 1 index /FID ne { def }{ pop pop } ifelse } forall\n"
193 "/Encoding ISOLatin1Encoding def\n"
194 "currentdict end definefont\n"
195 "} def\n"
196 "/ISOLatin1Encoding [\n"
197 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
198 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
199 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
200 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
201 "/space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quoteright\n"
202 "/parenleft/parenright/asterisk/plus/comma/minus/period/slash\n"
203 "/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon\n"
204 "/less/equal/greater/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N\n"
205 "/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backslash/bracketright\n"
206 "/asciicircum/underscore/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m\n"
207 "/n/o/p/q/r/s/t/u/v/w/x/y/z/braceleft/bar/braceright/asciitilde\n"
208 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
209 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
210 "/.notdef/dotlessi/grave/acute/circumflex/tilde/macron/breve\n"
211 "/dotaccent/dieresis/.notdef/ring/cedilla/.notdef/hungarumlaut\n";
212
213 static char wxPostScriptHeaderReencodeISO2[] =
214 "/ogonek/caron/space/exclamdown/cent/sterling/currency/yen/brokenbar\n"
215 "/section/dieresis/copyright/ordfeminine/guillemotleft/logicalnot\n"
216 "/hyphen/registered/macron/degree/plusminus/twosuperior/threesuperior\n"
217 "/acute/mu/paragraph/periodcentered/cedilla/onesuperior/ordmasculine\n"
218 "/guillemotright/onequarter/onehalf/threequarters/questiondown\n"
219 "/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla\n"
220 "/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex\n"
221 "/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis\n"
222 "/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute\n"
223 "/Thorn/germandbls/agrave/aacute/acircumflex/atilde/adieresis\n"
224 "/aring/ae/ccedilla/egrave/eacute/ecircumflex/edieresis/igrave\n"
225 "/iacute/icircumflex/idieresis/eth/ntilde/ograve/oacute/ocircumflex\n"
226 "/otilde/odieresis/divide/oslash/ugrave/uacute/ucircumflex/udieresis\n"
227 "/yacute/thorn/ydieresis\n"
228 "] def\n\n";
229
230 //-------------------------------------------------------------------------------
231 // wxPostScriptDC
232 //-------------------------------------------------------------------------------
233
234 wxPostScriptDC::wxPostScriptDC ()
235 {
236 m_pstream = (FILE*) NULL;
237
238 m_currentRed = 0;
239 m_currentGreen = 0;
240 m_currentBlue = 0;
241
242 m_pageNumber = 0;
243
244 m_clipping = FALSE;
245
246 m_underlinePosition = 0.0;
247 m_underlineThickness = 0.0;
248
249 m_signX = 1; // default x-axis left to right
250 m_signY = -1; // default y-axis bottom up -> top down
251
252 // Compatibility only
253 m_printData = * wxThePrintSetupData;
254 }
255
256 wxPostScriptDC::wxPostScriptDC (const wxString& file, bool interactive, wxWindow *parent)
257 {
258 m_pstream = (FILE*) NULL;
259
260 m_currentRed = 0;
261 m_currentGreen = 0;
262 m_currentBlue = 0;
263
264 m_pageNumber = 0;
265
266 m_clipping = FALSE;
267
268 m_underlinePosition = 0.0;
269 m_underlineThickness = 0.0;
270
271 m_signX = 1; // default x-axis left to right
272 m_signY = -1; // default y-axis bottom up -> top down
273
274 Create(file, interactive, parent);
275 }
276
277 bool wxPostScriptDC::Create(const wxString& file, bool interactive, wxWindow *parent)
278 {
279 m_isInteractive = interactive;
280
281 m_title = "";
282 m_printData.SetFilename(file);
283
284 #ifdef __WXMSW__
285 // Can only send to file in Windows
286 m_printData.SetPrintMode(wxPRINT_MODE_FILE);
287 #endif
288
289 if (m_isInteractive)
290 {
291 if ((m_ok = PrinterDialog (parent) ) == FALSE) return FALSE;
292 }
293 else
294 {
295 m_ok = TRUE;
296 }
297
298 return m_ok;
299 }
300
301 wxPostScriptDC::wxPostScriptDC (const wxPrintData& printData)
302 {
303 m_pstream = (FILE*) NULL;
304
305 m_currentRed = 0;
306 m_currentGreen = 0;
307 m_currentBlue = 0;
308
309 m_pageNumber = 0;
310
311 m_clipping = FALSE;
312
313 m_underlinePosition = 0.0;
314 m_underlineThickness = 0.0;
315
316 m_signX = 1; // default x-axis left to right
317 m_signY = -1; // default y-axis bottom up -> top down
318
319 m_printData = printData;
320
321 m_ok = TRUE;
322 }
323
324 wxPostScriptDC::~wxPostScriptDC ()
325 {
326 if (m_pstream)
327 {
328 fclose( m_pstream );
329 m_pstream = (FILE*) NULL;
330 }
331 }
332
333 bool wxPostScriptDC::Ok() const
334 {
335 return m_ok;
336 }
337
338 // This dialog is deprecated now: use wxGenericPrintDialog or the printing framework
339 bool wxPostScriptDC::PrinterDialog(wxWindow *parent)
340 {
341 wxPostScriptPrintDialog dialog( parent, _("Printer Settings"), wxPoint(150, 150), wxSize(400, 400),
342 wxDEFAULT_DIALOG_STYLE | wxDIALOG_MODAL );
343 m_ok = (dialog.ShowModal () == wxID_OK);
344
345 if (!m_ok) return FALSE;
346
347 if ((m_printData.GetFilename() == "") &&
348 (m_printData.GetPrintMode() == wxPRINT_MODE_PREVIEW ||
349 m_printData.GetPrintMode() == wxPRINT_MODE_PRINTER))
350 {
351 // steve, 05.09.94
352 #ifdef __VMS__
353 m_printData.SetFilename("preview");
354 #else
355 // For PS_PRINTER action this depends on a Unix-style print spooler
356 // since the wx_printer_file can be destroyed during a session
357 // @@@ TODO: a Windows-style answer for non-Unix
358 wxChar userId[256];
359 wxGetUserId (userId, sizeof (userId) / sizeof (char));
360 wxChar tmp[256];
361 wxStrcpy (tmp, _T("/tmp/preview_"));
362 wxStrcat (tmp, userId);
363 m_printData.SetFilename(tmp);
364 #endif
365 wxChar tmp2[256];
366 wxStrcpy(tmp2, m_printData.GetFilename());
367 wxStrcat (tmp2, _T(".ps"));
368 m_printData.SetFilename(tmp2);
369 }
370 else if ((m_printData.GetFilename() == _T("")) && (m_printData.GetPrintMode() == wxPRINT_MODE_FILE))
371 {
372 wxString file = wxSaveFileSelector (_("PostScript"), _T("ps"));
373 if ( file.IsEmpty() )
374 {
375 m_ok = FALSE;
376 return FALSE;
377 }
378
379 m_printData.SetFilename(file);
380 m_ok = TRUE;
381 }
382
383 return m_ok;
384 }
385
386 void wxPostScriptDC::SetClippingRegion (long x, long y, long w, long h)
387 {
388 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
389
390 if (m_clipping) return;
391
392 wxDC::SetClippingRegion( x, y, w, h );
393
394 m_clipping = TRUE;
395 fprintf( m_pstream,
396 "gsave\n newpath\n"
397 "%ld %ld moveto\n"
398 "%ld %ld lineto\n"
399 "%ld %ld lineto\n"
400 "%ld %ld lineto\n"
401 "closepath clip newpath\n",
402 XLOG2DEV(x), YLOG2DEV(y),
403 XLOG2DEV(x+w), YLOG2DEV(y),
404 XLOG2DEV(x+w), YLOG2DEV(y+h),
405 XLOG2DEV(x), YLOG2DEV(y+h) );
406 }
407
408 void wxPostScriptDC::SetClippingRegion( const wxRegion &WXUNUSED(region) )
409 {
410 wxFAIL_MSG( _T("wxPostScriptDC::SetClippingRegion not implemented.") );
411 }
412
413 void wxPostScriptDC::DestroyClippingRegion()
414 {
415 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
416
417 wxDC::DestroyClippingRegion();
418
419 if (m_clipping)
420 {
421 m_clipping = FALSE;
422 fprintf( m_pstream, "grestore\n" );
423 }
424 }
425
426 void wxPostScriptDC::Clear()
427 {
428 wxFAIL_MSG( _T("wxPostScriptDC::Clear not implemented.") );
429 }
430
431 void wxPostScriptDC::DoFloodFill (long WXUNUSED(x), long WXUNUSED(y), const wxColour &WXUNUSED(col), int WXUNUSED(style))
432 {
433 wxFAIL_MSG( _T("wxPostScriptDC::FloodFill not implemented.") );
434 }
435
436 bool wxPostScriptDC::DoGetPixel (long WXUNUSED(x), long WXUNUSED(y), wxColour * WXUNUSED(col)) const
437 {
438 wxFAIL_MSG( _T("wxPostScriptDC::GetPixel not implemented.") );
439 return FALSE;
440 }
441
442 void wxPostScriptDC::DoCrossHair (long WXUNUSED(x), long WXUNUSED(y))
443 {
444 wxFAIL_MSG( _T("wxPostScriptDC::CrossHair not implemented.") );
445 }
446
447 void wxPostScriptDC::DoDrawLine (long x1, long y1, long x2, long y2)
448 {
449 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
450
451 if (m_pen.GetStyle() == wxTRANSPARENT) return;
452
453 SetPen( m_pen );
454
455 fprintf( m_pstream,
456 "newpath\n"
457 "%ld %ld moveto\n"
458 "%ld %ld lineto\n"
459 "stroke\n",
460 XLOG2DEV(x1), YLOG2DEV(y1),
461 XLOG2DEV(x2), YLOG2DEV (y2) );
462
463 CalcBoundingBox( x1, y1 );
464 CalcBoundingBox( x2, y2 );
465 }
466
467 #define RAD2DEG 57.29577951308
468
469 void wxPostScriptDC::DoDrawArc (long x1, long y1, long x2, long y2, long xc, long yc)
470 {
471 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
472
473 long dx = x1 - xc;
474 long dy = y1 - yc;
475 long radius = (long) sqrt(dx*dx+dy*dy);
476 double alpha1, alpha2;
477
478 if (x1 == x2 && y1 == y2)
479 {
480 alpha1 = 0.0;
481 alpha2 = 360.0;
482 }
483 else if (radius == 0.0)
484 {
485 alpha1 = alpha2 = 0.0;
486 }
487 else
488 {
489 alpha1 = (x1 - xc == 0) ?
490 (y1 - yc < 0) ? 90.0 : -90.0 :
491 -atan2(double(y1-yc), double(x1-xc)) * RAD2DEG;
492 alpha2 = (x2 - xc == 0) ?
493 (y2 - yc < 0) ? 90.0 : -90.0 :
494 -atan2(double(y2-yc), double(x2-xc)) * RAD2DEG;
495 }
496 while (alpha1 <= 0) alpha1 += 360;
497 while (alpha2 <= 0) alpha2 += 360; // adjust angles to be between
498 while (alpha1 > 360) alpha1 -= 360; // 0 and 360 degree
499 while (alpha2 > 360) alpha2 -= 360;
500
501 if (m_brush.GetStyle() != wxTRANSPARENT)
502 {
503 SetBrush( m_brush );
504
505 fprintf( m_pstream,
506 "newpath\n"
507 "%ld %ld %ld %ld %ld %ld ellipse\n"
508 "%ld %ld lineto\n"
509 "closepath\n"
510 "fill\n",
511 XLOG2DEV(xc), YLOG2DEV(yc), XLOG2DEVREL(radius), YLOG2DEVREL(radius), (long)alpha1, (long) alpha2,
512 XLOG2DEV(xc), YLOG2DEV(yc) );
513
514 CalcBoundingBox( xc-radius, yc-radius );
515 CalcBoundingBox( xc+radius, yc+radius );
516 }
517
518 if (m_pen.GetStyle() != wxTRANSPARENT)
519 {
520 SetPen( m_pen );
521
522 fprintf( m_pstream,
523 "newpath\n"
524 "%ld %ld %ld %ld %ld %ld ellipse\n"
525 "%ld %ld lineto\n"
526 "stroke\n"
527 "fill\n",
528 XLOG2DEV(xc), YLOG2DEV(yc), XLOG2DEVREL(radius), YLOG2DEVREL(radius), (long)alpha1, (long) alpha2,
529 XLOG2DEV(xc), YLOG2DEV(yc) );
530
531 CalcBoundingBox( xc-radius, yc-radius );
532 CalcBoundingBox( xc+radius, yc+radius );
533 }
534 }
535
536 void wxPostScriptDC::DoDrawEllipticArc(long x,long y,long w,long h,double sa,double ea)
537 {
538 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
539
540 if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
541 if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
542 if (sa<0) sa+=360;
543 if (ea<0) ea+=360;
544
545 if (sa==ea)
546 {
547 DrawEllipse(x,y,w,h);
548 return;
549 }
550
551 if (m_brush.GetStyle () != wxTRANSPARENT)
552 {
553 SetBrush( m_brush );
554
555 fprintf( m_pstream,
556 "newpath\n"
557 "%ld %ld %ld %ld %ld %ld true ellipticarc\n",
558 XLOG2DEV(x+w/2), YLOG2DEV(y+h/2), XLOG2DEVREL(w/2), YLOG2DEVREL(h/2), (long)sa, (long)ea );
559
560 CalcBoundingBox( x ,y );
561 CalcBoundingBox( x+w, y+h );
562 }
563
564 if (m_pen.GetStyle () != wxTRANSPARENT)
565 {
566 SetPen( m_pen );
567
568 fprintf( m_pstream,
569 "newpath\n"
570 "%ld %ld %ld %ld %ld %ld false ellipticarc\n",
571 XLOG2DEV(x+w/2), YLOG2DEV(y+h/2), XLOG2DEVREL(w/2), YLOG2DEVREL(h/2), (long)sa, (long)ea );
572
573 CalcBoundingBox( x ,y );
574 CalcBoundingBox( x+w, y+h );
575 }
576 }
577
578 void wxPostScriptDC::DoDrawPoint (long x, long y)
579 {
580 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
581
582 if (m_pen.GetStyle() == wxTRANSPARENT) return;
583
584 SetPen (m_pen);
585
586 fprintf( m_pstream,
587 "newpath\n"
588 "%ld %ld moveto\n"
589 "%ld %ld lineto\n"
590 "stroke\n",
591 XLOG2DEV(x), YLOG2DEV(y),
592 XLOG2DEV(x+1), YLOG2DEV(y) );
593
594 CalcBoundingBox( x, y );
595 }
596
597 void wxPostScriptDC::DoDrawPolygon (int n, wxPoint points[], long xoffset, long yoffset, int WXUNUSED(fillStyle))
598 {
599 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
600
601 if (n <= 0) return;
602
603 if (m_brush.GetStyle () != wxTRANSPARENT)
604 {
605 SetBrush( m_brush );
606
607 fprintf( m_pstream, "newpath\n" );
608
609 long xx = XLOG2DEV(points[0].x + xoffset);
610 long yy = YLOG2DEV(points[0].y + yoffset);
611
612 fprintf( m_pstream, "%ld %ld moveto\n", xx, yy );
613
614 CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
615
616 for (int i = 1; i < n; i++)
617 {
618 xx = XLOG2DEV(points[i].x + xoffset);
619 yy = YLOG2DEV(points[i].y + yoffset);
620
621 fprintf( m_pstream, "%ld %ld lineto\n", xx, yy );
622
623 CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset);
624 }
625
626 fprintf( m_pstream, "fill\n" );
627 }
628
629 if (m_pen.GetStyle () != wxTRANSPARENT)
630 {
631 SetPen( m_pen );
632
633 fprintf( m_pstream, "newpath\n" );
634
635 long xx = XLOG2DEV(points[0].x + xoffset);
636 long yy = YLOG2DEV(points[0].y + yoffset);
637
638 fprintf( m_pstream, "%ld %ld moveto\n", xx, yy );
639
640 CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
641
642 for (int i = 1; i < n; i++)
643 {
644 xx = XLOG2DEV(points[i].x + xoffset);
645 yy = YLOG2DEV(points[i].y + yoffset);
646
647 fprintf( m_pstream, "%ld %ld lineto\n", xx, yy );
648
649 CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset);
650 }
651
652 fprintf( m_pstream, "fill\n" );
653 }
654 }
655
656 void wxPostScriptDC::DoDrawLines (int n, wxPoint points[], long xoffset, long yoffset)
657 {
658 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
659
660 if (m_pen.GetStyle() == wxTRANSPARENT) return;
661
662 if (n <= 0) return;
663
664 SetPen (m_pen);
665
666 int i;
667 for ( i =0; i<n ; i++ )
668 {
669 CalcBoundingBox( XLOG2DEV(points[i].x+xoffset), YLOG2DEV(points[i].y+yoffset));
670 }
671
672 fprintf( m_pstream,
673 "newpath\n"
674 "%ld %ld moveto\n",
675 XLOG2DEV(points[0].x+xoffset), YLOG2DEV(points[0].y+yoffset) );
676
677 for (i = 1; i < n; i++)
678 {
679 fprintf( m_pstream,
680 "%ld %ld lineto\n",
681 XLOG2DEV(points[i].x+xoffset), YLOG2DEV(points[i].y+yoffset) );
682 }
683
684 fprintf( m_pstream, "stroke\n" );
685 }
686
687 void wxPostScriptDC::DoDrawRectangle (long x, long y, long width, long height)
688 {
689 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
690
691 if (m_brush.GetStyle () != wxTRANSPARENT)
692 {
693 SetBrush( m_brush );
694
695 fprintf( m_pstream,
696 "newpath\n"
697 "%ld %ld moveto\n"
698 "%ld %ld lineto\n"
699 "%ld %ld lineto\n"
700 "%ld %ld lineto\n"
701 "closepath\n"
702 "fill\n",
703 XLOG2DEV(x), YLOG2DEV(y),
704 XLOG2DEV(x + width), YLOG2DEV(y),
705 XLOG2DEV(x + width), YLOG2DEV(y + height),
706 XLOG2DEV(x), YLOG2DEV(y + height) );
707
708 CalcBoundingBox( x, y );
709 CalcBoundingBox( x + width, y + height );
710 }
711
712 if (m_pen.GetStyle () != wxTRANSPARENT)
713 {
714 SetPen (m_pen);
715
716 fprintf( m_pstream,
717 "newpath\n"
718 "%ld %ld moveto\n"
719 "%ld %ld lineto\n"
720 "%ld %ld lineto\n"
721 "%ld %ld lineto\n"
722 "closepath\n"
723 "stroke\n",
724 XLOG2DEV(x), YLOG2DEV(y),
725 XLOG2DEV(x + width), YLOG2DEV(y),
726 XLOG2DEV(x + width), YLOG2DEV(y + height),
727 XLOG2DEV(x), YLOG2DEV(y + height) );
728
729 CalcBoundingBox( x, y );
730 CalcBoundingBox( x + width, y + height );
731 }
732 }
733
734 void wxPostScriptDC::DoDrawRoundedRectangle (long x, long y, long width, long height, double radius)
735 {
736 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
737
738 if (radius < 0.0)
739 {
740 // Now, a negative radius is interpreted to mean
741 // 'the proportion of the smallest X or Y dimension'
742 double smallest = 0.0;
743 if (width < height)
744 smallest = width;
745 else
746 smallest = height;
747 radius = (-radius * smallest);
748 }
749
750 long rad = (long) radius;
751
752 if (m_brush.GetStyle () != wxTRANSPARENT)
753 {
754 SetBrush( m_brush );
755
756 /* Draw rectangle anticlockwise */
757 fprintf( m_pstream,
758 "newpath\n"
759 "%ld %ld %ld 90 180 arc\n"
760 "%ld %ld moveto\n"
761 "%ld %ld %ld 180 270 arc\n"
762 "%ld %ld lineto\n"
763 "%ld %ld %ld 270 0 arc\n"
764 "%ld %ld lineto\n"
765 "%ld %ld %ld 0 90 arc\n"
766 "%ld %ld lineto\n"
767 "closepath\n"
768 "fill\n",
769 XLOG2DEV(x + rad), YLOG2DEV(y + rad), XLOG2DEVREL(rad),
770 XLOG2DEV(x), YLOG2DEV(y + rad),
771 XLOG2DEV(x + rad), YLOG2DEV(y + height - rad), XLOG2DEVREL(rad),
772 XLOG2DEV(x + width - rad), YLOG2DEV(y + height),
773 XLOG2DEV(x + width - rad), YLOG2DEV(y + height - rad), XLOG2DEVREL(rad),
774 XLOG2DEV(x + width), YLOG2DEV(y + rad),
775 XLOG2DEV(x + width - rad), YLOG2DEV(y + rad), XLOG2DEVREL(rad),
776 XLOG2DEV(x + rad), YLOG2DEV(y) );
777
778 CalcBoundingBox( x, y );
779 CalcBoundingBox( x + width, y + height );
780 }
781
782 if (m_pen.GetStyle () != wxTRANSPARENT)
783 {
784 SetPen (m_pen);
785
786 /* Draw rectangle anticlockwise */
787 fprintf( m_pstream,
788 "newpath\n"
789 "%ld %ld %ld 90 180 arc\n"
790 "%ld %ld moveto\n"
791 "%ld %ld %ld 180 270 arc\n"
792 "%ld %ld lineto\n"
793 "%ld %ld %ld 270 0 arc\n"
794 "%ld %ld lineto\n"
795 "%ld %ld %ld 0 90 arc\n"
796 "%ld %ld lineto\n"
797 "closepath\n"
798 "stroke\n",
799 XLOG2DEV(x + rad), YLOG2DEV(y + rad), XLOG2DEVREL(rad),
800 XLOG2DEV(x), YLOG2DEV(y + rad),
801 XLOG2DEV(x + rad), YLOG2DEV(y + height - rad), XLOG2DEVREL(rad),
802 XLOG2DEV(x + width - rad), YLOG2DEV(y + height),
803 XLOG2DEV(x + width - rad), YLOG2DEV(y + height - rad), XLOG2DEVREL(rad),
804 XLOG2DEV(x + width), YLOG2DEV(y + rad),
805 XLOG2DEV(x + width - rad), YLOG2DEV(y + rad), XLOG2DEVREL(rad),
806 XLOG2DEV(x + rad), YLOG2DEV(y) );
807
808 CalcBoundingBox( x, y );
809 CalcBoundingBox( x + width, y + height );
810 }
811 }
812
813 void wxPostScriptDC::DoDrawEllipse (long x, long y, long width, long height)
814 {
815 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
816
817 if (m_brush.GetStyle () != wxTRANSPARENT)
818 {
819 SetBrush (m_brush);
820
821 fprintf( m_pstream,
822 "newpath\n"
823 "%ld %ld %ld %ld 0 360 ellipse\n"
824 "fill\n",
825 XLOG2DEV(x + width / 2), YLOG2DEV(y + height / 2),
826 XLOG2DEV(width / 2), YLOG2DEVREL(height / 2) );
827
828 CalcBoundingBox( x - width, y - height );
829 CalcBoundingBox( x + width, y + height );
830 }
831
832 if (m_pen.GetStyle () != wxTRANSPARENT)
833 {
834 SetPen (m_pen);
835
836 fprintf( m_pstream,
837 "newpath\n"
838 "%ld %ld %ld %ld 0 360 ellipse\n"
839 "stroke\n",
840 XLOG2DEV(x + width / 2), YLOG2DEV(y + height / 2),
841 XLOG2DEV(width / 2), YLOG2DEVREL(height / 2) );
842
843 CalcBoundingBox( x - width, y - height );
844 CalcBoundingBox( x + width, y + height );
845 }
846 }
847
848 void wxPostScriptDC::DoDrawIcon( const wxIcon& icon, long x, long y )
849 {
850 DrawBitmap( icon, x, y, TRUE );
851 }
852
853 /* this has to be char, not wxChar */
854 static char hexArray[] = "0123456789ABCDEF";
855 static void LocalDecToHex( int dec, char *buf )
856 {
857 int firstDigit = (int)(dec/16.0);
858 int secondDigit = (int)(dec - (firstDigit*16.0));
859 buf[0] = hexArray[firstDigit];
860 buf[1] = hexArray[secondDigit];
861 buf[2] = 0;
862 }
863
864 void wxPostScriptDC::DoDrawBitmap( const wxBitmap& bitmap, long x, long y, bool WXUNUSED(useMask) )
865 {
866 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
867
868 if (!bitmap.Ok()) return;
869
870 wxImage image( bitmap );
871
872 if (!image.Ok()) return;
873
874 long ww = XLOG2DEVREL(image.GetWidth());
875 long hh = YLOG2DEVREL(image.GetHeight());
876
877 image = image.Scale( ww, hh );
878
879 if (!image.Ok()) return;
880
881 long xx = XLOG2DEV(x);
882 long yy = YLOG2DEV(y + bitmap.GetHeight());
883
884 fprintf( m_pstream,
885 "/origstate save def\n"
886 "20 dict begin\n"
887 "/pix %ld string def\n"
888 "/grays %ld string def\n"
889 "/npixels 0 def\n"
890 "/rgbindx 0 def\n"
891 "%ld %ld translate\n"
892 "%ld %ld scale\n"
893 "%ld %ld 8\n"
894 "[%ld 0 0 %ld 0 %ld]\n"
895 "{currentfile pix readhexstring pop}\n"
896 "false 3 colorimage\n",
897 ww, ww, xx, yy, ww, hh, ww, hh, ww, -hh, hh );
898
899 for (int j = 0; j < hh; j++)
900 {
901 for (int i = 0; i < ww; i++)
902 {
903 char buffer[5];
904 LocalDecToHex( image.GetRed(i,j), buffer );
905 fprintf( m_pstream, buffer );
906 LocalDecToHex( image.GetGreen(i,j), buffer );
907 fprintf( m_pstream, buffer );
908 LocalDecToHex( image.GetBlue(i,j), buffer );
909 fprintf( m_pstream, buffer );
910 }
911 fprintf( m_pstream, "\n" );
912 }
913
914 fprintf( m_pstream, "end\n" );
915 fprintf( m_pstream, "origstate restore\n" );
916 }
917
918 void wxPostScriptDC::SetFont( const wxFont& font )
919 {
920 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
921
922 if (!font.Ok()) return;
923
924 m_font = font;
925
926 const char *name;
927 const char *style = "";
928 int Style = m_font.GetStyle();
929 int Weight = m_font.GetWeight();
930
931 switch (m_font.GetFamily())
932 {
933 case wxTELETYPE:
934 case wxMODERN:
935 name = "/Courier";
936 break;
937 case wxSWISS:
938 name = "/Helvetica";
939 break;
940 case wxROMAN:
941 // name = "/Times-Roman";
942 name = "/Times"; // Altered by EDZ
943 break;
944 case wxSCRIPT:
945 name = "/Zapf-Chancery-MediumItalic";
946 Style = wxNORMAL;
947 Weight = wxNORMAL;
948 break;
949 default:
950 case wxDEFAULT: // Sans Serif Font
951 name = "/LucidaSans";
952 }
953
954 if (Style == wxNORMAL && (Weight == wxNORMAL || Weight == wxLIGHT))
955 {
956 if (m_font.GetFamily () == wxROMAN)
957 style = "-Roman";
958 else
959 style = "";
960 }
961 else if (Style == wxNORMAL && Weight == wxBOLD)
962 {
963 style = "-Bold";
964 }
965 else if (Style == wxITALIC && (Weight == wxNORMAL || Weight == wxLIGHT))
966 {
967 if (m_font.GetFamily () == wxROMAN)
968 style = "-Italic";
969 else
970 style = "-Oblique";
971 }
972 else if (Style == wxITALIC && Weight == wxBOLD)
973 {
974 if (m_font.GetFamily () == wxROMAN)
975 style = "-BoldItalic";
976 else
977 style = "-BoldOblique";
978 }
979 else if (Style == wxSLANT && (Weight == wxNORMAL || Weight == wxLIGHT))
980 {
981 if (m_font.GetFamily () == wxROMAN)
982 style = "-Italic";
983 else
984 style = "-Oblique";
985 }
986 else if (Style == wxSLANT && Weight == wxBOLD)
987 {
988 if (m_font.GetFamily () == wxROMAN)
989 style = "-BoldItalic";
990 else
991 style = "-BoldOblique";
992 }
993 else
994 {
995 style = "";
996 }
997
998 char buffer[100];
999 strcpy( buffer, name );
1000 strcat( buffer, style );
1001
1002 fprintf( m_pstream, buffer );
1003 fprintf( m_pstream, " reencodeISO def\n" );
1004 fprintf( m_pstream, buffer );
1005 fprintf( m_pstream, " findfont\n" );
1006 fprintf( m_pstream, "%ld scalefont setfont\n", YLOG2DEVREL(m_font.GetPointSize()) );
1007 }
1008
1009 void wxPostScriptDC::SetPen( const wxPen& pen )
1010 {
1011 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
1012
1013 if (!pen.Ok()) return;
1014
1015 int oldStyle = m_pen.GetStyle();
1016
1017 m_pen = pen;
1018
1019 fprintf( m_pstream, "%ld setlinewidth\n", XLOG2DEVREL(m_pen.GetWidth()) );
1020
1021 /*
1022 Line style - WRONG: 2nd arg is OFFSET
1023
1024 Here, I'm afraid you do not conceive meaning of parameters of 'setdash'
1025 operator correctly. You should look-up this in the Red Book: the 2nd parame-
1026 ter is not number of values in the array of the first one, but an offset
1027 into this description of the pattern. I mean a real *offset* not index
1028 into array. I.e. If the command is [3 4] 1 setdash is used, then there
1029 will be first black line *2* units long, then space 4 units, then the
1030 pattern of *3* units black, 4 units space will be repeated.
1031 */
1032
1033 static const char *dotted = "[2 5] 2";
1034 static const char *short_dashed = "[4 4] 2";
1035 static const char *long_dashed = "[4 8] 2";
1036 static const char *dotted_dashed = "[6 6 2 6] 4";
1037
1038 const char *psdash = (char *) NULL;
1039 switch (m_pen.GetStyle())
1040 {
1041 case wxDOT: psdash = dotted; break;
1042 case wxSHORT_DASH: psdash = short_dashed; break;
1043 case wxLONG_DASH: psdash = long_dashed; break;
1044 case wxDOT_DASH: psdash = dotted_dashed; break;
1045 case wxSOLID:
1046 case wxTRANSPARENT:
1047 default: psdash = "[] 0"; break;
1048 }
1049
1050 if (oldStyle != m_pen.GetStyle())
1051 {
1052 fprintf( m_pstream, psdash );
1053 fprintf( m_pstream," setdash\n" );
1054 }
1055
1056 // Line colour
1057 unsigned char red = m_pen.GetColour().Red();
1058 unsigned char blue = m_pen.GetColour().Blue();
1059 unsigned char green = m_pen.GetColour().Green();
1060
1061 if (!m_colour)
1062 {
1063 // Anything not white is black
1064 if (! (red == (unsigned char) 255 &&
1065 blue == (unsigned char) 255 &&
1066 green == (unsigned char) 255) )
1067 {
1068 red = (unsigned char) 0;
1069 green = (unsigned char) 0;
1070 blue = (unsigned char) 0;
1071 }
1072 // setgray here ?
1073 }
1074
1075 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1076 {
1077 double redPS = (double)(red) / 255.0;
1078 double bluePS = (double)(blue) / 255.0;
1079 double greenPS = (double)(green) / 255.0;
1080
1081 fprintf( m_pstream,
1082 "%.8f %.8f %.8f setrgbcolor\n",
1083 redPS, greenPS, bluePS );
1084
1085 m_currentRed = red;
1086 m_currentBlue = blue;
1087 m_currentGreen = green;
1088 }
1089 }
1090
1091 void wxPostScriptDC::SetBrush( const wxBrush& brush )
1092 {
1093 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
1094
1095 if (!brush.Ok()) return;
1096
1097 m_brush = brush;
1098
1099 // Brush colour
1100 unsigned char red = m_brush.GetColour().Red();
1101 unsigned char blue = m_brush.GetColour().Blue();
1102 unsigned char green = m_brush.GetColour().Green();
1103
1104 if (!m_colour)
1105 {
1106 // Anything not white is black
1107 if (! (red == (unsigned char) 255 &&
1108 blue == (unsigned char) 255 &&
1109 green == (unsigned char) 255) )
1110 {
1111 red = (unsigned char) 0;
1112 green = (unsigned char) 0;
1113 blue = (unsigned char) 0;
1114 }
1115 // setgray here ?
1116 }
1117
1118 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1119 {
1120 double redPS = (double)(red) / 255.0;
1121 double bluePS = (double)(blue) / 255.0;
1122 double greenPS = (double)(green) / 255.0;
1123
1124 fprintf( m_pstream,
1125 "%.8f %.8f %.8f setrgbcolor\n",
1126 redPS, greenPS, bluePS );
1127
1128 m_currentRed = red;
1129 m_currentBlue = blue;
1130 m_currentGreen = green;
1131 }
1132 }
1133
1134 void wxPostScriptDC::DoDrawText( const wxString& text, long x, long y )
1135 {
1136 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
1137
1138 SetFont( m_font );
1139
1140 if (m_textForegroundColour.Ok())
1141 {
1142 unsigned char red = m_textForegroundColour.Red();
1143 unsigned char blue = m_textForegroundColour.Blue();
1144 unsigned char green = m_textForegroundColour.Green();
1145
1146 if (!m_colour)
1147 {
1148 // Anything not white is black
1149 if (! (red == (unsigned char) 255 &&
1150 blue == (unsigned char) 255 &&
1151 green == (unsigned char) 255))
1152 {
1153 red = (unsigned char) 0;
1154 green = (unsigned char) 0;
1155 blue = (unsigned char) 0;
1156 }
1157 }
1158
1159 // maybe setgray here ?
1160 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1161 {
1162 double redPS = (double)(red) / 255.0;
1163 double bluePS = (double)(blue) / 255.0;
1164 double greenPS = (double)(green) / 255.0;
1165
1166 fprintf( m_pstream,
1167 "%.8f %.8f %.8f setrgbcolor\n",
1168 redPS, greenPS, bluePS );
1169
1170 m_currentRed = red;
1171 m_currentBlue = blue;
1172 m_currentGreen = green;
1173 }
1174 }
1175
1176 int size = m_font.GetPointSize();
1177
1178 long by = y + (long)floor( double(size) * 2.0 / 3.0 ); // approximate baseline
1179 fprintf( m_pstream, "%ld %ld moveto\n", XLOG2DEV(x), YLOG2DEV(by) );
1180
1181 /* I don't know how to write char to a stream, so I use a mini string */
1182 char tmpbuf[2];
1183 tmpbuf[1] = 0;
1184
1185 fprintf( m_pstream, "(" );
1186 const wxWX2MBbuf textbuf = text.mb_str();
1187 int len = strlen(textbuf);
1188 int i;
1189 for (i = 0; i < len; i++)
1190 {
1191 int c = (unsigned char) textbuf[i];
1192 if (c == ')' || c == '(' || c == '\\')
1193 {
1194 /* Cope with special characters */
1195 fprintf( m_pstream, "\\" );
1196 tmpbuf[0] = (char) c;
1197 fprintf( m_pstream, tmpbuf );
1198 }
1199 else if ( c >= 128 )
1200 {
1201 /* Cope with character codes > 127 */
1202 fprintf(m_pstream, "\\%o", c);
1203 }
1204 else
1205 {
1206 tmpbuf[0] = (char) c;
1207 fprintf( m_pstream, tmpbuf );
1208 }
1209 }
1210
1211 fprintf( m_pstream, ") show\n" );
1212
1213 if (m_font.GetUnderlined())
1214 {
1215 long uy = (long)(y + size - m_underlinePosition);
1216 long w, h;
1217 GetTextExtent(text, &w, &h);
1218
1219 fprintf( m_pstream,
1220 "gsave\n"
1221 "%ld %ld moveto\n"
1222 "%ld setlinewidth\n"
1223 "%ld %ld lineto\n"
1224 "stroke\n"
1225 "grestore\n",
1226 XLOG2DEV(x), YLOG2DEV(uy),
1227 (long)m_underlineThickness,
1228 XLOG2DEV(x + w), YLOG2DEV(uy) );
1229 }
1230
1231 CalcBoundingBox( x, y );
1232 CalcBoundingBox( x + size * text.Length() * 2/3 , y );
1233 }
1234
1235
1236 void wxPostScriptDC::SetBackground (const wxBrush& brush)
1237 {
1238 m_backgroundBrush = brush;
1239 }
1240
1241 void wxPostScriptDC::SetLogicalFunction (int WXUNUSED(function))
1242 {
1243 wxFAIL_MSG( _T("wxPostScriptDC::SetLogicalFunction not implemented.") );
1244 }
1245
1246 void wxPostScriptDC::DoDrawSpline( wxList *points )
1247 {
1248 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
1249
1250 SetPen( m_pen );
1251
1252 double a, b, c, d, x1, y1, x2, y2, x3, y3;
1253 wxPoint *p, *q;
1254
1255 wxNode *node = points->First();
1256 p = (wxPoint *)node->Data();
1257 x1 = p->x;
1258 y1 = p->y;
1259
1260 node = node->Next();
1261 p = (wxPoint *)node->Data();
1262 c = p->x;
1263 d = p->y;
1264 x3 = a = (double)(x1 + c) / 2;
1265 y3 = b = (double)(y1 + d) / 2;
1266
1267 fprintf( m_pstream,
1268 "newpath\n"
1269 "%ld %ld moveto\n"
1270 "%ld %ld lineto\n",
1271 XLOG2DEV((long)x1), YLOG2DEV((long)y1),
1272 XLOG2DEV((long)x3), YLOG2DEV((long)y3) );
1273
1274 CalcBoundingBox( (long)x1, (long)y1 );
1275 CalcBoundingBox( (long)x3, (long)y3 );
1276
1277 while ((node = node->Next()) != NULL)
1278 {
1279 q = (wxPoint *)node->Data();
1280
1281 x1 = x3;
1282 y1 = y3;
1283 x2 = c;
1284 y2 = d;
1285 c = q->x;
1286 d = q->y;
1287 x3 = (double)(x2 + c) / 2;
1288 y3 = (double)(y2 + d) / 2;
1289
1290 fprintf( m_pstream,
1291 "%ld %ld %ld %ld %ld %ld DrawSplineSection\n",
1292 XLOG2DEV((long)x1), YLOG2DEV((long)y1),
1293 XLOG2DEV((long)x2), YLOG2DEV((long)y2),
1294 XLOG2DEV((long)x3), YLOG2DEV((long)y3) );
1295
1296 CalcBoundingBox( (long)x1, (long)y1 );
1297 CalcBoundingBox( (long)x3, (long)y3 );
1298 }
1299
1300 /*
1301 At this point, (x2,y2) and (c,d) are the position of the
1302 next-to-last and last point respectively, in the point list
1303 */
1304
1305 fprintf( m_pstream,
1306 "%ld %ld lineto\n"
1307 "stroke\n",
1308 XLOG2DEV((long)c), YLOG2DEV((long)d) );
1309 }
1310
1311 long wxPostScriptDC::GetCharWidth() const
1312 {
1313 // Chris Breeze: reasonable approximation using wxMODERN/Courier
1314 return (long) (GetCharHeight() * 72.0 / 120.0);
1315 }
1316
1317
1318 void wxPostScriptDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1319 {
1320 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
1321
1322 m_signX = (xLeftRight ? 1 : -1);
1323 m_signY = (yBottomUp ? 1 : -1);
1324
1325 // FIXME there is no such function in MSW
1326 #ifndef __WXMSW__
1327 ComputeScaleAndOrigin();
1328 #endif
1329 }
1330
1331 void wxPostScriptDC::SetDeviceOrigin( long x, long y )
1332 {
1333 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
1334
1335 int h = 0;
1336 int w = 0;
1337 GetSize( &w, &h );
1338
1339 wxDC::SetDeviceOrigin( x, h-y );
1340 }
1341
1342 void wxPostScriptDC::DoGetSize(int* width, int* height) const
1343 {
1344 wxPaperSize id = m_printData.GetPaperId();
1345
1346 wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(id);
1347
1348 if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(wxPAPER_A4);
1349
1350 if (paper)
1351 {
1352 if (width) *width = paper->GetSizeDeviceUnits().x;
1353 if (height) *height = paper->GetSizeDeviceUnits().y;
1354 }
1355 else
1356 {
1357 if (width) *width = 595;
1358 if (height) *height = 842;
1359 }
1360 }
1361
1362 void wxPostScriptDC::DoGetSizeMM(int *width, int *height) const
1363 {
1364 wxPaperSize id = m_printData.GetPaperId();
1365
1366 wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(id);
1367
1368 if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(wxPAPER_A4);
1369
1370 if (paper)
1371 {
1372 if (width) *width = paper->GetWidth() / 10;
1373 if (height) *height = paper->GetHeight() / 10;
1374 }
1375 else
1376 {
1377 if (width) *width = 210;
1378 if (height) *height = 297;
1379 }
1380 }
1381
1382 // Resolution in pixels per logical inch
1383 wxSize wxPostScriptDC::GetPPI(void) const
1384 {
1385 return wxSize(72, 72);
1386 }
1387
1388
1389 bool wxPostScriptDC::StartDoc( const wxString& message )
1390 {
1391 wxCHECK_MSG( m_ok, FALSE, _T("invalid postscript dc") );
1392
1393 if (m_printData.GetFilename() == "")
1394 {
1395 wxString filename = wxGetTempFileName("ps");
1396 m_printData.SetFilename(filename);
1397 }
1398
1399 m_pstream = fopen( m_printData.GetFilename().fn_str(), "w+" );
1400
1401 if (!m_pstream)
1402 {
1403 wxMessageBox( _("Cannot open file for PostScript printing!"), _("Error"), wxOK );
1404 m_ok = FALSE;
1405 return FALSE;
1406 }
1407
1408 m_ok = TRUE;
1409
1410 fprintf( m_pstream, "%%%%BeginProlog\n" );
1411 fprintf( m_pstream, wxPostScriptHeaderEllipse );
1412 fprintf( m_pstream, wxPostScriptHeaderEllipticArc );
1413 fprintf( m_pstream, wxPostScriptHeaderColourImage );
1414 fprintf( m_pstream, wxPostScriptHeaderReencodeISO1 );
1415 fprintf( m_pstream, wxPostScriptHeaderReencodeISO2 );
1416 if (wxPostScriptHeaderSpline)
1417 fprintf( m_pstream, wxPostScriptHeaderSpline );
1418 fprintf( m_pstream, "%%%%EndProlog\n" );
1419
1420 SetBrush( *wxBLACK_BRUSH );
1421 SetPen( *wxBLACK_PEN );
1422 SetBackground( *wxWHITE_BRUSH );
1423 SetTextForeground( *wxBLACK );
1424
1425 // set origin according to paper size
1426 SetDeviceOrigin( 0,0 );
1427
1428 wxPageNumber = 1;
1429 m_pageNumber = 1;
1430 m_title = message;
1431 return TRUE;
1432 }
1433
1434 void wxPostScriptDC::EndDoc ()
1435 {
1436 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
1437
1438 if (m_clipping)
1439 {
1440 m_clipping = FALSE;
1441 fprintf( m_pstream, "grestore\n" );
1442 }
1443
1444 fclose( m_pstream );
1445 m_pstream = (FILE *) NULL;
1446
1447 wxChar *header_file = wxGetTempFileName("ps");
1448
1449 m_pstream = fopen( wxConvFile.cWX2MB(header_file) , "w+" );
1450
1451 fprintf( m_pstream, "%%!PS-Adobe-2.0\n" ); // PostScript magic strings
1452 fprintf( m_pstream, "%%%%Title: %s\n", m_title.mb_str() );
1453 fprintf( m_pstream, "%%%%Creator: %s\n", wxTheApp->argv[0] );
1454 fprintf( m_pstream, "%%%%CreationDate: %s\n", wxNow().mb_str() );
1455
1456 wxChar userID[256];
1457 if ( wxGetEmailAddress(userID, sizeof(userID)) )
1458 {
1459 fprintf( m_pstream, "%%%%For: %s ", MBSTRINGCAST wxConvCurrent->cWX2MB(userID) );
1460 wxChar userName[245];
1461 if (wxGetUserName(userName, sizeof(userName)))
1462 fprintf( m_pstream, " (%s)", MBSTRINGCAST wxConvCurrent->cWX2MB(userName) );
1463 fprintf( m_pstream, "\n" );
1464 }
1465 else if ( wxGetUserName(userID, sizeof(userID)) )
1466 {
1467 fprintf( m_pstream, "%%%%For: %s\n", MBSTRINGCAST wxConvCurrent->cWX2MB(userID) );;
1468 }
1469
1470 // THE FOLLOWING HAS BEEN CONTRIBUTED BY Andy Fyfe <andy@hyperparallel.com>
1471
1472 long wx_printer_translate_x, wx_printer_translate_y;
1473 double wx_printer_scale_x, wx_printer_scale_y;
1474
1475 wx_printer_translate_x = m_printData.GetPrinterTranslateX();
1476 wx_printer_translate_y = m_printData.GetPrinterTranslateY();
1477
1478 wx_printer_scale_x = m_printData.GetPrinterScaleX();
1479 wx_printer_scale_y = m_printData.GetPrinterScaleY();
1480
1481 if (m_printData.GetOrientation() == wxLANDSCAPE)
1482 fprintf( m_pstream, "%%%%Orientation: Landscape\n" );
1483 else
1484 fprintf( m_pstream, "%%%%Orientation: Portrait\n" );
1485
1486 // Compute the bounding box. Note that it is in the default user
1487 // coordinate system, thus we have to convert the values.
1488 long llx = (long) ((XLOG2DEV(m_minX)+wx_printer_translate_x)*wx_printer_scale_x);
1489 long lly = (long) ((YLOG2DEV(m_minY)+wx_printer_translate_y)*wx_printer_scale_y);
1490 long urx = (long) ((XLOG2DEV(m_maxX)+wx_printer_translate_x)*wx_printer_scale_x);
1491 long ury = (long) ((YLOG2DEV(m_maxY)+wx_printer_translate_y)*wx_printer_scale_y);
1492
1493 // If we're landscape, our sense of "x" and "y" is reversed.
1494 if (m_printData.GetOrientation() == wxLANDSCAPE)
1495 {
1496 long tmp;
1497 tmp = llx; llx = lly; lly = tmp;
1498 tmp = urx; urx = ury; ury = tmp;
1499
1500 // We need either the two lines that follow, or we need to subtract
1501 // min_x from real_translate_y, which is commented out below.
1502 llx = llx - (long)(m_minX*wx_printer_scale_y);
1503 urx = urx - (long)(m_minX*wx_printer_scale_y);
1504 }
1505
1506 // The Adobe specifications call for integers; we round as to make
1507 // the bounding larger.
1508 fprintf( m_pstream,
1509 "%%%%BoundingBox: %ld %ld %ld %ld\n",
1510 (long)floor((double)llx), (long)floor((double)lly),
1511 (long)ceil((double)urx), (long)ceil((double)ury) );
1512 fprintf( m_pstream, "%%%%Pages: %d\n", (wxPageNumber - 1) );
1513 fprintf( m_pstream, "%%%%EndComments\n\n" );
1514
1515 // To check the correctness of the bounding box, postscript commands
1516 // to draw a box corresponding to the bounding box are generated below.
1517 // But since we typically don't want to print such a box, the postscript
1518 // commands are generated within comments. These lines appear before any
1519 // adjustment of scale, rotation, or translation, and hence are in the
1520 // default user coordinates.
1521 fprintf( m_pstream, "%% newpath\n" );
1522 fprintf( m_pstream, "%% %ld %ld moveto\n", llx, lly );
1523 fprintf( m_pstream, "%% %ld %ld lineto\n", urx, lly );
1524 fprintf( m_pstream, "%% %ld %ld lineto\n", urx, ury );
1525 fprintf( m_pstream, "%% %ld %ld lineto closepath stroke\n", llx, ury );
1526
1527 fclose( m_pstream );
1528 m_pstream = (FILE*) NULL;
1529
1530 wxChar *tmp_file = wxGetTempFileName("ps");
1531
1532 // Paste header Before wx_printer_file
1533 wxConcatFiles (header_file, m_printData.GetFilename(), tmp_file );
1534 wxRemoveFile( header_file );
1535 wxRemoveFile( m_printData.GetFilename() );
1536 wxRenameFile( tmp_file, m_printData.GetFilename() );
1537
1538 #if defined(__X__) || defined(__WXGTK__)
1539 if (m_ok)
1540 {
1541 wxString previewCommand(m_printData.GetPreviewCommand());
1542 wxString printerCommand(m_printData.GetPrinterCommand());
1543 wxString printerOptions(m_printData.GetPrinterOptions());
1544 wxString filename(m_printData.GetFilename());
1545
1546 switch (m_printData.GetPrintMode())
1547 {
1548 case wxPRINT_MODE_PREVIEW:
1549 {
1550 wxChar *argv[3];
1551 argv[0] = WXSTRINGCAST previewCommand;
1552 argv[1] = WXSTRINGCAST filename;
1553 argv[2] = (wxChar*) NULL;
1554 wxExecute( argv, TRUE );
1555 wxRemoveFile( m_printData.GetFilename() );
1556 }
1557 break;
1558 case wxPRINT_MODE_PRINTER:
1559 {
1560 wxChar *argv[4];
1561 int argc = 0;
1562 argv[argc++] = WXSTRINGCAST printerCommand;
1563
1564 // !SM! If we simply assign to argv[1] here, if printer options
1565 // are blank, we get an annoying and confusing message from lpr.
1566 wxChar *opts = WXSTRINGCAST printerOptions;
1567 if (opts && *opts)
1568 argv[argc++] = opts;
1569
1570 argv[argc++] = WXSTRINGCAST filename;
1571 argv[argc++] = (wxChar *) NULL;
1572 wxExecute( argv, TRUE );
1573 wxRemoveFile( filename );
1574 }
1575 break;
1576 case wxPRINT_MODE_FILE:
1577 case wxPRINT_MODE_NONE:
1578 break;
1579 }
1580 }
1581 #endif
1582 }
1583
1584 void wxPostScriptDC::StartPage()
1585 {
1586 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
1587
1588 fprintf( m_pstream, "%%%%Page: %d\n", wxPageNumber++ );
1589
1590 // *m_pstream << "matrix currentmatrix\n";
1591
1592 // Added by Chris Breeze
1593
1594 // Each page starts with an "initgraphics" which resets the
1595 // transformation and so we need to reset the origin
1596 // (and rotate the page for landscape printing)
1597
1598 /*
1599 m_scaleFactor = 1.0;
1600 m_logicalOriginX = 0;
1601 m_logicalOriginY = 0;
1602 */
1603 // Output scaling
1604 long translate_x, translate_y;
1605 double scale_x, scale_y;
1606
1607 translate_x = m_printData.GetPrinterTranslateX();
1608 translate_y = m_printData.GetPrinterTranslateY();
1609
1610 scale_x = m_printData.GetPrinterScaleX();
1611 scale_y = m_printData.GetPrinterScaleY();
1612
1613 if (m_printData.GetOrientation() == wxLANDSCAPE)
1614 {
1615 // translate_y -= m_maxY;
1616 // fprintf( m_pstream, "90 rotate\n" );
1617
1618 printf( "Hi.\n" );
1619
1620 fprintf( m_pstream, "90 rotate llx neg ury nef translate\n" );
1621 }
1622
1623 // fprintf( m_pstream, "%.8f %.8f scale\n", scale_x, scale_y );
1624 // fprintf( m_pstream, "%ld %ld translate\n", translate_x, translate_y );
1625 }
1626
1627 void wxPostScriptDC::EndPage ()
1628 {
1629 wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
1630
1631 fprintf( m_pstream, "showpage\n" );
1632 }
1633
1634 bool wxPostScriptDC::DoBlit( long xdest, long ydest,
1635 long fwidth, long fheight,
1636 wxDC *source,
1637 long xsrc, long ysrc,
1638 int rop, bool WXUNUSED(useMask) )
1639 {
1640 wxCHECK_MSG( m_ok && m_pstream, FALSE, _T("invalid postscript dc") );
1641
1642 wxCHECK_MSG( source, FALSE, _T("invalid source dc") );
1643
1644 /* blit into a bitmap */
1645 wxBitmap bitmap( (int)fwidth, (int)fheight );
1646 wxMemoryDC memDC;
1647 memDC.SelectObject(bitmap);
1648 memDC.Blit(0, 0, fwidth, fheight, source, xsrc, ysrc, rop); /* TODO: Blit transparently? */
1649 memDC.SelectObject(wxNullBitmap);
1650
1651 /* draw bitmap. scaling and positioning is done there */
1652 DrawBitmap( bitmap, xdest, ydest );
1653
1654 return TRUE;
1655 }
1656
1657 long wxPostScriptDC::GetCharHeight() const
1658 {
1659 if (m_font.Ok())
1660 return m_font.GetPointSize();
1661 else
1662 return 12;
1663 }
1664
1665 void wxPostScriptDC::GetTextExtent( const wxString& string, long *x, long *y,
1666 long *descent, long *externalLeading, wxFont *theFont ) const
1667 {
1668 wxFont *fontToUse = theFont;
1669
1670 if (!fontToUse) fontToUse = (wxFont*) &m_font;
1671
1672 wxCHECK_RET( fontToUse, _T("GetTextExtent: no font defined") );
1673 wxCHECK_RET( x, _T("GetTextExtent: x == NULL") );
1674 wxCHECK_RET( y, _T("GetTextExtent: y == NULL") );
1675
1676 const wxWX2MBbuf strbuf = string.mb_str();
1677
1678 #if !USE_AFM_FOR_POSTSCRIPT
1679 /* Provide a VERY rough estimate (avoid using it).
1680 * Produces accurate results for mono-spaced font
1681 * such as Courier (aka wxMODERN) */
1682
1683 int height = 12;
1684 if (fontToUse)
1685 {
1686 height = fontToUse->GetPointSize();
1687 }
1688 *x = strlen (strbuf) * height * 72 / 120;
1689 *y = (long) (height * 1.32); /* allow for descender */
1690 if (descent) *descent = 0;
1691 if (externalLeading) *externalLeading = 0;
1692 #else
1693
1694 /* method for calculating string widths in postscript:
1695 / read in the AFM (adobe font metrics) file for the
1696 / actual font, parse it and extract the character widths
1697 / and also the descender. this may be improved, but for now
1698 / it works well. the AFM file is only read in if the
1699 / font is changed. this may be chached in the future.
1700 / calls to GetTextExtent with the font unchanged are rather
1701 / efficient!!!
1702 /
1703 / for each font and style used there is an AFM file necessary.
1704 / currently i have only files for the roman font family.
1705 / I try to get files for the other ones!
1706 /
1707 / CAVE: the size of the string is currently always calculated
1708 / in 'points' (1/72 of an inch). this should later on be
1709 / changed to depend on the mapping mode.
1710 / CAVE: the path to the AFM files must be set before calling this
1711 / function. this is usually done by a call like the following:
1712 / wxSetAFMPath("d:\\wxw161\\afm\\");
1713 /
1714 / example:
1715 /
1716 / wxPostScriptDC dc(NULL, TRUE);
1717 / if (dc.Ok()){
1718 / wxSetAFMPath("d:\\wxw161\\afm\\");
1719 / dc.StartDoc("Test");
1720 / dc.StartPage();
1721 / long w,h;
1722 / dc.SetFont(new wxFont(10, wxROMAN, wxNORMAL, wxNORMAL));
1723 / dc.GetTextExtent("Hallo",&w,&h);
1724 / dc.EndPage();
1725 / dc.EndDoc();
1726 / }
1727 /
1728 / by steve (stefan.hammes@urz.uni-heidelberg.de)
1729 / created: 10.09.94
1730 / updated: 14.05.95 */
1731
1732 /* these static vars are for storing the state between calls */
1733 static int lastFamily= INT_MIN;
1734 static int lastSize= INT_MIN;
1735 static int lastStyle= INT_MIN;
1736 static int lastWeight= INT_MIN;
1737 static int lastDescender = INT_MIN;
1738 static int lastWidths[256]; /* widths of the characters */
1739
1740 /* get actual parameters */
1741 const int Family = fontToUse->GetFamily();
1742 const int Size = fontToUse->GetPointSize();
1743 const int Style = fontToUse->GetStyle();
1744 const int Weight = fontToUse->GetWeight();
1745
1746 /* if we have another font, read the font-metrics */
1747 if (Family!=lastFamily || Size!=lastSize || Style!=lastStyle || Weight!=lastWeight)
1748 {
1749 /* store actual values */
1750 lastFamily = Family;
1751 lastSize = Size;
1752 lastStyle = Style;
1753 lastWeight = Weight;
1754
1755 char *name = (char*) NULL;
1756
1757 switch (Family)
1758 {
1759 case wxMODERN:
1760 {
1761 if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "CourBoO";
1762 else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "CourBo";
1763 else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "Cour0";
1764 else name = "Cour";
1765 }
1766 break;
1767 case wxROMAN:
1768 {
1769 if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "TimesBoO";
1770 else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "TimesBo";
1771 else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "TimesO";
1772 else if name = "TimesRo"; /* no typo */
1773 }
1774 break;
1775 default:
1776 {
1777 if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "HelvBoO";
1778 else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "HelvBo";
1779 else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "Helv0";
1780 else name = "Helv";
1781 }
1782 break;
1783 }
1784
1785 /* get the directory of the AFM files */
1786 char afmName[256];
1787 afmName[0] = 0;
1788
1789 if (!m_printData.GetFontMetricPath().IsEmpty())
1790 {
1791 strcpy( afmName, m_printData.GetFontMetricPath().fn_str() )
1792 }
1793
1794 /* 2. open and process the file
1795 / a short explanation of the AFM format:
1796 / we have for each character a line, which gives its size
1797 / e.g.:
1798 /
1799 / C 63 ; WX 444 ; N question ; B 49 -14 395 676 ;
1800 /
1801 / that means, we have a character with ascii code 63, and width
1802 / (444/1000 * fontSize) points.
1803 / the other data is ignored for now!
1804 /
1805 / when the font has changed, we read in the right AFM file and store the
1806 / character widths in an array, which is processed below (see point 3.). */
1807
1808 /* new elements JC Sun Aug 25 23:21:44 MET DST 1996 */
1809
1810 strcat(afmName,name);
1811 strcat(afmName,".afm");
1812 FILE *afmFile = fopen(afmName,"r");
1813
1814 #ifdef __UNIX__
1815 if (afmFile==NULL)
1816 {
1817 strcpy( afmName, "/usr/local/share/wx/gs_afm/" );
1818 strcat(afmName,name);
1819 strcat(afmName,".afm");
1820 FILE *afmFile = fopen(afmName,"r");
1821 }
1822
1823 if (afmFile==NULL)
1824 {
1825 strcpy( afmName, "/usr/share/wx/gs_afm/" );
1826 strcat(afmName,name);
1827 strcat(afmName,".afm");
1828 FILE *afmFile = fopen(afmName,"r");
1829 }
1830 #endif
1831
1832 if (afmFile==NULL)
1833 {
1834 wxLogDebug( "GetTextExtent: can't open AFM file '%s'\n", afmName );
1835 wxLogDebug( " using approximate values\n");
1836 for (int i=0; i<256; i++) lastWidths[i] = 500; /* an approximate value */
1837 lastDescender = -150; /* dito. */
1838 }
1839 else
1840 {
1841 /* init the widths array */
1842 for(int i=0; i<256; i++) lastWidths[i] = INT_MIN;
1843 /* some variables for holding parts of a line */
1844 char cString[10],semiString[10],WXString[10],descString[20];
1845 char upString[30], utString[30], encString[50];
1846 char line[256];
1847 int ascii,cWidth;
1848 /* read in the file and parse it */
1849 while(fgets(line,sizeof(line),afmFile)!=NULL)
1850 {
1851 /* A.) check for descender definition */
1852 if (strncmp(line,"Descender",9)==0)
1853 {
1854 if ((sscanf(line,"%s%d",descString,&lastDescender)!=2) ||
1855 (strcmp(descString,"Descender")!=0))
1856 {
1857 wxLogDebug( "AFM-file '%s': line '%s' has error (bad descender)\n", afmName,line );
1858 }
1859 }
1860 /* JC 1.) check for UnderlinePosition */
1861 else if(strncmp(line,"UnderlinePosition",17)==0)
1862 {
1863 if ((sscanf(line,"%s%lf",upString,&UnderlinePosition)!=2) ||
1864 (strcmp(upString,"UnderlinePosition")!=0))
1865 {
1866 wxLogDebug( "AFM-file '%s': line '%s' has error (bad UnderlinePosition)\n", afmName, line );
1867 }
1868 }
1869 /* JC 2.) check for UnderlineThickness */
1870 else if(strncmp(line,"UnderlineThickness",18)==0)
1871 {
1872 if ((sscanf(line,"%s%lf",utString,&UnderlineThickness)!=2) ||
1873 (strcmp(utString,"UnderlineThickness")!=0))
1874 {
1875 wxLogDebug( "AFM-file '%s': line '%s' has error (bad UnderlineThickness)\n", afmName, line );
1876 }
1877 }
1878 /* JC 3.) check for EncodingScheme */
1879 else if(strncmp(line,"EncodingScheme",14)==0)
1880 {
1881 if ((sscanf(line,"%s%s",utString,encString)!=2) ||
1882 (strcmp(utString,"EncodingScheme")!=0))
1883 {
1884 wxLogDebug("AFM-file '%s': line '%s' has error (bad EncodingScheme)\n", afmName, line );
1885 }
1886 else if (strncmp(encString, "AdobeStandardEncoding", 21))
1887 {
1888 wxLogDebug( "AFM-file '%s': line '%s' has error (unsupported EncodingScheme %s)\n",
1889 afmName,line, encString);
1890 }
1891 }
1892 /* B.) check for char-width */
1893 else if(strncmp(line,"C ",2)==0)
1894 {
1895 if (sscanf(line,"%s%d%s%s%d",cString,&ascii,semiString,WXString,&cWidth)!=5)
1896 {
1897 wxLogDebug("AFM-file '%s': line '%s' has an error (bad character width)\n",afmName,line);
1898 }
1899 if(strcmp(cString,"C")!=0 || strcmp(semiString,";")!=0 || strcmp(WXString,"WX")!=0)
1900 {
1901 wxLogDebug("AFM-file '%s': line '%s' has a format error\n",afmName,line);
1902 }
1903 /* printf(" char '%c'=%d has width '%d'\n",ascii,ascii,cWidth); */
1904 if (ascii>=0 && ascii<256)
1905 {
1906 lastWidths[ascii] = cWidth; /* store width */
1907 }
1908 else
1909 {
1910 /* MATTHEW: this happens a lot; don't print an error */
1911 /* wxLogDebug("AFM-file '%s': ASCII value %d out of range\n",afmName,ascii); */
1912 }
1913 }
1914 /* C.) ignore other entries. */
1915 }
1916 fclose(afmFile);
1917 }
1918 /* hack to compute correct values for german 'Umlaute'
1919 / the correct way would be to map the character names
1920 / like 'adieresis' to corresp. positions of ISOEnc and read
1921 / these values from AFM files, too. Maybe later ... */
1922 lastWidths[196] = lastWidths['A']; // Ä
1923 lastWidths[228] = lastWidths['a']; // ä
1924 lastWidths[214] = lastWidths['O']; // Ö
1925 lastWidths[246] = lastWidths['o']; // ö
1926 lastWidths[220] = lastWidths['U']; // Ü
1927 lastWidths[252] = lastWidths['u']; // ü
1928 lastWidths[223] = lastWidths[251]; // ß
1929 }
1930
1931 /* JC: calculate UnderlineThickness/UnderlinePosition */
1932 m_underlinePosition = m_underlinePosition * fontToUse->GetPointSize() / 1000.0f;
1933 m_underlineThickness = m_underlineThickness * fontToUse->GetPointSize() / 1000.0f * m_scaleFactor;
1934
1935 /* 3. now the font metrics are read in, calc size this
1936 / is done by adding the widths of the characters in the
1937 / string. they are given in 1/1000 of the size! */
1938
1939 long widthSum=0;
1940 long height=Size; /* by default */
1941 unsigned char *p;
1942 for(p=(unsigned char *)strbuf; *p; p++)
1943 {
1944 if(lastWidths[*p]== INT_MIN)
1945 {
1946 wxLogDebug("GetTextExtent: undefined width for character '%c' (%d)\n", *p,*p);
1947 widthSum += (long)(lastWidths[' ']/1000.0F * Size); /* assume space */
1948 }
1949 else
1950 {
1951 widthSum += (long)((lastWidths[*p]/1000.0F)*Size);
1952 }
1953 }
1954
1955 /* add descender to height (it is usually a negative value) */
1956 if (lastDescender!=INT_MIN)
1957 {
1958 height += (long)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
1959 }
1960
1961 /* return size values */
1962 *x = widthSum;
1963 *y = height;
1964
1965 /* return other parameters */
1966 if (descent)
1967 {
1968 if(lastDescender!=INT_MIN)
1969 {
1970 *descent = (long)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
1971 }
1972 else
1973 {
1974 *descent = 0;
1975 }
1976 }
1977
1978 /* currently no idea how to calculate this! */
1979 if (externalLeading) *externalLeading = 0;
1980
1981 #endif
1982 }
1983
1984 // Determine the Default Postscript Previewer
1985 // available on the platform
1986 #if defined(__SUN__) && defined(__XVIEW__)
1987 // OpenWindow/NeWS's Postscript Previewer
1988 # define PS_VIEWER_PROG "pageview"
1989 #elif defined(__VMS__)
1990 #define PS_VIEWER_PROG "view/format=ps/select=x_display"
1991 #elif defined(__SGI__)
1992 // SGI's Display Postscript Previewer
1993 //# define PS_VIEWER_PROG "dps"
1994 # define PS_VIEWER_PROG "xpsview"
1995 #elif defined(__X__) || defined(__WXGTK__)
1996 // Front-end to ghostscript
1997 # define PS_VIEWER_PROG "ghostview"
1998 #else
1999 // Windows ghostscript/ghostview
2000 # define PS_VIEWER_PROG NULL
2001 #endif
2002
2003 wxPrintSetupData *wxThePrintSetupData = (wxPrintSetupData *) NULL;
2004
2005 #if !USE_SHARED_LIBRARY
2006 IMPLEMENT_DYNAMIC_CLASS(wxPostScriptDC, wxDC)
2007 IMPLEMENT_DYNAMIC_CLASS(wxPrintSetupData, wxObject)
2008 #endif
2009
2010 // Redundant now I think
2011 #if 1
2012 IMPLEMENT_CLASS(wxPostScriptPrintDialog, wxDialog)
2013
2014 wxPostScriptPrintDialog::wxPostScriptPrintDialog (wxWindow *parent, const wxString& title,
2015 const wxPoint& pos, const wxSize& size, long style):
2016 wxDialog(parent, -1, title, pos, size, style)
2017 {
2018 wxBeginBusyCursor();
2019
2020 char buf[100];
2021 int yPos = 40;
2022 wxString
2023 *orientation = new wxString[2],
2024 *print_modes = new wxString[3];
2025 int features;
2026 long wx_printer_translate_x, wx_printer_translate_y;
2027 double wx_printer_scale_x, wx_printer_scale_y;
2028
2029 orientation[0] = _("Portrait");
2030 orientation[1] = _("Landscape");
2031
2032 print_modes[0] = _("Send to Printer");
2033 print_modes[1] = _("Print to File");
2034 print_modes[2] = _("Preview Only");
2035
2036
2037
2038 wxButton *okBut = new wxButton (this, wxID_OK, _("OK"), wxPoint(5, 5));
2039 (void) new wxButton (this, wxID_CANCEL, _("Cancel"), wxPoint(40, 5));
2040 okBut->SetDefault();
2041
2042
2043 #if defined(__WXGTK__) || defined (__WXMOTIF__)
2044 (void) new wxStaticText( this, -1, _("Printer Command: "),
2045 wxPoint(5, yPos) );
2046 (void) new wxTextCtrl( this, wxID_PRINTER_COMMAND, wxThePrintSetupData->GetPrinterCommand(),
2047 wxPoint(100, yPos), wxSize(100, -1) );
2048
2049 (void) new wxStaticText( this, -1, _("Printer Options: "),
2050 wxPoint(210, yPos) );
2051 (void) new wxTextCtrl( this, wxID_PRINTER_OPTIONS, wxThePrintSetupData->GetPrinterOptions(),
2052 wxPoint(305, yPos), wxSize(150, -1) );
2053
2054 yPos += 40;
2055 #endif
2056
2057
2058 wxRadioBox *radio0 = new wxRadioBox(this, wxID_PRINTER_ORIENTATION, "Orientation: ", wxPoint(5, yPos), wxSize(-1,-1),
2059 2,orientation,2,wxRA_SPECIFY_ROWS);
2060 radio0->SetSelection((int)wxThePrintSetupData->GetPrinterOrientation() - 1);
2061
2062 // @@@ Configuration hook
2063 if ( !wxThePrintSetupData->GetPrintPreviewCommand() )
2064 wxThePrintSetupData->SetPrintPreviewCommand(PS_VIEWER_PROG);
2065
2066 // wxGetResource ("wxWindows", "PSView", &wxThePrintSetupData->m_previewCommand);
2067
2068 features = (wxThePrintSetupData->GetPrintPreviewCommand() &&
2069 *wxThePrintSetupData->GetPrintPreviewCommand()) ? 3 : 2;
2070
2071 wxRadioBox *radio1 = new wxRadioBox(this, wxID_PRINTER_MODES, _("PostScript:"),
2072 wxPoint(150, yPos),
2073 wxSize(-1,-1), features,
2074 print_modes, features, wxRA_SPECIFY_ROWS);
2075
2076 #ifdef __WXMSW__
2077 radio1->Enable(0, FALSE);
2078 if (wxThePrintSetupData->GetPrintPreviewCommand() && *wxThePrintSetupData->GetPrintPreviewCommand())
2079 radio1->Enable(2, FALSE);
2080 #endif
2081
2082 radio1->SetSelection((int)wxThePrintSetupData->GetPrinterMode());
2083 wxThePrintSetupData->GetPrinterTranslation(&wx_printer_translate_x, &wx_printer_translate_y);
2084 wxThePrintSetupData->GetPrinterScaling(&wx_printer_scale_x, &wx_printer_scale_y);
2085
2086 sprintf (buf, "%.2f", wx_printer_scale_x);
2087
2088 yPos += 90;
2089 (void) new wxStaticText(this, -1, _("X Scaling"), wxPoint(5, yPos));
2090 /* wxTextCtrl *text1 = */ (void) new wxTextCtrl(this, wxID_PRINTER_X_SCALE, buf, wxPoint(100, yPos), wxSize(100, -1));
2091
2092 sprintf (buf, "%.2f", wx_printer_scale_y);
2093 (void) new wxStaticText(this, -1, _("Y Scaling"), wxPoint(220, yPos));
2094 /* wxTextCtrl *text2 = */ (void) new wxTextCtrl(this, wxID_PRINTER_Y_SCALE, buf, wxPoint(320, yPos), wxSize(100, -1));
2095
2096 yPos += 25;
2097
2098 (void) new wxStaticText(this, -1, _("X Translation"), wxPoint(5, yPos));
2099 sprintf (buf, "%.2ld", wx_printer_translate_x);
2100 /* wxTextCtrl *text3 = */ (void) new wxTextCtrl(this, wxID_PRINTER_X_TRANS, buf, wxPoint(100, yPos), wxSize(100, -1));
2101
2102 (void) new wxStaticText(this, -1, _("Y Translation"), wxPoint(220, yPos));
2103 sprintf (buf, "%.2ld", wx_printer_translate_y);
2104 /* wxTextCtrl *text4 = */ (void) new wxTextCtrl(this, wxID_PRINTER_Y_TRANS, buf, wxPoint(320, yPos), wxSize(100, -1));
2105
2106 Fit ();
2107
2108 delete[] orientation;
2109 delete[] print_modes;
2110
2111 wxEndBusyCursor();
2112 }
2113
2114 int wxPostScriptPrintDialog::ShowModal ()
2115 {
2116 if ( wxDialog::ShowModal() == wxID_OK )
2117 {
2118 // wxTextCtrl *text0 = (wxTextCtrl *)FindWindow(wxID_PRINTER_OPTIONS);
2119 wxTextCtrl *text1 = (wxTextCtrl *)FindWindow(wxID_PRINTER_X_SCALE);
2120 wxTextCtrl *text2 = (wxTextCtrl *)FindWindow(wxID_PRINTER_Y_SCALE);
2121 wxTextCtrl *text3 = (wxTextCtrl *)FindWindow(wxID_PRINTER_X_TRANS);
2122 wxTextCtrl *text4 = (wxTextCtrl *)FindWindow(wxID_PRINTER_Y_TRANS);
2123 // wxTextCtrl *text_prt = (wxTextCtrl *)FindWindow(wxID_PRINTER_COMMAND);
2124 wxRadioBox *radio0 = (wxRadioBox *)FindWindow(wxID_PRINTER_ORIENTATION);
2125 wxRadioBox *radio1 = (wxRadioBox *)FindWindow(wxID_PRINTER_MODES);
2126
2127 StringToDouble (WXSTRINGCAST text1->GetValue (), &wxThePrintSetupData->m_printerScaleX);
2128 StringToDouble (WXSTRINGCAST text2->GetValue (), &wxThePrintSetupData->m_printerScaleY);
2129 StringToLong (WXSTRINGCAST text3->GetValue (), &wxThePrintSetupData->m_printerTranslateX);
2130 StringToLong (WXSTRINGCAST text4->GetValue (), &wxThePrintSetupData->m_printerTranslateY);
2131
2132 #ifdef __X__
2133 // wxThePrintSetupData->SetPrinterOptions(WXSTRINGCAST text0->GetValue ());
2134 // wxThePrintSetupData->SetPrinterCommand(WXSTRINGCAST text_prt->GetValue ());
2135 #endif
2136
2137 wxThePrintSetupData->SetPrinterOrientation((radio0->GetSelection() == 1 ? wxLANDSCAPE : wxPORTRAIT));
2138
2139 // C++ wants this
2140 switch ( radio1->GetSelection() ) {
2141 case 0: wxThePrintSetupData->SetPrinterMode(PS_PRINTER); break;
2142 case 1: wxThePrintSetupData->SetPrinterMode(PS_FILE); break;
2143 case 2: wxThePrintSetupData->SetPrinterMode(PS_PREVIEW); break;
2144 }
2145 return wxID_OK;
2146 }
2147 return wxID_CANCEL;
2148 }
2149 #endif
2150 // 0 (redundant)
2151
2152 // PostScript printer settings
2153 // RETAINED FOR BACKWARD COMPATIBILITY
2154 void wxSetPrinterCommand(const wxString& cmd)
2155 {
2156 wxThePrintSetupData->SetPrinterCommand(cmd);
2157 }
2158
2159 void wxSetPrintPreviewCommand(const wxString& cmd)
2160 {
2161 wxThePrintSetupData->SetPrintPreviewCommand(cmd);
2162 }
2163
2164 void wxSetPrinterOptions(const wxString& flags)
2165 {
2166 wxThePrintSetupData->SetPrinterOptions(flags);
2167 }
2168
2169 void wxSetPrinterFile(const wxString& f)
2170 {
2171 wxThePrintSetupData->SetPrinterFile(f);
2172 }
2173
2174 void wxSetPrinterOrientation(int orient)
2175 {
2176 wxThePrintSetupData->SetPrinterOrientation(orient);
2177 }
2178
2179 void wxSetPrinterScaling(double x, double y)
2180 {
2181 wxThePrintSetupData->SetPrinterScaling(x, y);
2182 }
2183
2184 void wxSetPrinterTranslation(long x, long y)
2185 {
2186 wxThePrintSetupData->SetPrinterTranslation(x, y);
2187 }
2188
2189 // 1 = Preview, 2 = print to file, 3 = send to printer
2190 void wxSetPrinterMode(int mode)
2191 {
2192 wxThePrintSetupData->SetPrinterMode(mode);
2193 }
2194
2195 void wxSetAFMPath(const wxString& f)
2196 {
2197 wxThePrintSetupData->SetAFMPath(f);
2198 }
2199
2200 // Get current values
2201 wxString wxGetPrinterCommand()
2202 {
2203 return wxThePrintSetupData->GetPrinterCommand();
2204 }
2205
2206 wxString wxGetPrintPreviewCommand()
2207 {
2208 return wxThePrintSetupData->GetPrintPreviewCommand();
2209 }
2210
2211 wxString wxGetPrinterOptions()
2212 {
2213 return wxThePrintSetupData->GetPrinterOptions();
2214 }
2215
2216 wxString wxGetPrinterFile()
2217 {
2218 return wxThePrintSetupData->GetPrinterFile();
2219 }
2220
2221 int wxGetPrinterOrientation()
2222 {
2223 return wxThePrintSetupData->GetPrinterOrientation();
2224 }
2225
2226 void wxGetPrinterScaling(double* x, double* y)
2227 {
2228 wxThePrintSetupData->GetPrinterScaling(x, y);
2229 }
2230
2231 void wxGetPrinterTranslation(long *x, long *y)
2232 {
2233 wxThePrintSetupData->GetPrinterTranslation(x, y);
2234 }
2235
2236 int wxGetPrinterMode()
2237 {
2238 return wxThePrintSetupData->GetPrinterMode();
2239 }
2240
2241 wxString wxGetAFMPath()
2242 {
2243 return wxThePrintSetupData->GetAFMPath();
2244 }
2245
2246 /*
2247 * Print setup data
2248 */
2249
2250 wxPrintSetupData::wxPrintSetupData()
2251 {
2252 m_printerOrient = wxPORTRAIT;
2253 m_printerScaleX = (double)1.0;
2254 m_printerScaleY = (double)1.0;
2255 m_printerTranslateX = 0;
2256 m_printerTranslateY = 0;
2257 m_printerMode = wxPRINT_MODE_FILE;
2258 m_printColour = TRUE;
2259 }
2260
2261 wxPrintSetupData::~wxPrintSetupData()
2262 {
2263 }
2264
2265 void wxPrintSetupData::operator=(wxPrintSetupData& data)
2266 {
2267 SetPrinterCommand(data.GetPrinterCommand());
2268 SetPrintPreviewCommand(data.GetPrintPreviewCommand());
2269 SetPrinterOptions(data.GetPrinterOptions());
2270 long x, y;
2271 data.GetPrinterTranslation(&x, &y);
2272 SetPrinterTranslation(x, y);
2273
2274 double x1, y1;
2275 data.GetPrinterScaling(&x1, &y1);
2276 SetPrinterScaling(x1, y1);
2277
2278 SetPrinterOrientation(data.GetPrinterOrientation());
2279 SetPrinterMode(data.GetPrinterMode());
2280 SetAFMPath(data.GetAFMPath());
2281 SetPaperName(data.GetPaperName());
2282 SetColour(data.GetColour());
2283 }
2284
2285 // Initialize from a wxPrintData object (wxPrintData should now be used instead of wxPrintSetupData).
2286 void wxPrintSetupData::operator=(const wxPrintData& data)
2287 {
2288 SetPrinterCommand(data.GetPrinterCommand());
2289 SetPrintPreviewCommand(data.GetPreviewCommand());
2290 SetPrinterOptions(data.GetPrinterOptions());
2291 SetPrinterTranslation(data.GetPrinterTranslateX(), data.GetPrinterTranslateY());
2292 SetPrinterScaling(data.GetPrinterScaleX(), data.GetPrinterScaleY());
2293 SetPrinterOrientation(data.GetOrientation());
2294 SetPrinterMode((int) data.GetPrintMode());
2295 SetAFMPath(data.GetFontMetricPath());
2296 SetPaperName(wxThePrintPaperDatabase->ConvertIdToName(data.GetPaperId()));
2297 SetColour(data.GetColour());
2298 SetPrinterFile(data.GetFilename());
2299 }
2300
2301 void wxInitializePrintSetupData(bool init)
2302 {
2303 if (init)
2304 {
2305 wxThePrintSetupData = new wxPrintSetupData;
2306
2307 wxThePrintSetupData->SetPrintPreviewCommand(PS_VIEWER_PROG);
2308 wxThePrintSetupData->SetPrinterOrientation(wxPORTRAIT);
2309 wxThePrintSetupData->SetPrinterMode(wxPRINT_MODE_PREVIEW);
2310 wxThePrintSetupData->SetPaperName(_("A4 sheet, 210 x 297 mm"));
2311
2312 // Could have a .ini file to read in some defaults
2313 // - and/or use environment variables, e.g. WXWIN
2314 #ifdef __VMS__
2315 wxThePrintSetupData->SetPrinterCommand("print");
2316 wxThePrintSetupData->SetPrinterOptions("/nonotify/queue=psqueue");
2317 wxThePrintSetupData->SetAFMPath("sys$ps_font_metrics:");
2318 #endif
2319 #ifdef __WXMSW__
2320 wxThePrintSetupData->SetPrinterCommand("print");
2321 wxThePrintSetupData->SetAFMPath("c:\\windows\\system\\");
2322 wxThePrintSetupData->SetPrinterOptions("");
2323 #endif
2324 #if !defined(__VMS__) && !defined(__WXMSW__)
2325 wxThePrintSetupData->SetPrinterCommand("lpr");
2326 wxThePrintSetupData->SetPrinterOptions("");
2327 wxThePrintSetupData->SetAFMPath("");
2328 #endif
2329 }
2330 else
2331 {
2332 if (wxThePrintSetupData)
2333 delete wxThePrintSetupData;
2334 wxThePrintSetupData = (wxPrintSetupData *) NULL;
2335 }
2336 }
2337
2338 // A module to allow initialization/cleanup of PostScript-related
2339 // things without calling these functions from app.cpp.
2340
2341 class WXDLLEXPORT wxPostScriptModule: public wxModule
2342 {
2343 DECLARE_DYNAMIC_CLASS(wxPostScriptModule)
2344 public:
2345 wxPostScriptModule() {}
2346 bool OnInit();
2347 void OnExit();
2348 };
2349
2350 IMPLEMENT_DYNAMIC_CLASS(wxPostScriptModule, wxModule)
2351
2352 /*
2353 * Initialization/cleanup module
2354 */
2355
2356 bool wxPostScriptModule::OnInit()
2357 {
2358 wxInitializePrintSetupData();
2359
2360 return TRUE;
2361 }
2362
2363 void wxPostScriptModule::OnExit()
2364 {
2365 wxInitializePrintSetupData(FALSE);
2366 }
2367
2368 #endif
2369 // wxUSE_POSTSCRIPT
2370
2371 #endif
2372 // wxUSE_PRINTING_ARCHITECTURE
wxWidgets (Impactor)