![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitblt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / print / pscript|
Return to bitblt.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 root 1: //--------------------------------------------------------------------------
2: //
3: // Module Name: BITBLT.C
4: //
5: // Brief Description: This module contains the PSCRIPT driver's BitBlt
6: // functions and related routines.
7: //
8: // Author: Kent Settle (kentse)
9: // Created: 03-Dec-1990
10: //
11: // 26-Mar-1992 Thu 23:54:07 updated -by- Daniel Chou (danielc)
12: // 1) add the prclBound parameter to the bDoClipObj()
13: // 2) Remove 'pco' parameter and replaced it with prclClipBound parameter,
14: // since pco is never referenced, prclClipBound is used for the
15: // halftone.
16: // 3) Add another parameter to do NOTSRCCOPY
17: //
18: // 11-Feb-1993 Thu 21:32:07 updated -by- Daniel Chou (danielc)
19: // Major re-write to have DrvStretchBlt(), DrvCopyBits() do the right
20: // things.
21: //
22: // Copyright (c) 1990-1992 Microsoft Corporation
23: //
24: // This module contains DrvBitBlt, DrvStretchBlt and related routines.
25: //--------------------------------------------------------------------------
26:
27: #include "stdlib.h"
28: #include "pscript.h"
29: #include "enable.h"
30: #include "halftone.h"
31:
32: extern VOID vHexOut(PDEVDATA, PBYTE, LONG);
33: extern BOOL bDoClipObj(PDEVDATA, CLIPOBJ *, RECTL *, RECTL *, BOOL *, BOOL *, DWORD);
34: extern SHORT PSBitMapType(PDEVDATA pdev, BOOL BinaryClearChannel);
35:
36: #ifdef INDEX_PAL
37: extern ULONG PSMonoPalette[];
38: extern ULONG PSColorPalette[];
39: #endif
40:
41: #if DBG
42: BOOL DbgPSBitBlt = 0;
43: #endif
44:
45: #define PRINT_TOPDOWN 0x02
46: #define PRINT_SRCAND 0x04
47:
48: #define SWAP(a,b,tmp) tmp=a; a=b; b=tmp
49:
50:
51: #define PAL_MIN_I 0x00
52: #define PAL_MAX_I 0xff
53:
54: #define HTXB_R(htxb) htxb.b4.b1st
55: #define HTXB_G(htxb) htxb.b4.b2nd
56: #define HTXB_B(htxb) htxb.b4.b3rd
57: #define HTXB_I(htxb) htxb.b4.b4th
58:
59: #define SRC8PELS_TO_3P_DW(dwRet,pHTXB,pSrc8Pels) \
60: (dwRet) = (DWORD)((pHTXB[pSrc8Pels->b4.b1st].dw & (DWORD)0xc0c0c0c0) | \
61: (pHTXB[pSrc8Pels->b4.b2nd].dw & (DWORD)0x30303030) | \
62: (pHTXB[pSrc8Pels->b4.b3rd].dw & (DWORD)0x0c0c0c0c) | \
63: (pHTXB[pSrc8Pels->b4.b4th].dw & (DWORD)0x03030303)); \
64: ++pSrc8Pels
65:
66: #define INTENSITY(r,g,b) (BYTE)(((WORD)((r)*30) + (WORD)((g)*59) + (WORD)((b)*11))/100)
67:
68: //
69: // declarations of routines residing within this module.
70: //
71:
72: VOID
73: BeginImage(
74: PDEVDATA pdev,
75: BOOL Mono,
76: int x,
77: int y,
78: int cx,
79: int cy,
80: int cxBytes
81: );
82:
83: BOOL DoPatCopy(PDEVDATA, SURFOBJ *, PRECTL, BRUSHOBJ *, PPOINTL, ROP4, BOOL);
84:
85: BOOL
86: HalftoneBlt(
87: PDEVDATA pdev,
88: SURFOBJ *psoDest,
89: SURFOBJ *psoSrc,
90: SURFOBJ *psoMask,
91: CLIPOBJ *pco,
92: XLATEOBJ *pxlo,
93: COLORADJUSTMENT *pca,
94: POINTL *pptlBrushOrg,
95: PRECTL prclDest,
96: PRECTL prclSrc,
97: PPOINTL pptlMask,
98: BOOL NotSrcCopy
99: );
100:
101: BOOL
102: IsHTCompatibleSurfObj(
103: PDEVDATA pdev,
104: SURFOBJ *pso,
105: XLATEOBJ *pxlo
106: );
107:
108: BOOL
109: OutputHTCompatibleBits(
110: PDEVDATA pdev,
111: SURFOBJ *psoHT,
112: CLIPOBJ *pco,
113: DWORD xDest,
114: DWORD yDest
115: );
116:
117:
118: BOOL BeginImageEx(
119: PDEVDATA pdev,
120: SIZEL sizlSrc,
121: ULONG ulSrcFormat,
122: DWORD cbSrcWidth,
123: PRECTL prclDest,
124: BOOL bNotSrcCopy,
125: XLATEOBJ *pxlo);
126:
127: BOOL DoSourceCopy(
128: PDEVDATA pdev,
129: SURFOBJ *psoSrc,
130: PRECTL prclSrc,
131: PRECTL prclDest,
132: XLATEOBJ *pxlo,
133: RECTL *prclClipBound,
134: BOOL bNotSrcCopy);
135:
136: //
137: //********** Code start here
138: //
139:
140:
141:
142:
143:
144: BOOL
145: HalftoneBlt(
146: PDEVDATA pdev,
147: SURFOBJ *psoDest,
148: SURFOBJ *psoSrc,
149: SURFOBJ *psoMask,
150: CLIPOBJ *pco,
151: XLATEOBJ *pxlo,
152: COLORADJUSTMENT *pca,
153: POINTL *pptlBrushOrg,
154: PRECTL prclDest,
155: PRECTL prclSrc,
156: PPOINTL pptlMask,
157: BOOL NotSrcCopy
158: )
159:
160: /*++
161:
162: Routine Description:
163:
164: This function blt the soruces bitmap using halftone mode
165:
166: Arguments:
167:
168: Same as DrvStretchBlt() except pdev and NotSrcCopy flag
169:
170:
171: Return Value:
172:
173: BOOLEAN
174:
175:
176: Author:
177:
178: 17-Feb-1993 Wed 21:31:24 created -by- Daniel Chou (danielc)
179:
180:
181: Revision History:
182:
183:
184: --*/
185:
186: {
187: PDRVHTINFO pDrvHTInfo;
188: POINTL ZeroOrigin = {0, 0};
189: BOOL Ok;
190:
191:
192:
193: if (!(pDrvHTInfo = (PDRVHTINFO)(pdev->pvDrvHTData))) {
194:
195: DbgPrint("\nPSCRIPT!HalftoneBlt: pDrvHTInfo = NULL ???\n");
196: return(FALSE);
197: }
198:
199: if (pDrvHTInfo->Flags & DHIF_IN_STRETCHBLT) {
200:
201: #if DBG
202: DbgPrint("\nPSCRIPT!HalftoneBlt: EngStretchBlt() RECURSIVE CALLS NOT ALLOWED!!!\n");
203: #endif
204: return(FALSE);
205: }
206:
207: //
208: // Setup these data before calling EngStretchBlt(), these are used at later
209: // DrvCopyBits() call
210: //
211:
212: pDrvHTInfo->Flags |= DHIF_IN_STRETCHBLT;
213: pDrvHTInfo->HTPalXor = (NotSrcCopy) ? HTPALXOR_NOTSRCCOPY :
214: HTPALXOR_SRCCOPY;
215:
216: if (!pptlBrushOrg) {
217:
218: pptlBrushOrg = &ZeroOrigin;
219: }
220:
221: if (!pca) {
222:
223: pca = &(pDrvHTInfo->ca);
224: }
225:
226: #if DBG
227: if (DbgPSBitBlt) {
228:
229: if (pco) {
230:
231: DbgPrint("\nPSCRIPT!HalftoneBlt: CLIP: Complex=%ld",
232: (DWORD)pco->iDComplexity);
233: DbgPrint("\nClip rclBounds = (%ld, %ld) - (%ld, %ld)",
234: pco->rclBounds.left,
235: pco->rclBounds.top,
236: pco->rclBounds.right,
237: pco->rclBounds.bottom);
238: } else {
239:
240: DbgPrint("\nPSCRIPT!HalftoneBlt: pco = NULL\n");
241: }
242: }
243: #endif
244:
245: if (!(Ok = EngStretchBlt(psoDest, // Dest
246: psoSrc, // SRC
247: psoMask, // MASK
248: pco, // CLIPOBJ
249: pxlo, // XLATEOBJ
250: pca, // COLORADJUSTMENT
251: pptlBrushOrg, // BRUSH ORG
252: prclDest, // DEST RECT
253: prclSrc, // SRC RECT
254: pptlMask, // MASK POINT
255: HALFTONE))) { // HALFTONE MODE
256: #if DBG
257: DbgPrint("\nPSCRIPT!HalftoneBlt: EngStretchBlt(HALFTONE) Failed\n");
258: #endif
259: }
260:
261: //
262: // Clear These before we return
263: //
264:
265: pDrvHTInfo->HTPalXor = HTPALXOR_SRCCOPY;
266: pDrvHTInfo->Flags &= ~DHIF_IN_STRETCHBLT;
267:
268: return(Ok);
269:
270: }
271:
272:
273:
274:
275: BOOL
276: IsHTCompatibleSurfObj(
277: PDEVDATA pdev,
278: SURFOBJ *pso,
279: XLATEOBJ *pxlo
280: )
281:
282: /*++
283:
284: Routine Description:
285:
286: This function determine if the surface obj is compatble with postscript
287: halftone output format.
288:
289: Arguments:
290:
291: pdev - Pointer to the PDEVDATA data structure to determine what
292: type of postscript output for current device
293:
294: pso - engine SURFOBJ to be examine
295:
296: pxlo - engine XLATEOBJ for source -> postscript translation
297:
298: Return Value:
299:
300: BOOLEAN true if the pso is compatible with halftone output format, if
301: return value is true, the pDrvHTInfo->pHTXB is a valid trnaslation from
302: indices to 3 planes
303:
304: Author:
305:
306: 11-Feb-1993 Thu 18:49:55 created -by- Daniel Chou (danielc)
307:
308:
309: Revision History:
310:
311:
312: --*/
313:
314: {
315: #ifdef INDEX_PAL
316: PALETTEENTRY *prgb;
317: PALETTEENTRY *ppalette;
318: ULONG *pulColors;
319: #else
320: BGR_PAL_ENTRY *pbgr;
321: #endif
322: PDRVHTINFO pDrvHTInfo;
323: UINT BmpFormat;
324: UINT cPal;
325:
326: if (!(pDrvHTInfo = (PDRVHTINFO)(pdev->pvDrvHTData))) {
327:
328: DbgPrint("\nPSCRIPT!IsHTCompatibleSurfObj: pDrvHTInfo = NULL ???\n");
329: return(FALSE);
330: }
331:
332: #if DBG
333: if (DbgPSBitBlt) {
334:
335: DbgPrint("\n** IsHTCompatibleSurfObj **");
336: DbgPrint("\niType=%ld, BmpFormat=%ld",
337: (DWORD)pso->iType,
338: (DWORD)pso->iBitmapFormat);
339:
340: if (pxlo) {
341:
342: DbgPrint("\npxlo: flXlate=%08lx, cPal=%ld, pulXlate=%08lx",
343: (DWORD)pxlo->flXlate,
344: (DWORD)pxlo->cEntries,
345: (DWORD)pxlo->pulXlate);
346: } else {
347:
348: DbgPrint("\npxlo = NULL");
349: }
350: }
351: #endif
352:
353: //
354: // Make sure these fields' value are valid before create translation
355: //
356: // 1. pso->iBitmapFormat is one of 1BPP or 4BPP depends on current
357: // pscript's surface
358: // 2. pxlo is non null
359: // 3. pxlo->fXlate is XO_TABLE
360: // 4. pxlo->cPal is less or equal to the halftone palette count
361: // 5. pxlo->pulXlate is valid
362: // 6. source color table is within the range of halftone palette
363: //
364:
365: #if DBG
366: if (DbgPSBitBlt) {
367:
368: DbgPrint("\npso->iType = %x, pso->iBitmapFormat = %x.\n",
369: pso->iType, pso->iBitmapFormat);
370: DbgPrint("pDrvHTInfo->HTBmpFormat = %x.\n",
371: pDrvHTInfo->HTBmpFormat);
372: DbgPrint("pDrvHTInfo->AltBmpFormat = %x, pxlo = %x.\n",
373: pDrvHTInfo->AltBmpFormat, pxlo);
374: DbgPrint("pxlo->flXlate = %x, pxlo->cEntries = %d.\n",
375: pxlo->flXlate, pxlo->cEntries);
376: DbgPrint("pxlo->pulXlate = %x.\n", pxlo->pulXlate);
377: }
378: #endif
379:
380: if ((pso->iType == STYPE_BITMAP) &&
381: (((BmpFormat = (UINT)pso->iBitmapFormat) ==
382: (UINT)pDrvHTInfo->HTBmpFormat) ||
383: (BmpFormat == (UINT)pDrvHTInfo->AltBmpFormat)) &&
384: (pxlo) &&
385: #ifdef INDEX_PAL
386: ((pxlo->flXlate & XO_TRIVIAL) ||
387: ((pxlo->flXlate & XO_TABLE) &&
388: #else
389: (pxlo->flXlate & XO_TABLE) &&
390: #endif
391: ((cPal = (UINT)pxlo->cEntries) <= (UINT)pDrvHTInfo->HTPalCount) &&
392: #ifdef INDEX_PAL
393: (ppalette = (PALETTEENTRY *)pxlo->pulXlate)))) {
394: #else
395: (pbgr = (BGR_PAL_ENTRY *)pxlo->pulXlate)) {
396: #endif
397:
398:
399: ULONG HTPalXor;
400: UINT i;
401: HTXB htXB;
402: HTXB PalNibble[HTPAL_XLATE_COUNT];
403: BOOL GenHTXB = FALSE;
404: BYTE PalXlate[HTPAL_XLATE_COUNT];
405:
406:
407: HTPalXor = pDrvHTInfo->HTPalXor;
408: pDrvHTInfo->HTPalXor = HTPALXOR_SRCCOPY;
409:
410: #if DBG
411: if (DbgPSBitBlt) {
412:
413: DbgPrint("\nHTPalXor=%08lx", HTPalXor);
414: }
415: #endif
416:
417: #ifdef INDEX_PAL
418: // if the TRIVIAL color translation flag is set, then fill in
419: // halftoning palette from our hardcoded palettes.
420:
421: if (BmpFormat == (UINT)BMF_1BPP) {
422:
423: pulColors = PSMonoPalette;
424:
425: } else {
426:
427: pulColors = PSColorPalette;
428: }
429:
430: if (pxlo->flXlate & XO_TRIVIAL) {
431:
432: if (BmpFormat == (UINT)BMF_1BPP) {
433:
434: cPal = 2;
435: ppalette = (PALETTEENTRY *)PSMonoPalette;
436:
437: } else {
438:
439: cPal = 8;
440: ppalette = (PALETTEENTRY *)PSColorPalette;
441: }
442: }
443:
444: for (i = 0; i < cPal; i++, ppalette++) {
445:
446: if (pxlo->flXlate & XO_TRIVIAL) {
447:
448: prgb = ppalette;
449: }
450:
451: else if (pxlo->flXlate & XO_TABLE) {
452:
453: if (BmpFormat == BMF_24BPP) {
454:
455: prgb = ppalette;
456:
457: } else {
458:
459: prgb = (PALETTEENTRY *)(pulColors +
460: XLATEOBJ_iXlate(pxlo, *(ULONG *)ppalette));
461: }
462: }
463:
464: HTXB_R(htXB) = prgb->peRed;
465: HTXB_G(htXB) = prgb->peGreen;
466: HTXB_B(htXB) = prgb->peBlue;
467: #else
468: for (i = 0; i < cPal; i++, pbgr++) {
469:
470: HTXB_R(htXB) = pbgr->bgrRed;
471: HTXB_G(htXB) = pbgr->bgrGreen;
472: HTXB_B(htXB) = pbgr->bgrBlue;
473: #endif
474: htXB.dw ^= HTPalXor;
475:
476:
477: if (((HTXB_R(htXB) != PAL_MAX_I) &&
478: (HTXB_R(htXB) != PAL_MIN_I)) ||
479: ((HTXB_G(htXB) != PAL_MAX_I) &&
480: (HTXB_G(htXB) != PAL_MIN_I)) ||
481: ((HTXB_B(htXB) != PAL_MAX_I) &&
482: (HTXB_B(htXB) != PAL_MIN_I))) {
483:
484: #if DBG
485: if (DbgPSBitBlt) {
486:
487: DbgPrint("\nSrcPal has NON 0xff/0x00 intensity, NOT HTPalette");
488: }
489: #endif
490: return(FALSE);
491: }
492:
493: PalXlate[i] =
494: HTXB_I(htXB) = (BYTE)((HTXB_R(htXB) & 0x01) |
495: (HTXB_G(htXB) & 0x02) |
496: (HTXB_B(htXB) & 0x04));
497: PalNibble[i] = htXB;
498:
499: if (pDrvHTInfo->PalXlate[i] != HTXB_I(htXB)) {
500:
501: GenHTXB = TRUE;
502: }
503:
504: #if DBG
505: if (DbgPSBitBlt) {
506:
507: DbgPrint("\n%d - %02x:%02x:%02x -> %02x:%02x:%02x, Idx=%d, PalXlate=%d",
508: i,
509: #ifdef INDEX_PAL
510: (BYTE)prgb->peRed,
511: (BYTE)prgb->peGreen,
512: (BYTE)prgb->peBlue,
513: #else
514: (BYTE)pbgr->bgrRed,
515: (BYTE)pbgr->bgrGreen,
516: (BYTE)pbgr->bgrBlue,
517: #endif
518: (BYTE)HTXB_R(htXB),
519: (BYTE)HTXB_G(htXB),
520: (BYTE)HTXB_B(htXB),
521: (INT)PalXlate[i],
522: (INT)pDrvHTInfo->PalXlate[i]);
523: }
524: #endif
525: }
526:
527: if (BmpFormat == (UINT)BMF_1BPP) {
528:
529: if (((PalXlate[0] != 0) && (PalXlate[0] != 7)) ||
530: ((PalXlate[1] != 0) && (PalXlate[1] != 7))) {
531:
532: #if DBG
533: if (DbgPSBitBlt) {
534:
535: DbgPrint("\nNON-BLACK/WHITE MONO BITMAP, NOT HTPalette");
536: }
537: #endif
538: return(FALSE);
539: }
540: }
541:
542: if (GenHTXB) {
543:
544: //
545: // Copy down the pal xlate
546: //
547:
548: #if DBG
549: if (DbgPSBitBlt) {
550:
551: DbgPrint("\n --- Copy XLATE TABLE ---");
552: }
553: #endif
554:
555: CopyMemory(pDrvHTInfo->PalXlate, PalXlate, sizeof(PalXlate));
556:
557: //
558: // We only really generate 4bpp to 3 planes if the destination
559: // format is BMF_4BPP
560: //
561:
562: if (BmpFormat == (UINT)BMF_4BPP) {
563:
564: PHTXB pTmpHTXB;
565: UINT h;
566: UINT l;
567: DWORD HighNibble;
568:
569: #if DBG
570: if (DbgPSBitBlt) {
571:
572: DbgPrint("\n --- Generate 4bpp --> 3 planes xlate ---");
573: }
574: #endif
575:
576: if (!(pDrvHTInfo->pHTXB)) {
577:
578: RIP("PSCRIPT!IsHTCompatibleSurfObj: NULL pDrvHTInfo->pHTXB\n");
579:
580: if (!(pDrvHTInfo->pHTXB = (PHTXB)
581: HeapAlloc(pdev->hheap, 0, HTXB_TABLE_SIZE))) {
582:
583: RIP("PSCRIPT!IsHTCompatibleSurfObj: HeapAlloc(HTXB_TABLE_SIZE) failed\n");
584: return(FALSE);
585: }
586: }
587:
588: //
589: // Generate 4bpp to 3 planes xlate table
590: //
591:
592: for (h = 0, pTmpHTXB = pDrvHTInfo->pHTXB;
593: h < HTXB_H_NIBBLE_MAX;
594: h++, pTmpHTXB += HTXB_L_NIBBLE_DUP) {
595:
596: HighNibble = (DWORD)(PalNibble[h].dw & 0xaaaaaaaaL);
597:
598: for (l = 0; l < HTXB_L_NIBBLE_MAX; l++, pTmpHTXB++) {
599:
600: pTmpHTXB->dw = (DWORD)((HighNibble) |
601: (PalNibble[l].dw & 0x55555555L));
602: }
603:
604: //
605: // Duplicate low nibble high order bit, 8 of them
606: //
607:
608: CopyMemory(pTmpHTXB,
609: pTmpHTXB - HTXB_L_NIBBLE_MAX,
610: sizeof(HTXB) * HTXB_L_NIBBLE_DUP);
611: }
612:
613: //
614: // Copy high nibble duplication, 128 of them
615: //
616:
617: CopyMemory(pTmpHTXB,
618: pDrvHTInfo->pHTXB,
619: sizeof(HTXB) * HTXB_H_NIBBLE_DUP);
620: }
621: }
622:
623: #if DBG
624: if (DbgPSBitBlt) {
625:
626: DbgPrint("\n******* IsHTCompatibleSurfObj = YES *******");
627: }
628: #endif
629:
630: return(TRUE);
631:
632: } else {
633:
634: return(FALSE);
635: }
636: }
637:
638:
639:
640:
641: BOOL
642: OutputHTCompatibleBits(
643: PDEVDATA pdev,
644: SURFOBJ *psoHT,
645: CLIPOBJ *pco,
646: DWORD xDest,
647: DWORD yDest
648: )
649:
650: /*++
651:
652: Routine Description:
653:
654: This function output a compatible halftoned surface to the pscript device
655:
656: Arguments:
657:
658:
659: pdev - Pointer to the PDEVDATA data structure to determine what
660: type of postscript output for current device
661:
662: pso - engine SURFOBJ to be examine
663:
664: psoHT - compatible halftoned surface object
665:
666: xDest - the X bitmap start on the destination
667:
668: yDest - the Y bitmap start on the destination
669:
670: Return Value:
671:
672: BOOLEAN if function sucessful, failed if cannot allocate memory to do
673: the otuput.
674:
675: Author:
676:
677: 09-Feb-1993 Tue 20:45:37 created -by- Daniel Chou (danielc)
678:
679:
680: Revision History:
681:
682:
683: --*/
684:
685: {
686: PDRVHTINFO pDrvHTInfo;
687: LPBYTE pbHTBits;
688: LPBYTE pbOutput;
689: SIZEL SizeBlt;
690: RECTL rclBounds;
691: LONG cbToNextScan;
692: DWORD AllocSize;
693: DWORD cxDestBytes;
694: DWORD cxDestDW;
695: DWORD xLoop;
696: DWORD yLoop;
697: BOOL Mono;
698: BOOL bMoreClipping;
699: BOOL bFirstClipPass;
700: DWORD dwBlack = RGB_BLACK;
701:
702: pDrvHTInfo = (PDRVHTINFO)(pdev->pvDrvHTData);
703: SizeBlt = psoHT->sizlBitmap;
704: cxDestBytes = (DWORD)((SizeBlt.cx + 7) >> 3);
705:
706: if (Mono = (BOOL)(psoHT->iBitmapFormat == BMF_1BPP)) {
707:
708: //
709: // Our 1bpp bit 0 is BLACK, so if it is a WHITE then allocate memory
710: // and flip the outcome
711: //
712:
713: if (pDrvHTInfo->PalXlate[0]) {
714:
715: cxDestDW = (DWORD)((cxDestBytes + 3) >> 2);
716: AllocSize = cxDestDW * sizeof(DWORD);
717:
718: #if DBG
719: if (DbgPSBitBlt) {
720:
721: DbgPrint("\nOutputHTCompatibleBits: MONO -- INVERT");
722: }
723: #endif
724:
725: } else {
726:
727: #if DBG
728: if (DbgPSBitBlt) {
729:
730: DbgPrint("\nOutputHTCompatibleBits: MONO");
731: }
732: #endif
733: AllocSize = 0;
734: }
735:
736: } else {
737:
738: #if DBG
739: if (DbgPSBitBlt) {
740:
741: DbgPrint("\nOutputHTCompatibleBits: 4 BIT --> 3 PLANES");
742: }
743: #endif
744:
745: AllocSize = (DWORD)(cxDestBytes * 3);
746: }
747:
748: if (AllocSize) {
749:
750: if (!(pbOutput = (LPBYTE)HeapAlloc(pdev->hheap, 0, AllocSize))) {
751: #if DBG
752: DbgPrint("\nOutputHTCompatibleBits: HeapAlloc(HT CopyBits Buffer) Failed\n");
753: #endif
754: return(FALSE);
755: }
756:
757: } else {
758:
759: pbOutput = NULL;
760: }
761:
762: //
763: // 1. Must clip the bitmap if 'pco' has clipping, and will send it down
764: // to the printer
765: // 2. Must do ps_save() before sending the image to the printer
766:
767: #if DBG
768: if (DbgPSBitBlt) {
769:
770: DbgPrint("\nOutputHTCompatibleBits: pco = %08lx", (DWORD)pco);
771: }
772: #endif
773:
774: bMoreClipping = TRUE;
775: bFirstClipPass = TRUE;
776:
777: while (bMoreClipping)
778: {
779: if (pdev->dwFlags & PDEV_CANCELDOC)
780: break;
781:
782: pbHTBits = (LPBYTE)psoHT->pvScan0;
783:
784: if ((bDoClipObj(pdev, pco, &rclBounds, NULL, &bMoreClipping,
785: &bFirstClipPass, MAX_CLIP_RECTS)) && (pco)) {
786:
787: //
788: // If clipping is send to the printer then ps_save() already done
789: // at bDoClipObj()
790: //
791:
792: #if DBG
793: if (DbgPSBitBlt) {
794:
795: DbgPrint("\nOutputHTCompatibleBits: PS_CLIP: Complex=%ld",
796: (DWORD)pco->iDComplexity);
797: DbgPrint("\nClip rclBounds = (%ld, %ld) - (%ld, %ld)",
798: rclBounds.left,
799: rclBounds.top,
800: rclBounds.right,
801: rclBounds.bottom);
802: }
803: #endif
804:
805: ps_clip(pdev, TRUE);
806:
807: } else {
808:
809: ps_save(pdev, TRUE);
810: }
811:
812: //
813: // Now we can start xlate the bits into 3 planes
814: //
815:
816: cbToNextScan = (LONG)psoHT->lDelta;
817: yLoop = (DWORD)SizeBlt.cy;
818:
819: #if DBG
820: if (DbgPSBitBlt) {
821:
822: DbgPrint("\n**** OutputHTCompatibleBits *****");
823: DbgPrint("\nSizeBlt = %ld x %ld, Left/Top = (%ld, %ld)",
824: SizeBlt.cx, SizeBlt.cy, xDest, yDest);
825: DbgPrint("\ncxDestBytes = %ld, AllocSize = %ld", cxDestBytes, AllocSize);
826:
827:
828: }
829: #endif
830: // if we are doing the SourceOr hack, then we need to output the
831: // foreground color now.
832:
833: if (pdev->dwFlags & PDEV_SOURCEORHACK)
834: #ifdef INDEX_PAL
835: ps_setrgbcolor(pdev, (PALETTEENTRY *)&dwBlack);
836: #else
837: ps_setrgbcolor(pdev, (BGR_PAL_ENTRY *)&dwBlack);
838: #endif
839: BeginImage(pdev, Mono, xDest, yDest, SizeBlt.cx, SizeBlt.cy,
840: cxDestBytes);
841:
842: // clear the flag now.
843:
844: pdev->dwFlags &= ~PDEV_SOURCEORHACK;
845:
846: if (Mono) {
847:
848: //
849: // For 1BPP we output directly from the source bitmap buffer
850: //
851:
852: if (pbOutput) {
853:
854: //
855: // We need to invert each bit, since each scan line is DW aligned
856: // we can do it in 32-bit increment
857: //
858:
859: LPDWORD pdwMonoBits;
860: LPDWORD pdwFlipBits;
861:
862: while (yLoop--) {
863:
864: pdwFlipBits = (LPDWORD)pbOutput;
865: pdwMonoBits = (LPDWORD)pbHTBits;
866: pbHTBits += cbToNextScan;
867: xLoop = cxDestDW;
868:
869: while (xLoop--) {
870:
871: *pdwFlipBits++ = (DWORD)~(*pdwMonoBits++);
872: }
873:
874: if (pdev->dwFlags & PDEV_CANCELDOC)
875: break;
876:
877: vHexOut(pdev, (PBYTE)pbOutput, cxDestBytes);
878: PrintString(pdev, "\n");
879: }
880:
881: } else {
882:
883: while (yLoop--) {
884:
885: if (pdev->dwFlags & PDEV_CANCELDOC)
886: break;
887:
888: vHexOut(pdev, pbHTBits, cxDestBytes);
889: PrintString(pdev, "\n");
890:
891: pbHTBits += cbToNextScan;
892: }
893: }
894:
895: } else {
896:
897: PHTXB pHTXB;
898: PHTXB pSrc8Pels;
899: LPBYTE pbScanR0;
900: LPBYTE pbScanG0;
901: LPBYTE pbScanB0;
902: LPBYTE pbScanR;
903: LPBYTE pbScanG;
904: LPBYTE pbScanB;
905: HTXB htXB;
906:
907:
908: pHTXB = pDrvHTInfo->pHTXB;
909: pbScanR0 = pbOutput;
910: pbScanG0 = pbScanR0 + cxDestBytes;
911: pbScanB0 = pbScanG0 + cxDestBytes;
912:
913: while (yLoop--) {
914:
915: pSrc8Pels = (PHTXB)pbHTBits;
916: pbHTBits += cbToNextScan;
917: pbScanR = pbScanR0;
918: pbScanG = pbScanG0;
919: pbScanB = pbScanB0;
920: xLoop = cxDestBytes;
921:
922: while (xLoop--) {
923:
924: SRC8PELS_TO_3P_DW(htXB.dw, pHTXB, pSrc8Pels);
925:
926: *pbScanR++ = HTXB_R(htXB);
927: *pbScanG++ = HTXB_G(htXB);
928: *pbScanB++ = HTXB_B(htXB);
929: }
930:
931: if (pdev->dwFlags & PDEV_CANCELDOC)
932: break;
933:
934: vHexOut(pdev, pbScanR0, cxDestBytes);
935: PrintString(pdev, "\n");
936:
937: vHexOut(pdev, pbScanG0, cxDestBytes);
938: PrintString(pdev, "\n");
939:
940: vHexOut(pdev, pbScanB0, cxDestBytes);
941: PrintString(pdev, "\n");
942: }
943: }
944:
945: //
946: // After ps_save() we better have ps_restore() to match it
947: //
948:
949: ps_restore(pdev, TRUE);
950: }
951:
952: //
953: // Release scan line buffers if we did allocate one
954: //
955:
956: if (pbOutput) {
957:
958: HeapFree(pdev->hheap, 0, (PVOID)pbOutput);
959: }
960:
961: return(TRUE);
962: }
963:
964:
965:
966:
967: BOOL
968: DrvCopyBits(
969: SURFOBJ *psoDest,
970: SURFOBJ *psoSrc,
971: CLIPOBJ *pco,
972: XLATEOBJ *pxlo,
973: RECTL *prclDest,
974: POINTL *pptlSrc
975: )
976:
977: /*++
978:
979: Routine Description:
980:
981: Convert between two bitmap formats
982:
983: Arguments:
984:
985: Per Engine spec.
986:
987: Return Value:
988:
989: BOOLEAN
990:
991:
992: Author:
993:
994: 11-Feb-1993 Thu 21:00:43 created -by- Daniel Chou (danielc)
995:
996:
997: Revision History:
998:
999:
1000: --*/
1001:
1002: {
1003: PDEVDATA pdev;
1004: RECTL rclSrc;
1005: RECTL rclDest;
1006: RECTL rclClip;
1007: PRECTL prclClip;
1008: BOOL bClipping;
1009: BOOL bMoreClipping;
1010: BOOL bFirstClipPass;
1011:
1012: //
1013: // The DrvCopyBits() function let application convert between bitmap and
1014: // device format.
1015: //
1016: // BUT... for our postscript device we cannot read the printer surface
1017: // bitmap back, so tell the caller that we cannot do it if they
1018: // really called with these type of operations.
1019: //
1020:
1021: if (psoSrc->iType != STYPE_BITMAP)
1022: {
1023: return(EngEraseSurface(psoDest, prclDest, 0xffffffff));
1024: }
1025:
1026:
1027: if (psoDest->iType != STYPE_DEVICE) {
1028:
1029: //
1030: // Someone try to copy to bitmap surface, ie STYPE_BITMAP
1031: //
1032:
1033: #if DBG
1034: DbgPrint("\nPSCRIPT!DrvCopyBits: Cannot copy to NON-DEVICE destination\n");
1035: #endif
1036: SetLastError(ERROR_INVALID_PARAMETER);
1037: return(FALSE);
1038: }
1039:
1040: pdev = (PDEVDATA)psoDest->dhpdev;
1041:
1042: if (!bValidatePDEV(pdev)) {
1043:
1044: #if DBG
1045: DbgPrint("\nPSCRIPT!DrvCopyBits: Invalid PDEV for destination passed.\n");
1046: #endif
1047: SetLastError(ERROR_INVALID_PARAMETER);
1048: return(FALSE);
1049: }
1050:
1051: if (pdev->dwFlags & PDEV_PSHALFTONE)
1052: {
1053: //
1054: // Let the Postscript interpreter do the halftoning.
1055: //
1056: rclSrc.left = pptlSrc->x;
1057: rclSrc.top = pptlSrc->y;
1058: rclSrc.right = pptlSrc->x + psoSrc->sizlBitmap.cx;
1059: rclSrc.bottom = pptlSrc->y + psoSrc->sizlBitmap.cy;
1060:
1061: prclClip = &rclClip;
1062:
1063: bMoreClipping = TRUE;
1064: bFirstClipPass = TRUE;
1065:
1066: while (bMoreClipping)
1067: {
1068: if (!(bClipping = bDoClipObj(pdev, pco, &rclClip, prclDest,
1069: &bMoreClipping, &bFirstClipPass,
1070: MAX_CLIP_RECTS)))
1071: prclClip = NULL;
1072: else
1073: ps_clip(pdev, TRUE);
1074:
1075: // DoSourceCopy does not know how to use prclClip, so don't give it one.
1076: // if (!DoSourceCopy(pdev, psoSrc, &rclSrc, prclDest, pxlo, prclClip,
1077: if (!DoSourceCopy(pdev, psoSrc, &rclSrc, prclDest, pxlo, NULL,
1078: FALSE))
1079: return(FALSE);
1080:
1081: if (bClipping)
1082: ps_restore(pdev, TRUE);
1083: }
1084: }
1085: else
1086: {
1087: //
1088: // First validate everything to see if this one is the halftoned result
1089: // or compatible with halftoned result, otherwise call HalftoneBlt() to
1090: // halftone the sources then it will eventually come back to this
1091: // function to output the halftoned result.
1092: //
1093:
1094: if ((pptlSrc->x == 0) &&
1095: (pptlSrc->y == 0) &&
1096: (prclDest->left >= 0) &&
1097: (prclDest->top >= 0) &&
1098: (prclDest->right <= psoDest->sizlBitmap.cx) &&
1099: (prclDest->bottom <= psoDest->sizlBitmap.cy) &&
1100: ((prclDest->right - prclDest->left) == psoSrc->sizlBitmap.cx) &&
1101: ((prclDest->bottom - prclDest->top) == psoSrc->sizlBitmap.cy) &&
1102: (IsHTCompatibleSurfObj(pdev, psoSrc, pxlo))) {
1103:
1104: return(OutputHTCompatibleBits(pdev,
1105: psoSrc,
1106: pco,
1107: prclDest->left,
1108: prclDest->top));
1109:
1110: } else {
1111:
1112:
1113: rclDest = *prclDest;
1114: rclSrc.left = pptlSrc->x;
1115: rclSrc.top = pptlSrc->y;
1116: rclSrc.right = rclSrc.left + (rclDest.right - rclDest.left);
1117: rclSrc.bottom = rclSrc.top + (rclDest.bottom - rclDest.top);
1118:
1119: //
1120: // Validate that we only BLT the available source size
1121: //
1122:
1123: if ((rclSrc.right > psoSrc->sizlBitmap.cx) ||
1124: (rclSrc.bottom > psoSrc->sizlBitmap.cy)) {
1125:
1126: #if DBG
1127: DbgPrint("\nWARNING: PSCRIPT!DrvCopyBits: Engine passed SOURCE != DEST size, CLIP IT");
1128: #endif
1129: rclSrc.right = psoSrc->sizlBitmap.cx;
1130: rclSrc.bottom = psoSrc->sizlBitmap.cy;
1131:
1132: rclDest.right = (LONG)(rclSrc.right - rclSrc.left + rclDest.left);
1133: rclDest.bottom = (LONG)(rclSrc.bottom - rclSrc.top + rclDest.top);
1134: }
1135:
1136: #if DBG
1137: if (DbgPSBitBlt) {
1138:
1139: DbgPrint("\nDrvCopyBits CALLING HalftoneBlt().");
1140: }
1141: #endif
1142:
1143: return(HalftoneBlt(pdev,
1144: psoDest,
1145: psoSrc,
1146: NULL, // no source mask
1147: pco,
1148: pxlo,
1149: NULL, // Default color adjustment
1150: NULL, // Brush origin at (0,0)
1151: &rclDest,
1152: &rclSrc,
1153: NULL, // No source mask
1154: FALSE)); // SRCCOPY
1155: }
1156: }
1157: }
1158:
1159:
1160:
1161:
1162: BOOL
1163: DrvStretchBlt(
1164: SURFOBJ *psoDest,
1165: SURFOBJ *psoSrc,
1166: SURFOBJ *psoMask,
1167: CLIPOBJ *pco,
1168: XLATEOBJ *pxlo,
1169: COLORADJUSTMENT *pca,
1170: POINTL *pptlBrushOrg,
1171: PRECTL prclDest,
1172: PRECTL prclSrc,
1173: PPOINTL pptlMask,
1174: ULONG iMode
1175: )
1176:
1177: /*++
1178:
1179: Routine Description:
1180:
1181: This function halfotne a soource rectangle area to the destination
1182: rectangle area with options of invver source, and source masking
1183:
1184: Provides stretching Blt capabilities between any combination of device
1185: managed and GDI managed surfaces. We want the device driver to be able
1186: to write on GDI bitmaps especially when it can do halftoning. This
1187: allows us to get the same halftoning algorithm applied to GDI bitmaps
1188: and device surfaces.
1189:
1190: This function is optional. It can also be provided to handle only some
1191: kinds of stretching, for example by integer multiples. This function
1192: should return FALSE if it gets called to perform some operation it
1193: doesn't know how to do.
1194:
1195: Arguments:
1196:
1197: psoDest
1198: This is a pointer to a SURFOBJ. It identifies the surface on which
1199: to draw.
1200:
1201: psoSrc
1202: This SURFOBJ defines the source for the Blt operation. The driver
1203: must call GDI Services to find out if this is a device managed
1204: surface or a bitmap managed by GDI.
1205:
1206: psoMask
1207: This optional surface provides a mask for the source. It is defined
1208: by a logic map, i.e. a bitmap with one bit per pel.
1209:
1210: The mask is used to limit the area of the source that is copied.
1211: When a mask is provided there is an implicit rop4 of 0xCCAA, which
1212: means that the source should be copied wherever the mask is 1, but
1213: the destination should be left alone wherever the mask is 0.
1214:
1215: When this argument is NULL there is an implicit rop4 of 0xCCCC,
1216: which means that the source should be copied everywhere in the
1217: source rectangle.
1218:
1219: The mask will always be large enough to contain the source
1220: rectangle, tiling does not need to be done.
1221:
1222: pco
1223: This is a pointer to a CLIPOBJ. GDI Services are provided to
1224: enumerate the clipping region as a set of rectangles or trapezoids.
1225: This limits the area of the destination that will be modified.
1226:
1227: Whenever possible, GDI will simplify the clipping involved.
1228: However, unlike DrvBitBlt, DrvStretchBlt may be called with a
1229: single clipping rectangle. This is necessary to prevent roundoff
1230: errors in clipping the output.
1231:
1232: pxlo
1233: This is a pointer to an XLATEOBJ. It tells how color indices should
1234: be translated between the source and target surfaces.
1235:
1236: The XLATEOBJ can also be queried to find the RGB color for any source
1237: index. A high quality stretching Blt will need to interpolate colors
1238: in some cases.
1239:
1240: pca
1241: This is a pointer to COLORADJUSTMENT structure, if NULL it specified
1242: that appiclation did not set any color adjustment for this DC, and is
1243: up to the driver to provide default adjustment
1244:
1245: pptlBrushOrg
1246: Pointer to the POINT structure to specified the location where halftone
1247: brush should alignment to, if this pointer is NULL then it assume that
1248: (0, 0) as origin of the brush
1249:
1250: prclDest
1251: This RECTL defines the area in the coordinate system of the
1252: destination surface that can be modified.
1253:
1254: The rectangle is defined by two points. These points are not well
1255: ordered, i.e. the coordinates of the second point are not necessarily
1256: larger than those of the first point. The rectangle they describe
1257: does not include the lower and right edges. DrvStretchBlt will never
1258: be called with an empty destination rectangle.
1259:
1260: DrvStretchBlt can do inversions in both x and y, this happens when
1261: the destination rectangle is not well ordered.
1262:
1263: prclSrc
1264: This RECTL defines the area in the coordinate system of the source
1265: surface that will be copied. The rectangle is defined by two points,
1266: and will map onto the rectangle defined by prclDest. The points of
1267: the source rectangle are well ordered. DrvStretch will never be given
1268: an empty source rectangle.
1269:
1270: Note that the mapping to be done is defined by prclSrc and prclDest.
1271: To be precise, the given points in prclDest and prclSrc lie on
1272: integer coordinates, which we consider to correspond to pel centers.
1273: A rectangle defined by two such points should be considered a
1274: geometric rectangle with two vertices whose coordinates are the given
1275: points, but with 0.5 subtracted from each coordinate. (The POINTLs
1276: should just be considered a shorthand notation for specifying these
1277: fractional coordinate vertices.) Note thate the edges of any such
1278: rectangle never intersect a pel, but go around a set of pels. Note
1279: also that the pels that are inside the rectangle are just what you
1280: would expect for a "bottom-right exclusive" rectangle. The mapping
1281: to be done by DrvStretchBlt will map the geometric source rectangle
1282: exactly onto the geometric destination rectangle.
1283:
1284: pptlMask
1285: This POINTL specifies which pel in the given mask corresponds to
1286: the upper left pel in the source rectangle. Ignore this argument
1287: if there is no given mask.
1288:
1289:
1290: iMode
1291: This defines how source pels should be combined to get output pels.
1292: The methods SB_OR, SB_AND, and SB_IGNORE are all simple and fast.
1293: They provide compatibility for old applications, but don't produce
1294: the best looking results for color surfaces.
1295:
1296:
1297: SB_OR On a shrinking Blt the pels should be combined with an
1298: OR operation. On a stretching Blt pels should be
1299: replicated.
1300: SB_AND On a shrinking Blt the pels should be combined with an
1301: AND operation. On a stretching Blt pels should be
1302: replicated.
1303: SB_IGNORE On a shrinking Blt enough pels should be ignored so that
1304: pels don't need to be combined. On a stretching Blt pels
1305: should be replicated.
1306: SB_BLEND RGB colors of output pels should be a linear blending of
1307: the RGB colors of the pels that get mapped onto them.
1308: SB_HALFTONE The driver may use groups of pels in the output surface
1309: to best approximate the color or gray level of the input.
1310:
1311:
1312: For this function we will ignored this parameter and always output
1313: the SB_HALFTONE result
1314:
1315:
1316: Return Value:
1317:
1318:
1319: BOOLEAN
1320:
1321:
1322: Author:
1323:
1324: 11-Feb-1993 Thu 19:52:29 created -by- Daniel Chou (danielc)
1325:
1326:
1327: Revision History:
1328:
1329:
1330: --*/
1331:
1332: {
1333: PDEVDATA pdev;
1334:
1335: UNREFERENCED_PARAMETER(iMode); // we always do HALFTONE
1336:
1337: //
1338: // get the pointer to our DEVDATA structure and make sure it is ours.
1339: //
1340:
1341: pdev = (PDEVDATA)psoDest->dhpdev;
1342:
1343: if (!bValidatePDEV(pdev)) {
1344:
1345: RIP("PSCRIPT!DrvStretchBlt: invalid pdev.\n");
1346: SetLastError(ERROR_INVALID_PARAMETER);
1347: return(FALSE);
1348: }
1349:
1350: // clear the source OR hack bit.
1351:
1352: pdev->dwFlags &= ~PDEV_SOURCEORHACK;
1353:
1354: return(HalftoneBlt(pdev, // pdev
1355: psoDest, // Dest
1356: psoSrc, // SRC
1357: psoMask, // ----- psoMask
1358: pco, // CLIPOBJ
1359: pxlo, // XLATEOBJ
1360: pca, // COLORADJUSTMENT
1361: pptlBrushOrg, // BRUSH ORG
1362: prclDest, // DEST RECT
1363: prclSrc, // SRC RECT
1364: pptlMask, // ----- pptlMask
1365: FALSE)); // SrcCopy
1366: }
1367:
1368:
1369: //--------------------------------------------------------------------------
1370: // VOID DrvBitBlt(
1371: // PSURFOBJ psoTrg, // Target surface
1372: // PSURFOBJ psoSrc, // Source surface
1373: // PSURFOBJ psoMask, // Mask
1374: // PCLIPOBJ pco, // Clip through this
1375: // PXLATEOBJ pxlo, // Color translation
1376: // PRECTL prclTrg, // Target offset and extent
1377: // PPOINTL pptlSrc, // Source offset
1378: // PPOINTL pptlMask, // Mask offset
1379: // PBRUSHOBJ pbo, // Brush data
1380: // PPOINTL pptlBrush, // Brush offset
1381: // ROP4 rop4); // Raster operation
1382: //
1383: // Provides general Blt capabilities to device managed surfaces. The Blt
1384: // might be from an Engine managed bitmap. In that case, the bitmap is
1385: // one of the standard format bitmaps. The driver will never be asked
1386: // to Blt to an Engine managed surface.
1387: //
1388: // This function is required if any drawing is done to device managed
1389: // surfaces. The basic functionality required is:
1390: //
1391: // 1 Blt from any standard format bitmap or device surface to a device
1392: // surface,
1393: //
1394: // 2 with any ROP,
1395: //
1396: // 3 optionally masked,
1397: //
1398: // 4 with color index translation,
1399: //
1400: // 5 with arbitrary clipping.
1401: //
1402: // Engine services allow the clipping to be reduced to a series of clip
1403: // rectangles. A translation vector is provided to assist in color index
1404: // translation for palettes.
1405: //
1406: // This is a large and complex function. It represents most of the work
1407: // in writing a driver for a raster display device that does not have
1408: // a standard format frame buffer. The Microsoft VGA driver provides
1409: // example code that supports the basic function completely for a planar
1410: // device.
1411: //
1412: // NOTE: PostScript printers do not support copying from device bitmaps.
1413: // Nor can they perform raster operations on bitmaps. Therefore,
1414: // it is not possible to support ROPs which interact with the
1415: // destination (ie inverting the destination). The driver will
1416: // do its best to map these ROPs into ROPs utilizing functions on
1417: // the Source or Pattern.
1418: //
1419: // This driver supports the bitblt cases indicated below:
1420: //
1421: // Device -> Memory No
1422: // Device -> Device No
1423: // Memory -> Memory No
1424: // Memory -> Device Yes
1425: // Brush -> Memory No
1426: // Brush -> Device Yes
1427: //
1428: // Parameters:
1429: // <psoDest>
1430: // This is a pointer to a device managed SURFOBJ. It identifies the
1431: // surface on which to draw.
1432: //
1433: // <psoSrc>
1434: // If the rop requires it, this SURFOBJ defines the source for the
1435: // Blt operation. The driver must call the Engine Services to find out
1436: // if this is a device managed surface or a bitmap managed by the
1437: // Engine.
1438: //
1439: // <psoMask>
1440: // This optional surface provides another input for the rop4. It is
1441: // defined by a logic map, i.e. a bitmap with one bit per pel.
1442: //
1443: // The mask is typically used to limit the area of the destination that
1444: // should be modified. This masking is accomplished by a rop4 whose
1445: // lower byte is AA, leaving the destination unaffected when the mask
1446: // is 0.
1447: //
1448: // This mask, like a brush, may be of any size and is assumed to tile
1449: // to cover the destination of the Blt.
1450: //
1451: // If this argument is NULL and a mask is required by the rop4, the
1452: // implicit mask in the brush will be used.
1453: //
1454: // <pco>
1455: // This is a pointer to a CLIPOBJ. Engine Services are provided to
1456: // enumerate the clipping region as a set of rectangles or trapezoids.
1457: // This limits the area of the destination that will be modified.
1458: //
1459: // Whenever possible, the Graphics Engine will simplify the clipping
1460: // involved. For example, vBitBlt will never be called with exactly
1461: // one clipping rectangle. The Engine will have clipped the destination
1462: // rectangle before calling, so that no clipping needs to be considered.
1463: //
1464: // <pxlo>
1465: // This is a pointer to an XLATEOBJ. It tells how color indices should
1466: // be translated between the source and target surfaces.
1467: //
1468: // If the source surface is palette managed, then its colors are
1469: // represented by indices into a list of RGB colors. In this case, the
1470: // XLATEOBJ can be queried to get a translate vector that will allow
1471: // the device driver to quickly translate any source index into a color
1472: // index for the destination.
1473: //
1474: // The situation is more complicated when the source is, for example,
1475: // RGB but the destination is palette managed. In this case a closest
1476: // match to each source RGB must be found in the destination palette.
1477: // The XLATEOBJ provides a service routine to do this matching. (The
1478: // device driver is allowed to do the matching itself when the target
1479: // palette is the default device palette.)
1480: //
1481: // <prclDest>
1482: // This RECTL defines the area in the coordinate system of the
1483: // destination surface that will be modified. The rectangle is defined
1484: // as two points, upper left and lower right. The lower and right edges
1485: // of this rectangle are not part of the Blt, i.e. the rectangle is
1486: // lower right exclusive. vBitBlt will never be called with an empty
1487: // destination rectangle, and the two points of the rectangle will
1488: // always be well ordered.
1489: //
1490: // <pptlSrc>
1491: // This POINTL defines the upper left corner of the source rectangle, if
1492: // there is a source. Ignore this argument if there is no source.
1493: //
1494: // <pptlMask>
1495: // This POINTL defines which pel in the mask corresponds to the upper
1496: // left corner of the destination rectangle. Ignore this argument if
1497: // no mask is provided with psoMask.
1498: //
1499: // <pdbrush>
1500: // This is a pointer to the device's realization of the brush to be
1501: // used in the Blt. The pattern for the Blt is defined by this brush.
1502: // Ignore this argument if the rop4 does not require a pattern.
1503: //
1504: // <pptlBrushOrigin>
1505: // This is a pointer to a POINTL which defines the origin of the brush.
1506: // The upper left pel of the brush is aligned here and the brush repeats
1507: // according to its dimensions. Ignore this argument if the rop4 does
1508: // not require a pattern.
1509: //
1510: // <rop4>
1511: // This raster operation defines how the mask, pattern, source, and
1512: // destination pels should be combined to determine an output pel to be
1513: // written on the destination surface.
1514: //
1515: // This is a quaternary raster operation, which is a natural extension
1516: // of the usual ternary rop3. There are 16 relevant bits in the rop4,
1517: // these are like the 8 defining bits of a rop3. (We ignore the other
1518: // bits of the rop3, which are redundant.) The simplest way to
1519: // implement a rop4 is to consider its two bytes separately. The lower
1520: // byte specifies a rop3 that should be computed wherever the mask
1521: // is 0. The high byte specifies a rop3 that should then be computed
1522: // and applied wherever the mask is 1.
1523: //
1524: // NOTE: The PostScript driver cannot do anything with any raster ops
1525: // which utilize the destination. This means we only support the following
1526: // 17 raster ops:
1527: //
1528: // BLACKNESS_ROP 0x00
1529: // SRCORPATNOT_ROP 0x03
1530: // PATNOTSRCAND_ROP 0x0C
1531: // PATNOT_ROP 0x0F
1532: // SRCNOTPATAND_ROP 0x30
1533: // SRCNOT_ROP 0x33
1534: // SRCXORPAT_ROP 0x3C
1535: // SRCANDPATNOT_ROP 0x3F
1536: // DST_ROP 0xAA
1537: // SRCANDPAT_ROP 0xC0
1538: // SRCXORPATNOT_ROP 0xC3
1539: // SRC_ROP 0xCC
1540: // PATNOTSRCOR_ROP 0xCF
1541: // PAT_ROP 0xF0
1542: // SRCNOTPATOR_ROP 0xF3
1543: // SRCORPAT_ROP 0xFC
1544: // WHITENESS_ROP 0xFF
1545: //
1546: // NOTE: PostScript printers cannot handle bitmap masking. What this
1547: // translates to is that if the background rop3 is AA (Destination)
1548: // there is no way for the printer to not overwrite the background.
1549: //
1550: // Returns:
1551: // This function does not return a value.
1552: //
1553: // History:
1554: // 17-Mar-1993 Thu 21:29:15 updated -by- Rob Kiesler
1555: // Added a code path to allow the PS Interpreter to do halftoning when
1556: // the option is selected by the user.
1557: //
1558: // 11-Feb-1993 Thu 21:29:15 updated -by- Daniel Chou (danielc)
1559: // Modified so that it call DrvStretchBlt(HALFTONE) when it can.
1560: //
1561: // 27-Mar-1992 Fri 00:08:43 updated -by- Daniel Chou (danielc)
1562: // 1) Remove 'pco' parameter and replaced it with prclClipBound parameter,
1563: // since pco is never referenced, prclClipBound is used for the
1564: // halftone.
1565: // 2) Add another parameter to do NOTSRCCOPY
1566: // 04-Dec-1990 -by- Kent Settle (kentse)
1567: // Wrote it.
1568: //--------------------------------------------------------------------------
1569:
1570: BOOL DrvBitBlt(
1571: SURFOBJ *psoTrg, // Target surface
1572: SURFOBJ *psoSrc, // Source surface
1573: SURFOBJ *psoMask, // Mask
1574: CLIPOBJ *pco, // Clip through this
1575: XLATEOBJ *pxlo, // Color translation
1576: PRECTL prclTrg, // Target offset and extent
1577: PPOINTL pptlSrc, // Source offset
1578: PPOINTL pptlMask, // Mask offset
1579: BRUSHOBJ *pbo, // Brush data
1580: PPOINTL pptlBrush, // Brush offset
1581: ROP4 rop4) // Raster operation
1582: {
1583: PDEVDATA pdev;
1584: PDRVHTINFO pDrvHTInfo;
1585: RECTL rclSrc;
1586: ULONG ulColor;
1587: BOOL bInvertPat;
1588: BOOL bClipping;
1589: BOOL NotSrcCopy;
1590: PRECTL prclClip;
1591: RECTL rclClip;
1592: RECTL rclTmp;
1593: BOOL bMoreClipping;
1594: BOOL bFirstClipPass;
1595:
1596: // make sure none of the high bits are set.
1597:
1598: ASSERTPS((rop4 & 0xffff0000) == 0, "DrvBitBlt: invalid ROP.\n");
1599:
1600: //
1601: // get the pointer to our DEVDATA structure and make sure it is ours.
1602: //
1603:
1604: pdev = (PDEVDATA)psoTrg->dhpdev;
1605:
1606: if (!bValidatePDEV(pdev)) {
1607:
1608: RIP("PSCRIPT!DrvBitBlt: invalid pdev.\n");
1609: SetLastError(ERROR_INVALID_PARAMETER);
1610: return(FALSE);
1611: }
1612:
1613: //
1614: // Do DrvStretchBlt(HALFTONE) first if we can, notices that we do not
1615: // handle source masking case, because we cannot read back whatever on
1616: // the printer surface, also we can just output it to the printer
1617: // if the source bitmap/color is same or compatible with halftoned palette
1618: //
1619:
1620: if (!(pDrvHTInfo = (PDRVHTINFO)(pdev->pvDrvHTData))) {
1621:
1622: DbgPrint("\nPSCRIPT!DrvBitBlt: pDrvHTInfo = NULL ???\n");
1623: return(FALSE);
1624: }
1625:
1626: NotSrcCopy = FALSE;
1627:
1628: //
1629: // Following are the one involve with source and destination. each rop4
1630: // will have two version, one for rop3/rop3 other for rop3/mask
1631: //
1632:
1633:
1634: // clear the source OR hack bit.
1635:
1636: pdev->dwFlags &= ~PDEV_SOURCEORHACK;
1637:
1638: switch (rop4) {
1639:
1640:
1641: //----------------------------------------------------------------------
1642: // Rop4 Request Op. SrcMASK Pscript Result Op.
1643: //----------------------------------------------------------------------
1644:
1645: case 0xB8B8: // ugly raster op that apps seem to use to blt text
1646: case 0xB8AA: // to our surface, when they treat us as a raster device.
1647:
1648: if (psoSrc->iBitmapFormat == BMF_1BPP)
1649: pdev->dwFlags |= PDEV_SOURCEORHACK;
1650:
1651: case 0x1111: // ~( S | D) ~S
1652: case 0x11AA: // ~( S | D) + SrcMask ~S
1653:
1654: case 0x3333: // (~S ) ~S
1655: case 0x33AA: // (~S ) + SrcMask ~S
1656:
1657: case 0x9999: // ~( S ^ D) ~S
1658: case 0x99AA: // ~( S ^ D) + SrcMask ~S
1659:
1660: case 0xBBBB: // (~S | D) ~S
1661: case 0xBBAA: // (~S | D) + SrcMask ~S
1662:
1663: case 0x7777: // ~( S & D) ~S
1664: case 0x77AA: // ~( S & D) + SrcMask ~S
1665:
1666: NotSrcCopy = TRUE;
1667:
1668: case 0x4444: // ( S & ~D) S
1669: case 0x44AA: // ( S & ~D) + SrcMask S
1670:
1671: case 0x6666: // ( S ^ D) S
1672: case 0x66AA: // ( S ^ D) + SrcMask S
1673:
1674: case 0x8888: // ( S & D) S
1675: case 0x88AA: // ( S & D) + SrcMask S
1676:
1677: case 0xCCCC: // ( S ) S
1678: case 0xCCAA: // ( S ) + SrcMask S
1679:
1680: case 0xDDDD: // ( S | ~D) S
1681: case 0xDDAA: // ( S | ~D) + SrcMask S
1682:
1683: case 0xEEEE: // ( S | D) S
1684: case 0xEEAA: // ( S | D) + SrcMask S
1685:
1686: if (pdev->dwFlags & PDEV_PSHALFTONE)
1687: {
1688: //
1689: // Let the Postscript interpreter do the halftoning.
1690: //
1691: rclSrc.left = pptlSrc->x;
1692: rclSrc.top = pptlSrc->y;
1693: rclSrc.right = pptlSrc->x + psoSrc->sizlBitmap.cx;
1694: rclSrc.bottom = pptlSrc->y + psoSrc->sizlBitmap.cy;
1695:
1696: prclClip = &rclClip;
1697:
1698: bMoreClipping = TRUE;
1699: bFirstClipPass = TRUE;
1700:
1701: while (bMoreClipping)
1702: {
1703: if (!(bClipping = bDoClipObj(pdev, pco, &rclClip, prclTrg,
1704: &bMoreClipping, &bFirstClipPass,
1705: MAX_CLIP_RECTS)))
1706: prclClip = NULL;
1707: else
1708: ps_clip(pdev, TRUE);
1709:
1710: // DoSourceCopy does not know how to use prclClip, so don't give it one.
1711: // if (!DoSourceCopy(pdev, psoSrc, &rclSrc, prclTrg, pxlo, prclClip,
1712: if (!DoSourceCopy(pdev, psoSrc, &rclSrc, prclTrg, pxlo, NULL,
1713: NotSrcCopy))
1714: return(FALSE);
1715:
1716: if (bClipping)
1717: ps_restore(pdev, TRUE);
1718: }
1719:
1720: break;
1721: }
1722: else
1723: {
1724: //
1725: // We will output the bitmap directly to the surface if following
1726: // conditions are all met
1727: //
1728: // 1. SRC = STYPE_BITMAP
1729: // 2. No source mask
1730: // 3. Source left/top = { 0, 0 }
1731: // 4. Destination RECTL is visible on the destination surface
1732: // 5. Destination RECTL size same as source bitmap size
1733: //
1734:
1735: if ((psoSrc->iType == STYPE_BITMAP) &&
1736: ((rop4 & 0xff) != 0xAA) &&
1737: (pptlSrc->x == 0) &&
1738: (pptlSrc->y == 0) &&
1739: (prclTrg->left >= 0) &&
1740: (prclTrg->top >= 0) &&
1741: (prclTrg->right <= psoTrg->sizlBitmap.cx) &&
1742: (prclTrg->bottom <= psoTrg->sizlBitmap.cy) &&
1743: ((prclTrg->right - prclTrg->left) == psoSrc->sizlBitmap.cx) &&
1744: ((prclTrg->bottom - prclTrg->top) == psoSrc->sizlBitmap.cy) &&
1745: (IsHTCompatibleSurfObj(pdev, psoSrc, pxlo))) {
1746:
1747: return(OutputHTCompatibleBits(pdev,
1748: psoSrc,
1749: pco,
1750: prclTrg->left,
1751: prclTrg->top));
1752: }
1753:
1754: //
1755: // If we did not met above conditions then passed it to the
1756: // HalftoneBlt(HALFTONE) and eventually it will come back to BitBlt()
1757: // with (0xCCCC) or DrvCopyBits()
1758: //
1759: // The reason we pass the source mask to the HalftoneBlt() function is
1760: // that when GDI engine create a shadow bitmap it will ask driver to
1761: // provide the current destination surface bits but since we cannot
1762: // read back from destination surface we will return FAILED in
1763: // DrvCopyBits(FROM DEST) and engine will just WHITE OUT shadow bitmap
1764: // (by DrvBitBlt(WHITENESS) before it doing SRC MASK COPY.
1765: //
1766:
1767: if ((rop4 & 0xFF) != 0xAA) {
1768:
1769: psoMask = NULL;
1770: pptlMask = NULL;
1771: }
1772:
1773: rclSrc.left = pptlSrc->x;
1774: rclSrc.top = pptlSrc->y;
1775: rclSrc.right = rclSrc.left + (prclTrg->right - prclTrg->left);
1776: rclSrc.bottom = rclSrc.top + (prclTrg->bottom - prclTrg->top);
1777:
1778: return(HalftoneBlt(pdev,
1779: psoTrg,
1780: psoSrc,
1781: psoMask, // no mask
1782: pco,
1783: pxlo,
1784: &(pDrvHTInfo->ca), // default clradj
1785: NULL, // Brush Origin = (0,0)
1786: prclTrg,
1787: &rclSrc,
1788: pptlMask,
1789: NotSrcCopy));
1790: }
1791: }
1792: //
1793: // Now following are not HalftoneBlt() cases
1794: // update the SURFOBJ pointer in our PDEV.
1795: //
1796:
1797: //
1798: // set some flags concerning the bitmap.
1799: // rop4 is a quaternary raster operation, which is a natural extension
1800: // of the usual ternary rop3. There are 16 relevant bits in the rop4,
1801: // these are like the 8 defining bits of a rop3. (We ignore the other
1802: // bits of the rop3, which are redundant.) The simplest way to
1803: // implement a rop4 is to consider its two bytes separately. The lower
1804: // byte specifies a rop3 that should be computed wherever the mask
1805: // is 0. The high byte specifies a rop3 that should then be computed
1806: // and applied wherever the mask is 1. if both of the rop3s are the
1807: // same, then a mask is not needed. otherwise a mask is necessary.
1808:
1809: #if 0
1810: if ((rop4 >> 8) != (rop4 & 0xff))
1811: {
1812: RIP("PSCRIPT: vBitBlt - mask needed.\n");
1813: return(FALSE);
1814: }
1815: #endif
1816:
1817: // assume patterns will not be inverted.
1818:
1819: bInvertPat = FALSE;
1820:
1821: switch(rop4) {
1822:
1823: case 0xFFFF: // WHITENESS.
1824: case 0xFFAA: // WHITENESS.
1825: case 0x0000: // BLACKNESS.
1826: case 0x00AA: // BLACKNESS.
1827:
1828: if ((rop4 == 0xFFFF) || (rop4 == 0xFFAA))
1829: ulColor = RGB_WHITE;
1830: else
1831: ulColor = RGB_BLACK;
1832:
1833: // handle the clip object passed in.
1834:
1835: bMoreClipping = TRUE;
1836: bFirstClipPass = TRUE;
1837:
1838: while (bMoreClipping)
1839: {
1840: bClipping = bDoClipObj(pdev, pco, NULL, prclTrg, &bMoreClipping,
1841: &bFirstClipPass, MAX_CLIP_RECTS);
1842:
1843: if (bClipping) {
1844:
1845: ps_clip(pdev, TRUE);
1846: }
1847:
1848: #ifdef INDEX_PAL
1849: ps_setrgbcolor(pdev, (PALETTEENTRY *)&ulColor);
1850: #else
1851: ps_setrgbcolor(pdev, (BGR_PAL_ENTRY *)&ulColor);
1852: #endif
1853:
1854: // position the image on the page, remembering to flip the image
1855: // from top to bottom.
1856:
1857: // remember, with bitblt, the target rectangle is bottom/right
1858: // exclusive.
1859:
1860: rclTmp.left = prclTrg->left;
1861: rclTmp.top = prclTrg->top;
1862: rclTmp.right = prclTrg->right;
1863: rclTmp.bottom = prclTrg->bottom;
1864:
1865: if ((prclTrg->right - prclTrg->left) > 1)
1866: rclTmp.right -= 1;
1867:
1868: if ((prclTrg->bottom - prclTrg->top) > 1)
1869: rclTmp.bottom -= 1;
1870:
1871: ps_box(pdev, &rclTmp);
1872: PrintString(pdev, "f\n");
1873:
1874: if (bClipping) {
1875:
1876: ps_restore(pdev, TRUE);
1877: }
1878: }
1879:
1880: break;
1881:
1882: case 0x5A5A:
1883: case 0x5AAA:
1884: // we can't do the right thing, so we are done.
1885:
1886: break;
1887:
1888: case 0xF0F0: // PATCOPY opaque.
1889: case 0xF0AA: // PATCOPY transparent.
1890:
1891: // handle the clip object passed in.
1892:
1893: bMoreClipping = TRUE;
1894: bFirstClipPass = TRUE;
1895:
1896: while (bMoreClipping)
1897: {
1898: bClipping = bDoClipObj(pdev, pco, NULL, prclTrg, &bMoreClipping,
1899: &bFirstClipPass, MAX_CLIP_RECTS);
1900:
1901: if (bClipping) {
1902:
1903: ps_clip(pdev, TRUE);
1904: }
1905:
1906: if (!DoPatCopy(pdev, psoTrg, prclTrg, pbo, pptlBrush, rop4, bInvertPat)) {
1907:
1908: return(FALSE);
1909: }
1910:
1911: if (bClipping) {
1912:
1913: ps_restore(pdev, TRUE);
1914: }
1915: }
1916:
1917: break;
1918:
1919: default:
1920:
1921: return (EngBitBlt(
1922: psoTrg,
1923: psoSrc,
1924: psoMask,
1925: pco,
1926: pxlo,
1927: prclTrg,
1928: pptlSrc,
1929: pptlMask,
1930: pbo,
1931: pptlBrush,
1932: rop4));
1933: }
1934:
1935: //
1936: // bDoClipObj does a save around the clip region.
1937: //
1938:
1939: return(TRUE);
1940:
1941: }
1942:
1943:
1944:
1945:
1946: VOID
1947: BeginImage(
1948: PDEVDATA pdev,
1949: BOOL Mono,
1950: int x,
1951: int y,
1952: int cx,
1953: int cy,
1954: int cxBytes
1955: )
1956:
1957: /*++
1958:
1959: Routine Description:
1960:
1961: This routine copy sorce image using PostScript code for the image command
1962: appropriate for the bitmap format.
1963:
1964: Arguments:
1965:
1966: pdev - pointer to PDEVDATA
1967:
1968: Mono - true if output is B/W monochrome
1969:
1970: x - starting destination location in x
1971:
1972: y - starting destination location in y
1973:
1974: cx - bitmap width
1975:
1976: cy - bitmap height
1977:
1978: cxBytes - bytes count per single color scan line
1979:
1980: Return Value:
1981:
1982: void
1983:
1984: Author:
1985:
1986: 16-Feb-1993 Tue 12:43:03 created -by- Daniel Chou (danielc)
1987:
1988:
1989: Revision History:
1990:
1991:
1992: --*/
1993:
1994: {
1995: POINTPSFX ptpsfx;
1996:
1997: //
1998: // create the necessary string(s) on the printer's stack to read
1999: // in the bitmap data.
2000: //
2001:
2002: if (Mono) {
2003:
2004: PrintString(pdev, "/mstr ");
2005: PrintDecimal(pdev, 1, cxBytes);
2006: PrintString(pdev, " string def\n");
2007:
2008: } else {
2009:
2010: PrintString(pdev, "/rstr ");
2011: PrintDecimal(pdev, 1, cxBytes);
2012: PrintString(pdev, " string def\n");
2013: PrintString(pdev, "/gstr ");
2014: PrintDecimal(pdev, 1, cxBytes);
2015: PrintString(pdev, " string def\n");
2016: PrintString(pdev, "/bstr ");
2017: PrintDecimal(pdev, 1, cxBytes);
2018: PrintString(pdev, " string def\n");
2019: }
2020:
2021: //
2022: // position the image on the page, remembering to flip the image
2023: // from top to bottom. output PostScript user coordinates to the printer.
2024: //
2025: //
2026: // 22-Feb-1993 Mon 21:44:22 updated -by- Daniel Chou (danielc)
2027: // If application do their own banding then this computation could
2028: // run into problems by missing 1 device pel because 1/64 accuracy
2029: // is not good enough for full size banding
2030: //
2031:
2032: ptpsfx.x = X72DPI(x);
2033: ptpsfx.y = Y72DPI(y);
2034:
2035: PrintPSFIX(pdev, 2, ptpsfx.x, ptpsfx.y);
2036: PrintString(pdev, " _snap translate\n");
2037:
2038: //
2039: // scale the image.
2040: //
2041:
2042: ptpsfx.x = ((cx * PS_FIX_RESOLUTION) + (pdev->psdm.dm.dmPrintQuality / 2)) /
2043: pdev->psdm.dm.dmPrintQuality;
2044: ptpsfx.y = ((cy * PS_FIX_RESOLUTION) + (pdev->psdm.dm.dmPrintQuality / 2)) /
2045: pdev->psdm.dm.dmPrintQuality;
2046:
2047: PrintPSFIX(pdev, 2, ptpsfx.x, ptpsfx.y);
2048: PrintString(pdev, " scale\n");
2049:
2050: //
2051: // Output the image operator and the scan data.
2052: //
2053:
2054: PrintDecimal(pdev, 2, cx, cy);
2055: PrintString(pdev, " ");
2056:
2057: if (pdev->dwFlags & PDEV_SOURCEORHACK)
2058: PrintString(pdev, "true [");
2059: else
2060: PrintString(pdev, "1 [");
2061:
2062: PrintDecimal(pdev, 1, cx);
2063: PrintString(pdev, " 0 0 ");
2064:
2065: //
2066: // We will always send in as TOPDOWN when we calling this function
2067: //
2068:
2069: PrintDecimal(pdev, 1, -cy);
2070: PrintString(pdev, " 0 0] ");
2071:
2072: if (Mono) {
2073:
2074: PrintString(pdev, "{currentfile mstr readhexstring pop}");
2075:
2076: if (pdev->dwFlags & PDEV_SOURCEORHACK)
2077: PrintString(pdev, " im\n");
2078: else
2079: PrintString(pdev, " image\n");
2080:
2081: } else {
2082:
2083: PrintString(pdev, "\n{currentfile rstr readhexstring pop}\n");
2084: PrintString(pdev, "{currentfile gstr readhexstring pop}\n");
2085: PrintString(pdev, "{currentfile bstr readhexstring pop}\n");
2086: PrintString(pdev, "true 3 colorimage\n");
2087: }
2088: }
2089:
2090:
2091: //--------------------------------------------------------------------
2092: // BOOL DoPatCopy(pdev, pso, prclTrg, pbo, pptlBrush, rop4, bInvertPat)
2093: // PDEVDATA pdev;
2094: // SURFOBJ *pso;
2095: // PRECTL prclTrg;
2096: // BRUSHOBJ *pbo;
2097: // PPOINTL pptlBrush;
2098: // ROP4 rop4;
2099: // BOOL bInvertPat;
2100: //
2101: // This routine determines which pattern we are to print from the
2102: // BRUSHOBJ passed in, and will output the PostScript commands to
2103: // do the pattern fill. It is assumed the clipping will have been
2104: // set up at this point.
2105: //
2106: // History:
2107: // Thu May 23, 1991 -by- Kent Settle [kentse]
2108: // Wrote it.
2109: //--------------------------------------------------------------------
2110:
2111: BOOL DoPatCopy(pdev, pso, prclTrg, pbo, pptlBrush, rop4, bInvertPat)
2112: PDEVDATA pdev;
2113: SURFOBJ *pso;
2114: PRECTL prclTrg;
2115: BRUSHOBJ *pbo;
2116: PPOINTL pptlBrush;
2117: ROP4 rop4;
2118: BOOL bInvertPat;
2119: {
2120: RECTL rclTmp;
2121: BOOL bUserPat;
2122: DEVBRUSH *pBrush;
2123:
2124: // remember, with bitblt, the target rectangle is bottom/right
2125: // exclusive.
2126:
2127: rclTmp.left = prclTrg->left;
2128: rclTmp.top = prclTrg->top;
2129: rclTmp.right = prclTrg->right;
2130: rclTmp.bottom = prclTrg->bottom;
2131:
2132: if ((prclTrg->right - prclTrg->left) > 1)
2133: rclTmp.right -= 1;
2134:
2135: if ((prclTrg->bottom - prclTrg->top) > 1)
2136: rclTmp.bottom -= 1;
2137:
2138: // if we have a user defined pattern, don't output the bounding box since
2139: // it will not be used.
2140:
2141: bUserPat = FALSE;
2142:
2143: if (pbo->iSolidColor != NOT_SOLID_COLOR)
2144: bUserPat = FALSE;
2145: else
2146: {
2147: pBrush = (DEVBRUSH *)BRUSHOBJ_pvGetRbrush(pbo);
2148:
2149: if (!pBrush)
2150: bUserPat = FALSE;
2151: else
2152: {
2153: if ((pBrush->iPatIndex < HS_HORIZONTAL) ||
2154: (pBrush->iPatIndex >= HS_API_MAX))
2155: bUserPat = TRUE;
2156: }
2157: }
2158:
2159: if (!bUserPat)
2160: ps_box(pdev, & rclTmp);
2161:
2162: // now fill the target rectangle with the given pattern.
2163:
2164: return(ps_patfill(pdev, pso, (FLONG)FP_WINDINGMODE, pbo, pptlBrush, (MIX)rop4,
2165: &rclTmp, bInvertPat, FALSE));
2166: }
2167:
2168: //--------------------------------------------------------------------
2169: // BOOL DoSourceCopy(pdev, psoSrc, prclSrc, prclDest, pxlo, prclClipBound,
2170: // bNotSrcCopy)
2171: // PDEVDATA pdev;
2172: // SURFOBJ *psoSrc;
2173: // PRECTL prclSrc;
2174: // PRECTL prclDest;
2175: // XLATEOBJ *pxlo;
2176: // RECTL *prclClipBound;
2177: // BOOL bNotSrcCopy;
2178: //
2179: // This routine projects an image of a rectangle on
2180: // the source DC's bitmap onto the printer.
2181: //
2182: // 06-Jun-1991 -by- Kent Settle (kentse)
2183: // Wrote it.
2184: // 17-Mar-1993 -by- Rob Kiesler
2185: // Resurrected and rewritten to allow the PS Interpreter to do Halftoning.
2186: //--------------------------------------------------------------------
2187:
2188: BOOL DoSourceCopy(pdev, psoSrc, prclSrc, prclDest, pxlo, prclClipBound,
2189: bNotSrcCopy)
2190: PDEVDATA pdev;
2191: SURFOBJ *psoSrc;
2192: PRECTL prclSrc;
2193: PRECTL prclDest;
2194: XLATEOBJ *pxlo;
2195: RECTL *prclClipBound;
2196: BOOL bNotSrcCopy;
2197: {
2198: RECTL rclBand, rclDest, rclClip;
2199: LONG Temp;
2200: DWORD cbSrcScanLine;
2201: DWORD cbDstScanLine;
2202: POINTL ZeroPointl={0,0};
2203: PBYTE pbSrc;
2204: ULONG ulbpp;
2205: DWORD cScanlines;
2206: //
2207: // If we know the destination clipping region bounding rectangle then we
2208: // can allocate smaller bitmap and use that bounding rectangle as our
2209: // banding rectangle for halftone, if prclClipBound is NULL then the whole
2210: // destinaiton rectangle is our bounding (banding) rectangle area
2211: //
2212:
2213: // make sure the destination rectangle is well ordered.
2214:
2215: rclDest = *prclDest;
2216:
2217: if (rclDest.left > rclDest.right)
2218: {
2219: Temp = rclDest.left;
2220: rclDest.left = rclDest.right;
2221: rclDest.right = Temp;
2222: }
2223:
2224: if (rclDest.top > rclDest.bottom)
2225: {
2226: Temp = rclDest.top;
2227: rclDest.top = rclDest.bottom;
2228: rclDest.bottom = Temp;
2229: }
2230:
2231: // if there is a clipping rectangle, intersect it with the destination
2232: // rectangle to come up with a banding rectangle.
2233:
2234: if (prclClipBound)
2235: {
2236: rclClip = *prclClipBound;
2237:
2238: // Make sure the clip rectangle is well ordered
2239:
2240: if (rclClip.left > rclClip.right)
2241: {
2242: Temp = rclClip.left;
2243: rclClip.left = rclClip.right;
2244: rclClip.right = Temp;
2245: }
2246:
2247: if (rclClip.top > rclClip.bottom)
2248: {
2249: Temp = rclClip.top;
2250: rclClip.top = rclClip.bottom;
2251: rclClip.bottom = Temp;
2252: }
2253:
2254: // now intersect the destination and clip rectangles.
2255:
2256: if ((rclDest.left >= rclClip.right) ||
2257: (rclClip.left >= rclDest.right) ||
2258: (rclDest.top >= rclClip.bottom) ||
2259: (rclClip.top >= rclDest.bottom))
2260: {
2261: #if DBG
2262: DbgPrint("PSCRIPT!DoSourceCopy: NULL rectangle, returning FALSE.\n");
2263: #endif
2264: return(FALSE);
2265: }
2266:
2267: // we know we have a non-NULL intersection.
2268:
2269: rclBand.left = max(rclClip.left, rclDest.left);
2270: rclBand.right = min(rclClip.right, rclDest.right);
2271: rclBand.bottom = min(rclClip.bottom, rclDest.bottom);
2272: rclBand.top = max(rclClip.top, rclDest.top);
2273: }
2274: else
2275: rclBand = rclDest;
2276:
2277: //
2278: // Now check if the banding area is bigger than our page size, if so clip
2279: // to the page limit
2280: //
2281:
2282: if (rclBand.left < 0)
2283: rclBand.left = 0;
2284:
2285: if (rclBand.top < 0)
2286: rclBand.top = 0;
2287:
2288: //
2289: // send out the bitmap data one scanline at a time.
2290: // and compute DWORD aligned scanline width in bytes
2291: //
2292:
2293: //
2294: // Number of pels/scanline.
2295: //
2296: cbSrcScanLine = psoSrc->sizlBitmap.cx;
2297:
2298: //
2299: // times how many bits per pel.
2300: //
2301: switch (psoSrc->iBitmapFormat)
2302: {
2303: case BMF_1BPP:
2304: ulbpp = 1;
2305: break;
2306:
2307: case BMF_4BPP:
2308: ulbpp = 4;
2309: break;
2310:
2311: case BMF_8BPP:
2312: ulbpp = 8;
2313: break;
2314:
2315: case BMF_16BPP:
2316: ulbpp = 16;
2317: break;
2318:
2319: case BMF_24BPP:
2320: ulbpp = 24;
2321: break;
2322:
2323: case BMF_32BPP:
2324: ulbpp = 32;
2325: break;
2326: }
2327:
2328: cbSrcScanLine *= ulbpp;
2329: //
2330: // cbSrcScanLine now equals the number of bits per scanline.
2331: // calculate the destination width in bytes from the width in bits.
2332: // Note that the PS image routines only require scans to be padded to
2333: // byte boundaries.
2334: //
2335: cbDstScanLine = (cbSrcScanLine + 7) >> 3;
2336:
2337: //
2338: // Now convert cbSrcScanLine to the number of bytes per scanline,
2339: // taking into account that scanlines are padded out to 32 bit
2340: // boundaries.
2341: //
2342: cbSrcScanLine = ((cbDstScanLine + 3) >> 2) * 4;
2343:
2344: //
2345: // Output the PostScript beginimage operator.
2346: //
2347: BeginImageEx(pdev,
2348: psoSrc->sizlBitmap,
2349: ulbpp,
2350: cbDstScanLine,
2351: &rclBand,
2352: FALSE,
2353: pxlo);
2354:
2355: //
2356: // Set up pbSrc -> start of the source bitmap.
2357: //
2358: pbSrc = psoSrc->pvBits;
2359:
2360: cScanlines = (DWORD)psoSrc->sizlBitmap.cy;
2361:
2362: while (cScanlines--)
2363: {
2364: if (pdev->dwFlags & PDEV_CANCELDOC)
2365: break;
2366:
2367: //
2368: // Output each scanline to the printer
2369: //
2370: vHexOut(pdev, pbSrc, cbDstScanLine);
2371: PrintString(pdev, "\n");
2372:
2373: pbSrc += cbSrcScanLine;
2374: }
2375: PrintString(pdev, "\nendimage\n");
2376:
2377: return(TRUE);
2378: }
2379:
2380:
2381: //--------------------------------------------------------------------
2382: // BOOL BeginImageEx(pdev, sizlSrc, ulSrcFormat, cbSrcWidth, prclDest,
2383: // bNotSrcCopy, pxlo)
2384: // PDEVDATA pdev;
2385: // SIZEL sizlSrc;
2386: // ULONG ulSrcFormat;
2387: // DWORD cbSrcWidth;
2388: // PRECTL prclDest;
2389: // BOOL bNotSrcCopy;
2390: // XLATEOBJ *pxlo;VOID
2391: //
2392: // Routine Description:
2393: //
2394: // This routine will output the appropriate operators to set up the PS
2395: // interprter to receive a source image from the host. This routine is
2396: // called only when the PS Interpreter is being asked to perform
2397: // halftoning.
2398: //
2399: // Return Value:
2400: //
2401: // FALSE if an error occurred.
2402: //
2403: // Author:
2404: //
2405: // 17-Mar-1993 created -by- Rob Kiesler
2406: //
2407: //
2408: // Revision History:
2409: //--------------------------------------------------------------------
2410:
2411:
2412: BOOL BeginImageEx(pdev, sizlSrc, ulSrcFormat, cbSrcWidth, prclDest,
2413: bNotSrcCopy, pxlo)
2414: PDEVDATA pdev;
2415: SIZEL sizlSrc;
2416: ULONG ulSrcFormat;
2417: DWORD cbSrcWidth;
2418: PRECTL prclDest;
2419: BOOL bNotSrcCopy;
2420: XLATEOBJ *pxlo;
2421: {
2422: #ifdef INDEX_PAL
2423: PALETTEENTRY *prgb;
2424: DWORD i;
2425: POINTPSFX ptpsfx;
2426: CHAR bmpTypeStr[2];
2427: BYTE intensity;
2428: PALETTEENTRY *prgbFore;
2429: PALETTEENTRY *prgbBack;
2430: PALETTEENTRY *ppalette;
2431: PALETTEENTRY *ppalSave;
2432: ULONG *pulColors;
2433: DWORD cColors;
2434:
2435: //
2436: // Check to see if any of the PS image handling code
2437: // has been downloaded.
2438: //
2439: if(!(pdev->dwFlags & PDEV_UTILSSENT))
2440: {
2441: //
2442: // Download the Adobe PS Utilities Procset.
2443: //
2444: PrintString(pdev, "/Adobe_WinNT_Driver_Gfx 175 dict dup begin\n");
2445: if (!bSendPSProcSet(pdev, UTILS))
2446: {
2447: RIP("PSCRIPT!BeginImageEx: Couldn't download Utils Procset.\n");
2448: return(FALSE);
2449: }
2450: PrintString(pdev, "end def\n[ 1.000 0 0 1.000 0 0 ] Adobe_WinNT_Driver_Gfx dup /initialize get exec\n");
2451: pdev->dwFlags |= PDEV_UTILSSENT;
2452: }
2453:
2454: if(!(pdev->dwFlags & PDEV_IMAGESENT))
2455: {
2456: //
2457: // Download the Adobe PS Image Procset.
2458: //
2459: PrintString(pdev, "Adobe_WinNT_Driver_Gfx begin\n");
2460: if (!bSendPSProcSet(pdev, IMAGE))
2461: {
2462: RIP("PSCRIPT!BeginImageEx: Couldn't download Image Procset.\n");
2463: return(FALSE);
2464: }
2465: PrintString(pdev, "end reinitialize\n");
2466: pdev->dwFlags |= PDEV_IMAGESENT;
2467: }
2468:
2469: //
2470: // Send the source bmp origin, source bmp format, and scanline width.
2471: //
2472:
2473: PrintDecimal(pdev, 4, sizlSrc.cx, sizlSrc.cy, ulSrcFormat, cbSrcWidth);
2474: // PrintDecimal(pdev, 4, sizlSrc.cx, (prclDest->bottom - prclDest->top),
2475: // ulSrcFormat, cbSrcWidth);
2476: PrintString(pdev, " ");
2477:
2478: //
2479: // Compute the destination rectangle extents, and convert to fixed point.
2480: //
2481:
2482: #if 0
2483: ptpsfx.x = ((prclDest->right - prclDest->left) * PS_FIX_RESOLUTION) /
2484: pdev->psdm.dm.dmPrintQuality;
2485: ptpsfx.y = ((prclDest->bottom - prclDest->top) * PS_FIX_RESOLUTION) /
2486: pdev->psdm.dm.dmPrintQuality;
2487:
2488: PrintPSFIX(pdev, 2, ptpsfx.x, ptpsfx.y);
2489:
2490: PrintString(pdev, " "); // PrintPSFIX doesn't generate a " " after
2491: // the last # printed!
2492: #endif
2493:
2494: ptpsfx.x = ((prclDest->right - prclDest->left) * PS_FIX_RESOLUTION) /
2495: pdev->psdm.dm.dmPrintQuality;
2496: ptpsfx.y = ((prclDest->bottom - prclDest->top) * PS_FIX_RESOLUTION) /
2497: pdev->psdm.dm.dmPrintQuality;
2498:
2499: PrintDecimal(pdev, 1, (prclDest->right - prclDest->left));
2500: PrintString(pdev, " 72 mul DPI div ");
2501: PrintDecimal(pdev, 1, (prclDest->bottom - prclDest->top));
2502: PrintString(pdev, " 72 mul DPI div ");
2503:
2504: //
2505: // Convert Destination Rect Origin to fixed point.
2506: //
2507: #if 0
2508: ptpsfx.x = X72DPI(prclDest->left);
2509: ptpsfx.y = Y72DPI(prclDest->top);
2510:
2511: PrintPSFIX(pdev, 2, ptpsfx.x, ptpsfx.y);
2512: #endif
2513:
2514: PrintDecimal(pdev, 1, prclDest->left);
2515: PrintString(pdev, " 72 mul DPI div ");
2516: PrintDecimal(pdev, 1, pdev->CurForm.imagearea.left);
2517: PrintString(pdev, " add\n");
2518: PrintDecimal(pdev, 1, pdev->CurForm.imagearea.top);
2519: PrintString(pdev, " ");
2520: PrintDecimal(pdev, 1, prclDest->top);
2521: PrintString(pdev, " 72 mul DPI div sub\n");
2522:
2523: PrintString(pdev, " false "); // Smoothflag = FALSE for now.
2524: PrintString(pdev, bNotSrcCopy && (ulSrcFormat == 1) ? "false " : "true ");
2525:
2526: //
2527: // Determine the type of data (binary RLE, ASCII85 RLE, etc) which
2528: // the output channel supports, and pass it to the "beginimage"
2529: // operator.
2530: //
2531: itoa(PSBitMapType(pdev, FALSE), bmpTypeStr, 10);
2532: PrintString(pdev, bmpTypeStr);
2533: PrintString(pdev, " ");
2534:
2535: PrintString(pdev, "beginimage\n");
2536:
2537: if (pxlo)
2538: {
2539: // get pointer to our device palettes.
2540:
2541: if (ulSrcFormat == 1)
2542: pulColors = PSMonoPalette;
2543: else
2544: pulColors = PSColorPalette;
2545:
2546: if (pxlo->flXlate & XO_TRIVIAL)
2547: {
2548: // if the TRIVIAL color translation flag is set, then fill in
2549: // halftoning palette from our hardcoded palettes.
2550:
2551: if (ulSrcFormat == 1)
2552: ppalette = (PALETTEENTRY *)PSMonoPalette;
2553: else
2554: ppalette = (PALETTEENTRY *)PSColorPalette;
2555: }
2556: else if (pxlo->flXlate & XO_TABLE)
2557: {
2558: ppalette = (PALETTEENTRY *)pxlo->pulXlate;
2559: }
2560: else
2561: ppalette = (PALETTEENTRY *)NULL;
2562: }
2563: else
2564: ppalette = (PALETTEENTRY *)NULL;
2565:
2566: // ppalette now points to our palette. the format of this palette can
2567: // vary depending on pxlo->flXlate.
2568:
2569: switch (ulSrcFormat)
2570: {
2571: case 1:
2572: #if 0
2573: if (ppalette == NULL)
2574: {
2575: //
2576: // No palette, so assume fgcolor = black, bgcolor = white.
2577: //
2578: PrintString(pdev, "1bitbwcopyimage\n");
2579: }
2580: else
2581: {
2582: //
2583: // There is a palette, check the fg and bg colors.
2584: //
2585:
2586: if (pxlo->flXlate & XO_TRIVIAL)
2587: {
2588: prgbBack = ppalette;
2589: prgbFore = ppalette + 1;
2590: }
2591: else
2592: {
2593: prgbBack = (PALETTEENTRY *)(pulColors +
2594: XLATEOBJ_iXlate(pxlo, *(ULONG *)ppalette));
2595: prgbFore = (PALETTEENTRY *)(pulColors +
2596: XLATEOBJ_iXlate(pxlo, *(ULONG *)(ppalette + 1)));
2597: }
2598:
2599: if ((prgbBack->peRed == 0xFF) &&
2600: (prgbBack->peGreen == 0xFF) &&
2601: (prgbBack->peBlue == 0xFF) &&
2602: (prgbFore->peRed == 0x00) &&
2603: (prgbFore->peGreen == 0x00) &&
2604: (prgbFore->peBlue == 0x00))
2605: {
2606: //
2607: // fgcolor = black, bgcolor = white. The default case.
2608: //
2609: PrintString(pdev, "1bitbwcopyimage\n");
2610: }
2611: else
2612: {
2613: //
2614: // Either fg != black, or bg != white, must send
2615: // fg and bg colors.
2616: //
2617: PrintPSFIX(pdev, 3, LTOPSFX((ULONG)prgbFore->peRed) / 255,
2618: LTOPSFX((ULONG)prgbFore->peGreen) / 255,
2619: LTOPSFX((ULONG)prgbFore->peBlue) / 255);
2620: PrintString(pdev, " false ");
2621: PrintPSFIX(pdev, 3, LTOPSFX((ULONG)prgbBack->peRed) / 255,
2622: LTOPSFX((ULONG)prgbBack->peGreen) / 255,
2623: LTOPSFX((ULONG)prgbBack->peBlue) / 255);
2624: PrintString(pdev, " false ");
2625: PrintString(pdev, "1bitcopyimage\n");
2626: }
2627: }
2628: #endif
2629: PrintString(pdev, " doNimage\n");
2630: break;
2631:
2632: case 4 :
2633: case 8 :
2634: if (ppalette == NULL)
2635: {
2636: //
2637: // No palette, use the current PS colors.
2638: //
2639: PrintString(pdev, "doNimage\n");
2640: }
2641: else
2642: {
2643: //
2644: // There is a palette, send it to the PS interpreter.
2645: // First, compute and send the mono (intensity) palette.
2646: //
2647: PrintString(pdev, "<\n");
2648:
2649: if (pxlo->flXlate & XO_TRIVIAL)
2650: {
2651: if (ulSrcFormat == 4)
2652: cColors = 16;
2653:
2654: #if DBG
2655: else
2656: RIP("PSCRIPT!BeginImageEx: invalid pxlo format.\n");
2657: #endif
2658: }
2659: else
2660: cColors = pxlo->cEntries;
2661:
2662: ppalSave = ppalette;
2663:
2664: for (i = 0; i < cColors; ppalette++)
2665: {
2666: if (pxlo->flXlate & XO_TRIVIAL)
2667: prgb = ppalette;
2668: else
2669: prgb = (PALETTEENTRY *)(pulColors +
2670: XLATEOBJ_iXlate(pxlo, *(ULONG *)ppalette));
2671:
2672: intensity = INTENSITY(prgb->peRed,
2673: prgb->peGreen,
2674: prgb->peBlue);
2675:
2676: vHexOut(pdev, &intensity, 1);
2677:
2678: if (++i % 16)
2679: PrintString(pdev," ");
2680: else
2681: PrintString(pdev,"\n");
2682: }
2683:
2684: //
2685: // If the number of palette entries is less than the
2686: // number of possible colors for ulSrcFormat, pad the
2687: // palette with 0's.
2688: //
2689: for ( ; i < (DWORD)(1 << ulSrcFormat) ; )
2690: {
2691: PrintString(pdev,"00");
2692: if (++i % 16)
2693: PrintString(pdev," ");
2694: else
2695: PrintString(pdev, "\n");
2696: }
2697: PrintString(pdev, ">\n");
2698:
2699: //
2700: // Send the RGB palette.
2701: //
2702: PrintString(pdev, "<\n");
2703:
2704: ppalette = ppalSave;
2705:
2706: for (i = 0; i < cColors; ppalette++)
2707: {
2708: if (pdev->dwFlags & PDEV_CANCELDOC)
2709: break;
2710:
2711: if (pxlo->flXlate & XO_TRIVIAL)
2712: prgb = ppalette;
2713: else
2714: prgb = (PALETTEENTRY *)(pulColors +
2715: XLATEOBJ_iXlate(pxlo, *(ULONG *)ppalette));
2716:
2717: if (pxlo->iSrcType & PAL_BGR)
2718: {
2719: vHexOut(pdev, &(prgb->peBlue), 1);
2720: vHexOut(pdev, &(prgb->peGreen), 1);
2721: vHexOut(pdev, &(prgb->peRed), 1);
2722: }
2723: else
2724: {
2725: vHexOut(pdev, (PBYTE)prgb, 3);
2726: }
2727:
2728: if (++i % 8)
2729: PrintString(pdev," ");
2730: else
2731: PrintString(pdev,"\n");
2732: }
2733:
2734: //
2735: // If the number of palette entries is less than the
2736: // number of possible colors for ulSrcFormat, pad the
2737: // palette with 0's.
2738: //
2739:
2740: for ( ; i < (DWORD)(1 << ulSrcFormat) ; )
2741: {
2742: PrintString(pdev,"000000");
2743: if (++i % 8)
2744: PrintString(pdev," ");
2745: else
2746: PrintString(pdev, "\n");
2747: }
2748: PrintString(pdev, "\n>\n");
2749: PrintString(pdev, "doclutimage\n");
2750: }
2751:
2752: break;
2753:
2754: #else // 24BPP case.
2755: BGR_PAL_ENTRY *pbgr;
2756: DWORD i;
2757: POINTPSFX ptpsfx;
2758: CHAR bmpTypeStr[2];
2759: BYTE intensity;
2760: BGR_PAL_ENTRY *pbgrFore;
2761: BGR_PAL_ENTRY *pbgrBack;
2762:
2763: //
2764: // Check to see if any of the PS image handling code
2765: // has been downloaded.
2766: //
2767: if(!(pdev->dwFlags & PDEV_UTILSSENT))
2768: {
2769: //
2770: // Download the Adobe PS Utilities Procset.
2771: //
2772: PrintString(pdev, "/Adobe_WinNT_Driver_Gfx 175 dict dup begin\n");
2773: if (!bSendPSProcSet(pdev, UTILS))
2774: {
2775: RIP("PSCRIPT!BeginImageEx: Couldn't download Utils Procset.\n");
2776: return(FALSE);
2777: }
2778: PrintString(pdev, "end def\n[ 1.000 0 0 1.000 0 0 ] Adobe_WinNT_Driver_Gfx dup /initialize get exec\n");
2779: pdev->dwFlags |= PDEV_UTILSSENT;
2780: }
2781:
2782: if(!(pdev->dwFlags & PDEV_IMAGESENT))
2783: {
2784: //
2785: // Download the Adobe PS Image Procset.
2786: //
2787: PrintString(pdev, "Adobe_WinNT_Driver_Gfx begin\n");
2788: if (!bSendPSProcSet(pdev, IMAGE))
2789: {
2790: RIP("PSCRIPT!BeginImageEx: Couldn't download Image Procset.\n");
2791: return(FALSE);
2792: }
2793: PrintString(pdev, "end reinitialize\n");
2794: pdev->dwFlags |= PDEV_IMAGESENT;
2795: }
2796:
2797: //
2798: // Send the source bmp origin, source bmp format, and scanline width.
2799: //
2800:
2801: PrintDecimal(pdev, 4, sizlSrc.cx, sizlSrc.cy, ulSrcFormat, cbSrcWidth);
2802: PrintString(pdev, " ");
2803:
2804: //
2805: // Compute the destination rectangle extents, and convert to fixed point.
2806: //
2807:
2808: ptpsfx.x = ((prclDest->right - prclDest->left) * PS_FIX_RESOLUTION) /
2809: pdev->psdm.dm.dmPrintQuality;
2810: ptpsfx.y = ((prclDest->bottom - prclDest->top) * PS_FIX_RESOLUTION) /
2811: pdev->psdm.dm.dmPrintQuality;
2812:
2813: PrintDecimal(pdev, 1, (prclDest->right - prclDest->left));
2814: PrintString(pdev, " 72 mul DPI div ");
2815: PrintDecimal(pdev, 1, (prclDest->bottom - prclDest->top));
2816: PrintString(pdev, " 72 mul DPI div ");
2817:
2818: //
2819: // Convert Destination Rect Origin to fixed point.
2820: //
2821:
2822: PrintDecimal(pdev, 1, prclDest->left);
2823: PrintString(pdev, " 72 mul DPI div ");
2824: PrintDecimal(pdev, 1, pdev->CurForm.imagearea.left);
2825: PrintString(pdev, " add\n");
2826: PrintDecimal(pdev, 1, pdev->CurForm.imagearea.top);
2827: PrintString(pdev, " ");
2828: PrintDecimal(pdev, 1, prclDest->top);
2829: PrintString(pdev, " 72 mul DPI div sub");
2830:
2831: PrintString(pdev, " false "); // Smoothflag = FALSE for now.
2832: PrintString(pdev, bNotSrcCopy && (ulSrcFormat == 1) ? "false " : "true ");
2833:
2834: //
2835: // Determine the type of data (binary RLE, ASCII85 RLE, etc) which
2836: // the output channel supports, and pass it to the "beginimage"
2837: // operator.
2838: //
2839: itoa(PSBitMapType(pdev, FALSE), bmpTypeStr, 10);
2840: PrintString(pdev, bmpTypeStr);
2841: PrintString(pdev, " ");
2842:
2843: PrintString(pdev, "beginimage\n");
2844:
2845: if (pxlo)
2846: pbgr = (BGR_PAL_ENTRY *)pxlo->pulXlate;
2847: else
2848: pbgr = (BGR_PAL_ENTRY *)NULL;
2849:
2850: switch (ulSrcFormat)
2851: {
2852: case 1:
2853: #if 0
2854: if (pbgr == NULL)
2855: {
2856: //
2857: // No palette, so assume fgcolor = black, bgcolor = white.
2858: //
2859: PrintString(pdev, "1bitbwcopyimage\n");
2860: }
2861: else
2862: {
2863: pbgrBack = pbgr;
2864: pbgrFore = pbgr + 1;
2865:
2866: if ((pbgrBack->bgrRed == 0xFF) &&
2867: (pbgrBack->bgrGreen == 0xFF) &&
2868: (pbgrBack->bgrBlue == 0xFF) &&
2869: (pbgrFore->bgrRed == 0x00) &&
2870: (pbgrFore->bgrGreen == 0x00) &&
2871: (pbgrFore->bgrBlue == 0x00))
2872: {
2873: //
2874: // fgcolor = black, bgcolor = white. The default case.
2875: //
2876: PrintString(pdev, "1bitbwcopyimage\n");
2877: }
2878: else
2879: {
2880: //
2881: // Either fg != black, or bg != white, must send
2882: // fg and bg colors.
2883: //
2884: PrintPSFIX(pdev, 3, LTOPSFX((ULONG)pbgrFore->bgrRed) / 255,
2885: LTOPSFX((ULONG)pbgrFore->bgrGreen) / 255,
2886: LTOPSFX((ULONG)pbgrFore->bgrBlue) / 255);
2887: PrintString(pdev, " false ");
2888: PrintPSFIX(pdev, 3, LTOPSFX((ULONG)pbgrBack->bgrRed) / 255,
2889: LTOPSFX((ULONG)pbgrBack->bgrGreen) / 255,
2890: LTOPSFX((ULONG)pbgrBack->bgrBlue) / 255);
2891: PrintString(pdev, " false ");
2892: PrintString(pdev, "1bitcopyimage\n");
2893: }
2894: }
2895: #endif
2896: PrintString(pdev, "doNimage\n");
2897: break;
2898:
2899: case 4 :
2900: case 8 :
2901: if (pbgr == NULL)
2902: {
2903: //
2904: // No palette, use the current PS colors.
2905: //
2906: PrintString(pdev, "doNimage\n");
2907: }
2908: else
2909: {
2910: //
2911: // There is a palette, send it to the PS interpreter.
2912: // First, compute and send the mono (intensity) palette.
2913: //
2914: PrintString(pdev, "<\n");
2915:
2916: for (i = 0; i < pxlo->cEntries; pbgr++)
2917: {
2918: intensity = INTENSITY(pbgr->bgrRed,
2919: pbgr->bgrGreen,
2920: pbgr->bgrBlue);
2921:
2922: vHexOut(pdev, &intensity, 1);
2923:
2924: if (++i % 16)
2925: PrintString(pdev," ");
2926: else
2927: PrintString(pdev,"\n");
2928: }
2929:
2930: //
2931: // If the number of palette entries is less than the
2932: // number of possible colors for ulSrcFormat, pad the
2933: // palette with 0's.
2934: //
2935: for ( ; i < (DWORD)(1 << ulSrcFormat) ; )
2936: {
2937: PrintString(pdev,"00");
2938: if (++i % 16)
2939: PrintString(pdev," ");
2940: else
2941: PrintString(pdev, "\n");
2942: }
2943: PrintString(pdev, ">\n");
2944:
2945: //
2946: // Send the RGB palette.
2947: //
2948: PrintString(pdev, "<\n");
2949:
2950: pbgr = (BGR_PAL_ENTRY *)pxlo->pulXlate;
2951:
2952: for (i = 0; i < pxlo->cEntries; pbgr++)
2953: {
2954: if (pdev->dwFlags & PDEV_CANCELDOC)
2955: break;
2956:
2957: if (pxlo->iSrcType & PAL_BGR)
2958: {
2959: vHexOut(pdev, (PBYTE)pbgr, 3);
2960: }
2961: else
2962: {
2963: vHexOut(pdev, &(pbgr->bgrRed), 1);
2964: vHexOut(pdev, &(pbgr->bgrGreen), 1);
2965: vHexOut(pdev, &(pbgr->bgrBlue), 1);
2966: }
2967:
2968: if (++i % 8)
2969: PrintString(pdev," ");
2970: else
2971: PrintString(pdev,"\n");
2972: }
2973:
2974: //
2975: // If the number of palette entries is less than the
2976: // number of possible colors for ulSrcFormat, pad the
2977: // palette with 0's.
2978: //
2979:
2980: for ( ; i < (DWORD)(1 << ulSrcFormat) ; )
2981: {
2982: PrintString(pdev,"000000");
2983: if (++i % 8)
2984: PrintString(pdev," ");
2985: else
2986: PrintString(pdev, "\n");
2987: }
2988: PrintString(pdev, "\n>\n");
2989: PrintString(pdev, "doclutimage\n");
2990: }
2991:
2992: break;
2993:
2994: #endif
2995: case 24 :
2996: //
2997: // 24BPP images don't need a palette, use the doNimage operator.
2998: //
2999: PrintString(pdev, "doNimage\n");
3000: break;
3001:
3002: default:
3003: //
3004: // Can't handle bitmaps in formats other than the ones above!
3005: //
3006: return(FALSE);
3007: }
3008: return(TRUE);
3009: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.