2 * PostScript output functions
4 * Copyright 1998 Huw D M Davies
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
34 #include "wine/debug.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(psdrv
);
38 static const char psheader
[] = /* title llx lly urx ury */
40 "%%%%Creator: Wine PostScript Driver\n"
42 "%%%%BoundingBox: %d %d %d %d\n"
43 "%%%%Pages: (atend)\n"
46 static const char psbeginprolog
[] =
49 static const char psendprolog
[] =
52 static const char psprolog
[] =
53 "/tmpmtrx matrix def\n"
56 " /b exch def /r exch def /t exch def /l exch def /gap 32 def\n"
57 " l cvi gap idiv gap mul\n"
59 " r cvi gap idiv gap mul\n"
60 " {t moveto 0 b t sub rlineto}\n"
63 "/B {pop pop pop pop} def\n"
65 "/havetype42gdir {version cvi 2015 ge} bind def\n";
67 static const char psbeginsetup
[] =
70 static const char psendsetup
[] =
73 static const char psbeginfeature
[] = /* feature, value */
75 "%%%%BeginFeature: %s %s\n";
77 static const char psendfeature
[] =
79 "} stopped cleartomark\n";
81 static const char psnewpage
[] = /* name, number, xres, yres, xtrans, ytrans, rot */
83 "%%%%BeginPageSetup\n"
85 "72 %d div 72 %d div scale\n"
91 static const char psendpage
[] =
95 static const char psfooter
[] = /* pages */
100 static const char psmoveto
[] = /* x, y */
103 static const char pslineto
[] = /* x, y */
106 static const char psstroke
[] =
109 static const char psrectangle
[] = /* x, y, width, height, -width */
116 static const char psrrectangle
[] = /* x, y, width, height, -width */
123 static const char psglyphshow
[] = /* glyph name */
126 static const char pssetfont
[] = /* fontname, xscale, yscale, ascent, escapement */
129 "%d 10 div matrix rotate\n"
130 "matrix concatmatrix\n"
131 "makefont setfont\n";
133 static const char pssetlinewidth
[] = /* width */
136 static const char pssetdash
[] = /* dash, offset */
139 static const char pssetgray
[] = /* gray */
142 static const char pssetrgbcolor
[] = /* r, g, b */
143 "%.2f %.2f %.2f setrgbcolor\n";
145 static const char psarc
[] = /* x, y, w, h, ang1, ang2 */
146 "tmpmtrx currentmatrix pop\n"
149 "0 0 0.5 %.1f %.1f arc\n"
150 "tmpmtrx setmatrix\n";
152 static const char psgsave
[] =
155 static const char psgrestore
[] =
158 static const char psfill
[] =
161 static const char pseofill
[] =
164 static const char psnewpath
[] =
167 static const char psclosepath
[] =
170 static const char psclip
[] =
173 static const char psinitclip
[] =
176 static const char pseoclip
[] =
179 static const char psrectclip
[] =
180 "%d %d %d %d rectclip\n";
182 static const char psrectclip2
[] =
185 static const char pshatch
[] =
188 static const char psrotate
[] = /* ang */
191 static const char psarrayget
[] =
194 static const char psarrayput
[] =
197 static const char psarraydef
[] =
198 "/%s %d array def\n";
200 static const char psenddocument
[] =
203 DWORD
PSDRV_WriteSpool(PSDRV_PDEVICE
*physDev
, LPCSTR lpData
, DWORD cch
)
205 int num
, num_left
= cch
;
207 if(physDev
->job
.quiet
) {
208 TRACE("ignoring output\n");
212 if(physDev
->job
.in_passthrough
) { /* Was in PASSTHROUGH mode */
213 WriteSpool16( physDev
->job
.hJob
, (LPSTR
)psenddocument
, sizeof(psenddocument
)-1 );
214 physDev
->job
.in_passthrough
= physDev
->job
.had_passthrough_rect
= FALSE
;
217 if(physDev
->job
.OutOfPage
) { /* Will get here after NEWFRAME Escape */
218 if( !PSDRV_StartPage(physDev
) )
223 num
= min(num_left
, 0x8000);
224 if(WriteSpool16( physDev
->job
.hJob
, (LPSTR
)lpData
, num
) != num
)
234 static INT
PSDRV_WriteFeature(HANDLE16 hJob
, LPCSTR feature
, LPCSTR value
, LPSTR invocation
)
237 char *buf
= HeapAlloc( PSDRV_Heap
, 0, sizeof(psbeginfeature
) +
238 strlen(feature
) + strlen(value
));
241 sprintf(buf
, psbeginfeature
, feature
, value
);
242 WriteSpool16( hJob
, buf
, strlen(buf
) );
244 WriteSpool16( hJob
, invocation
, strlen(invocation
) );
246 WriteSpool16( hJob
, (LPSTR
)psendfeature
, strlen(psendfeature
) );
248 HeapFree( PSDRV_Heap
, 0, buf
);
252 /********************************************************
255 * Helper for PSDRV_WriteHeader. Escape any non-printable characters
256 * as octal. If we've had to use an escape then surround the entire string
257 * in brackets. Truncate string to represent at most 0x80 characters.
260 static char *escape_title(LPCSTR str
)
267 ret
= HeapAlloc(GetProcessHeap(), 0, 1);
272 for(i
= 0; i
< 0x80 && str
[i
]; i
++)
280 ret
= HeapAlloc(GetProcessHeap(), 0, i
+ 1);
286 extra
+= 2; /* two for the brackets */
287 cp
= ret
= HeapAlloc(GetProcessHeap(), 0, i
+ extra
+ 1);
289 for(i
= 0; i
< 0x80 && str
[i
]; i
++)
293 BYTE b
= (BYTE
)str
[i
];
295 *cp
++ = ((b
>> 6) & 0x7) + '0';
296 *cp
++ = ((b
>> 3) & 0x7) + '0';
297 *cp
++ = ((b
) & 0x7) + '0';
308 INT
PSDRV_WriteHeader( PSDRV_PDEVICE
*physDev
, LPCSTR title
)
310 char *buf
, *escaped_title
;
315 int llx
, lly
, urx
, ury
;
317 TRACE("'%s'\n", debugstr_a(title
));
319 escaped_title
= escape_title(title
);
320 buf
= HeapAlloc( PSDRV_Heap
, 0, sizeof(psheader
) +
321 strlen(escaped_title
) + 30 );
323 WARN("HeapAlloc failed\n");
327 /* BBox co-ords are in default user co-ord system so urx < ury even in
329 llx
= physDev
->ImageableArea
.left
* 72.0 / physDev
->logPixelsX
;
330 lly
= physDev
->ImageableArea
.bottom
* 72.0 / physDev
->logPixelsY
;
331 urx
= physDev
->ImageableArea
.right
* 72.0 / physDev
->logPixelsX
;
332 ury
= physDev
->ImageableArea
.top
* 72.0 / physDev
->logPixelsY
;
333 /* FIXME should do something better with BBox */
335 sprintf(buf
, psheader
, escaped_title
, llx
, lly
, urx
, ury
);
337 HeapFree(GetProcessHeap(), 0, escaped_title
);
338 if( WriteSpool16( physDev
->job
.hJob
, buf
, strlen(buf
) ) !=
340 WARN("WriteSpool error\n");
341 HeapFree( PSDRV_Heap
, 0, buf
);
344 HeapFree( PSDRV_Heap
, 0, buf
);
346 WriteSpool16( physDev
->job
.hJob
, (LPSTR
)psbeginprolog
, strlen(psbeginprolog
) );
347 WriteSpool16( physDev
->job
.hJob
, (LPSTR
)psprolog
, strlen(psprolog
) );
348 WriteSpool16( physDev
->job
.hJob
, (LPSTR
)psendprolog
, strlen(psendprolog
) );
350 WriteSpool16( physDev
->job
.hJob
, (LPSTR
)psbeginsetup
, strlen(psbeginsetup
) );
352 if(physDev
->Devmode
->dmPublic
.dmCopies
> 1) {
353 char copies_buf
[100];
354 sprintf(copies_buf
, "mark {\n << /NumCopies %d >> setpagedevice\n} stopped cleartomark\n", physDev
->Devmode
->dmPublic
.dmCopies
);
355 WriteSpool16(physDev
->job
.hJob
, copies_buf
, strlen(copies_buf
));
358 for(slot
= physDev
->pi
->ppd
->InputSlots
; slot
; slot
= slot
->next
) {
359 if(slot
->WinBin
== physDev
->Devmode
->dmPublic
.dmDefaultSource
) {
360 if(slot
->InvocationString
) {
361 PSDRV_WriteFeature(physDev
->job
.hJob
, "*InputSlot", slot
->Name
,
362 slot
->InvocationString
);
368 for(page
= physDev
->pi
->ppd
->PageSizes
; page
; page
= page
->next
) {
369 if(page
->WinPage
== physDev
->Devmode
->dmPublic
.u1
.s1
.dmPaperSize
) {
370 if(page
->InvocationString
) {
371 PSDRV_WriteFeature(physDev
->job
.hJob
, "*PageSize", page
->Name
,
372 page
->InvocationString
);
378 win_duplex
= physDev
->Devmode
->dmPublic
.dmFields
& DM_DUPLEX
?
379 physDev
->Devmode
->dmPublic
.dmDuplex
: 0;
380 for(duplex
= physDev
->pi
->ppd
->Duplexes
; duplex
; duplex
= duplex
->next
) {
381 if(duplex
->WinDuplex
== win_duplex
) {
382 if(duplex
->InvocationString
) {
383 PSDRV_WriteFeature(physDev
->job
.hJob
, "*Duplex", duplex
->Name
,
384 duplex
->InvocationString
);
390 WriteSpool16( physDev
->job
.hJob
, (LPSTR
)psendsetup
, strlen(psendsetup
) );
397 INT
PSDRV_WriteFooter( PSDRV_PDEVICE
*physDev
)
401 buf
= HeapAlloc( PSDRV_Heap
, 0, sizeof(psfooter
) + 100 );
403 WARN("HeapAlloc failed\n");
407 sprintf(buf
, psfooter
, physDev
->job
.PageNo
);
409 if( WriteSpool16( physDev
->job
.hJob
, buf
, strlen(buf
) ) !=
411 WARN("WriteSpool error\n");
412 HeapFree( PSDRV_Heap
, 0, buf
);
415 HeapFree( PSDRV_Heap
, 0, buf
);
421 INT
PSDRV_WriteEndPage( PSDRV_PDEVICE
*physDev
)
423 if( WriteSpool16( physDev
->job
.hJob
, (LPSTR
)psendpage
, sizeof(psendpage
)-1 ) !=
424 sizeof(psendpage
)-1 ) {
425 WARN("WriteSpool error\n");
434 INT
PSDRV_WriteNewPage( PSDRV_PDEVICE
*physDev
)
438 signed int xtrans
, ytrans
, rotation
;
440 sprintf(name
, "%d", physDev
->job
.PageNo
);
442 buf
= HeapAlloc( PSDRV_Heap
, 0, sizeof(psnewpage
) + 200 );
444 WARN("HeapAlloc failed\n");
448 if(physDev
->Devmode
->dmPublic
.u1
.s1
.dmOrientation
== DMORIENT_LANDSCAPE
) {
449 if(physDev
->pi
->ppd
->LandscapeOrientation
== -90) {
450 xtrans
= physDev
->ImageableArea
.right
;
451 ytrans
= physDev
->ImageableArea
.top
;
454 xtrans
= physDev
->ImageableArea
.left
;
455 ytrans
= physDev
->ImageableArea
.bottom
;
459 xtrans
= physDev
->ImageableArea
.left
;
460 ytrans
= physDev
->ImageableArea
.top
;
464 sprintf(buf
, psnewpage
, name
, physDev
->job
.PageNo
,
465 physDev
->logPixelsX
, physDev
->logPixelsY
,
466 xtrans
, ytrans
, rotation
);
468 if( WriteSpool16( physDev
->job
.hJob
, buf
, strlen(buf
) ) !=
470 WARN("WriteSpool error\n");
471 HeapFree( PSDRV_Heap
, 0, buf
);
474 HeapFree( PSDRV_Heap
, 0, buf
);
479 BOOL
PSDRV_WriteMoveTo(PSDRV_PDEVICE
*physDev
, INT x
, INT y
)
483 sprintf(buf
, psmoveto
, x
, y
);
484 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
487 BOOL
PSDRV_WriteLineTo(PSDRV_PDEVICE
*physDev
, INT x
, INT y
)
491 sprintf(buf
, pslineto
, x
, y
);
492 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
496 BOOL
PSDRV_WriteStroke(PSDRV_PDEVICE
*physDev
)
498 return PSDRV_WriteSpool(physDev
, psstroke
, sizeof(psstroke
)-1);
503 BOOL
PSDRV_WriteRectangle(PSDRV_PDEVICE
*physDev
, INT x
, INT y
, INT width
,
508 sprintf(buf
, psrectangle
, x
, y
, width
, height
, -width
);
509 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
512 BOOL
PSDRV_WriteRRectangle(PSDRV_PDEVICE
*physDev
, INT x
, INT y
, INT width
,
517 sprintf(buf
, psrrectangle
, x
, y
, width
, height
, -width
);
518 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
521 BOOL
PSDRV_WriteArc(PSDRV_PDEVICE
*physDev
, INT x
, INT y
, INT w
, INT h
, double ang1
,
526 /* Make angles -ve and swap order because we're working with an upside
528 push_lc_numeric("C");
529 sprintf(buf
, psarc
, x
, y
, w
, h
, -ang2
, -ang1
);
531 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
535 BOOL
PSDRV_WriteSetFont(PSDRV_PDEVICE
*physDev
, const char *name
, INT size
, INT escapement
)
539 buf
= HeapAlloc( PSDRV_Heap
, 0, sizeof(pssetfont
) +
543 WARN("HeapAlloc failed\n");
547 sprintf(buf
, pssetfont
, name
, size
, -size
, -escapement
);
549 PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
550 HeapFree(PSDRV_Heap
, 0, buf
);
554 BOOL
PSDRV_WriteSetColor(PSDRV_PDEVICE
*physDev
, PSCOLOR
*color
)
558 PSDRV_CopyColor(&physDev
->inkColor
, color
);
559 switch(color
->type
) {
561 push_lc_numeric("C");
562 sprintf(buf
, pssetrgbcolor
, color
->value
.rgb
.r
, color
->value
.rgb
.g
,
565 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
568 push_lc_numeric("C");
569 sprintf(buf
, pssetgray
, color
->value
.gray
.i
);
571 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
574 ERR("Unkonwn colour type %d\n", color
->type
);
581 BOOL
PSDRV_WriteSetPen(PSDRV_PDEVICE
*physDev
)
585 sprintf(buf
, pssetlinewidth
, physDev
->pen
.width
);
586 PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
588 if(physDev
->pen
.dash
) {
589 sprintf(buf
, pssetdash
, physDev
->pen
.dash
, 0);
592 sprintf(buf
, pssetdash
, "", 0);
594 PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
599 BOOL
PSDRV_WriteGlyphShow(PSDRV_PDEVICE
*physDev
, LPCSTR g_name
)
604 l
= snprintf(buf
, sizeof(buf
), psglyphshow
, g_name
);
606 if (l
< sizeof(psglyphshow
) - 2 || l
> sizeof(buf
) - 1) {
607 WARN("Unusable glyph name '%s' - ignoring\n", g_name
);
611 PSDRV_WriteSpool(physDev
, buf
, l
);
615 BOOL
PSDRV_WriteFill(PSDRV_PDEVICE
*physDev
)
617 return PSDRV_WriteSpool(physDev
, psfill
, sizeof(psfill
)-1);
620 BOOL
PSDRV_WriteEOFill(PSDRV_PDEVICE
*physDev
)
622 return PSDRV_WriteSpool(physDev
, pseofill
, sizeof(pseofill
)-1);
625 BOOL
PSDRV_WriteGSave(PSDRV_PDEVICE
*physDev
)
627 return PSDRV_WriteSpool(physDev
, psgsave
, sizeof(psgsave
)-1);
630 BOOL
PSDRV_WriteGRestore(PSDRV_PDEVICE
*physDev
)
632 return PSDRV_WriteSpool(physDev
, psgrestore
, sizeof(psgrestore
)-1);
635 BOOL
PSDRV_WriteNewPath(PSDRV_PDEVICE
*physDev
)
637 return PSDRV_WriteSpool(physDev
, psnewpath
, sizeof(psnewpath
)-1);
640 BOOL
PSDRV_WriteClosePath(PSDRV_PDEVICE
*physDev
)
642 return PSDRV_WriteSpool(physDev
, psclosepath
, sizeof(psclosepath
)-1);
645 BOOL
PSDRV_WriteClip(PSDRV_PDEVICE
*physDev
)
647 return PSDRV_WriteSpool(physDev
, psclip
, sizeof(psclip
)-1);
650 BOOL
PSDRV_WriteEOClip(PSDRV_PDEVICE
*physDev
)
652 return PSDRV_WriteSpool(physDev
, pseoclip
, sizeof(pseoclip
)-1);
655 BOOL
PSDRV_WriteInitClip(PSDRV_PDEVICE
*physDev
)
657 return PSDRV_WriteSpool(physDev
, psinitclip
, sizeof(psinitclip
)-1);
660 BOOL
PSDRV_WriteHatch(PSDRV_PDEVICE
*physDev
)
662 return PSDRV_WriteSpool(physDev
, pshatch
, sizeof(pshatch
)-1);
665 BOOL
PSDRV_WriteRotate(PSDRV_PDEVICE
*physDev
, float ang
)
669 push_lc_numeric("C");
670 sprintf(buf
, psrotate
, ang
);
672 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
675 BOOL
PSDRV_WriteIndexColorSpaceBegin(PSDRV_PDEVICE
*physDev
, int size
)
678 sprintf(buf
, "[/Indexed /DeviceRGB %d\n<\n", size
);
679 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
682 BOOL
PSDRV_WriteIndexColorSpaceEnd(PSDRV_PDEVICE
*physDev
)
684 static const char buf
[] = ">\n] setcolorspace\n";
685 return PSDRV_WriteSpool(physDev
, buf
, sizeof(buf
) - 1);
688 BOOL
PSDRV_WriteRGB(PSDRV_PDEVICE
*physDev
, COLORREF
*map
, int number
)
690 char *buf
= HeapAlloc(PSDRV_Heap
, 0, number
* 7 + 1), *ptr
;
694 for(i
= 0; i
< number
; i
++) {
695 sprintf(ptr
, "%02x%02x%02x%c", (int)GetRValue(map
[i
]),
696 (int)GetGValue(map
[i
]), (int)GetBValue(map
[i
]),
697 ((i
& 0x7) == 0x7) || (i
== number
- 1) ? '\n' : ' ');
700 PSDRV_WriteSpool(physDev
, buf
, number
* 7);
701 HeapFree(PSDRV_Heap
, 0, buf
);
705 static BOOL
PSDRV_WriteImageDict(PSDRV_PDEVICE
*physDev
, WORD depth
,
706 INT widthSrc
, INT heightSrc
, char *bits
)
708 static const char start
[] = "<<\n"
709 " /ImageType 1\n /Width %d\n /Height %d\n /BitsPerComponent %d\n"
710 " /ImageMatrix [%d 0 0 %d 0 %d]\n";
712 static const char decode1
[] = " /Decode [0 %d]\n";
713 static const char decode3
[] = " /Decode [0 1 0 1 0 1]\n";
715 static const char end
[] = " /DataSource currentfile /ASCII85Decode filter /RunLengthDecode filter\n>>\n";
716 static const char endbits
[] = " /DataSource <%s>\n>>\n";
718 char *buf
= HeapAlloc(PSDRV_Heap
, 0, 1000);
720 sprintf(buf
, start
, widthSrc
, heightSrc
,
721 (depth
< 8) ? depth
: 8, widthSrc
, -heightSrc
, heightSrc
);
723 PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
727 sprintf(buf
, decode1
, 255);
731 sprintf(buf
, decode1
, 15);
735 sprintf(buf
, decode1
, 1);
739 strcpy(buf
, decode3
);
743 PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
746 PSDRV_WriteSpool(physDev
, end
, sizeof(end
) - 1);
748 sprintf(buf
, endbits
, bits
);
749 PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
752 HeapFree(PSDRV_Heap
, 0, buf
);
756 BOOL
PSDRV_WriteImage(PSDRV_PDEVICE
*physDev
, WORD depth
, INT xDst
, INT yDst
,
757 INT widthDst
, INT heightDst
, INT widthSrc
,
758 INT heightSrc
, BOOL mask
)
760 static const char start
[] = "%d %d translate\n%d %d scale\n";
761 static const char image
[] = "image\n";
762 static const char imagemask
[] = "imagemask\n";
765 sprintf(buf
, start
, xDst
, yDst
, widthDst
, heightDst
);
766 PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
767 PSDRV_WriteImageDict(physDev
, depth
, widthSrc
, heightSrc
, NULL
);
769 PSDRV_WriteSpool(physDev
, imagemask
, sizeof(imagemask
) - 1);
771 PSDRV_WriteSpool(physDev
, image
, sizeof(image
) - 1);
776 BOOL
PSDRV_WriteBytes(PSDRV_PDEVICE
*physDev
, const BYTE
*bytes
, DWORD number
)
778 char *buf
= HeapAlloc(PSDRV_Heap
, 0, number
* 3 + 1);
784 for(i
= 0; i
< number
; i
++) {
785 sprintf(ptr
, "%02x", bytes
[i
]);
787 if(((i
& 0xf) == 0xf) || (i
== number
- 1)) {
792 PSDRV_WriteSpool(physDev
, buf
, ptr
- buf
);
793 HeapFree(PSDRV_Heap
, 0, buf
);
797 BOOL
PSDRV_WriteData(PSDRV_PDEVICE
*physDev
, const BYTE
*data
, DWORD number
)
799 int num
, num_left
= number
;
802 num
= min(num_left
, 60);
803 PSDRV_WriteSpool(physDev
, (LPCSTR
)data
, num
);
804 PSDRV_WriteSpool(physDev
, "\n", 1);
812 BOOL
PSDRV_WriteArrayGet(PSDRV_PDEVICE
*physDev
, CHAR
*pszArrayName
, INT nIndex
)
816 sprintf(buf
, psarrayget
, pszArrayName
, nIndex
);
817 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
820 BOOL
PSDRV_WriteArrayPut(PSDRV_PDEVICE
*physDev
, CHAR
*pszArrayName
, INT nIndex
, LONG lObject
)
824 sprintf(buf
, psarrayput
, pszArrayName
, nIndex
, lObject
);
825 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
828 BOOL
PSDRV_WriteArrayDef(PSDRV_PDEVICE
*physDev
, CHAR
*pszArrayName
, INT nSize
)
832 sprintf(buf
, psarraydef
, pszArrayName
, nSize
);
833 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
836 BOOL
PSDRV_WriteRectClip(PSDRV_PDEVICE
*physDev
, INT x
, INT y
, INT w
, INT h
)
840 sprintf(buf
, psrectclip
, x
, y
, w
, h
);
841 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
844 BOOL
PSDRV_WriteRectClip2(PSDRV_PDEVICE
*physDev
, CHAR
*pszArrayName
)
848 sprintf(buf
, psrectclip2
, pszArrayName
);
849 return PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
852 BOOL
PSDRV_WritePatternDict(PSDRV_PDEVICE
*physDev
, BITMAP
*bm
, BYTE
*bits
)
854 static const char mypat
[] = "/mypat\n";
855 static const char do_pattern
[] = "<<\n /PaintType 1\n /PatternType 1\n /TilingType 1\n "
856 "/BBox [0 0 %d %d]\n /XStep %d\n /YStep %d\n /PaintProc {\n begin\n 0 0 translate\n"
857 " %d %d scale\n mypat image\n end\n }\n>>\n matrix makepattern setpattern\n";
860 INT w
, h
, x
, y
, w_mult
, h_mult
;
863 w
= bm
->bmWidth
& ~0x7;
864 h
= bm
->bmHeight
& ~0x7;
866 buf
= HeapAlloc(PSDRV_Heap
, 0, sizeof(do_pattern
) + 100);
868 for(y
= h
-1; y
>= 0; y
--) {
869 for(x
= 0; x
< w
/8; x
++) {
870 sprintf(ptr
, "%02x", *(bits
+ x
/8 + y
* bm
->bmWidthBytes
));
874 PSDRV_WriteSpool(physDev
, mypat
, sizeof(mypat
) - 1);
875 PSDRV_WriteImageDict(physDev
, 1, 8, 8, buf
);
876 PSDRV_WriteSpool(physDev
, "def\n", 4);
878 PSDRV_WriteIndexColorSpaceBegin(physDev
, 1);
879 map
[0] = GetTextColor( physDev
->hdc
);
880 map
[1] = GetBkColor( physDev
->hdc
);
881 PSDRV_WriteRGB(physDev
, map
, 2);
882 PSDRV_WriteIndexColorSpaceEnd(physDev
);
884 /* Windows seems to scale patterns so that a one pixel corresponds to 1/300" */
885 w_mult
= (physDev
->logPixelsX
+ 150) / 300;
886 h_mult
= (physDev
->logPixelsY
+ 150) / 300;
887 sprintf(buf
, do_pattern
, w
* w_mult
, h
* h_mult
, w
* w_mult
, h
* h_mult
, w
* w_mult
, h
* h_mult
);
888 PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
890 HeapFree(PSDRV_Heap
, 0, buf
);
894 BOOL
PSDRV_WriteDIBPatternDict(PSDRV_PDEVICE
*physDev
, BITMAPINFO
*bmi
, UINT usage
)
896 static const char mypat
[] = "/mypat\n";
897 static const char do_pattern
[] = "<<\n /PaintType 1\n /PatternType 1\n /TilingType 1\n "
898 "/BBox [0 0 %d %d]\n /XStep %d\n /YStep %d\n /PaintProc {\n begin\n 0 0 translate\n"
899 " %d %d scale\n mypat image\n end\n }\n>>\n matrix makepattern setpattern\n";
902 INT w
, h
, x
, y
, colours
, w_mult
, h_mult
;
905 if(bmi
->bmiHeader
.biBitCount
!= 1) {
906 FIXME("dib depth %d not supported\n", bmi
->bmiHeader
.biBitCount
);
910 bits
= (LPBYTE
)bmi
+ bmi
->bmiHeader
.biSize
;
911 colours
= bmi
->bmiHeader
.biClrUsed
;
912 if (colours
> 256) colours
= 256;
913 if(!colours
&& bmi
->bmiHeader
.biBitCount
<= 8)
914 colours
= 1 << bmi
->bmiHeader
.biBitCount
;
915 bits
+= colours
* ((usage
== DIB_RGB_COLORS
) ?
916 sizeof(RGBQUAD
) : sizeof(WORD
));
918 w
= bmi
->bmiHeader
.biWidth
& ~0x7;
919 h
= bmi
->bmiHeader
.biHeight
& ~0x7;
921 buf
= HeapAlloc(PSDRV_Heap
, 0, sizeof(do_pattern
) + 100);
923 for(y
= h
-1; y
>= 0; y
--) {
924 for(x
= 0; x
< w
/8; x
++) {
925 sprintf(ptr
, "%02x", *(bits
+ x
/8 + y
*
926 (bmi
->bmiHeader
.biWidth
+ 31) / 32 * 4));
930 PSDRV_WriteSpool(physDev
, mypat
, sizeof(mypat
) - 1);
931 PSDRV_WriteImageDict(physDev
, 1, 8, 8, buf
);
932 PSDRV_WriteSpool(physDev
, "def\n", 4);
934 PSDRV_WriteIndexColorSpaceBegin(physDev
, 1);
935 map
[0] = GetTextColor( physDev
->hdc
);
936 map
[1] = GetBkColor( physDev
->hdc
);
937 PSDRV_WriteRGB(physDev
, map
, 2);
938 PSDRV_WriteIndexColorSpaceEnd(physDev
);
940 /* Windows seems to scale patterns so that a one pixel corresponds to 1/300" */
941 w_mult
= (physDev
->logPixelsX
+ 150) / 300;
942 h_mult
= (physDev
->logPixelsY
+ 150) / 300;
943 sprintf(buf
, do_pattern
, w
* w_mult
, h
* h_mult
, w
* w_mult
, h
* h_mult
, w
* w_mult
, h
* h_mult
);
944 PSDRV_WriteSpool(physDev
, buf
, strlen(buf
));
945 HeapFree(PSDRV_Heap
, 0, buf
);