![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pslayer.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 pslayer.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 root 1: //--------------------------------------------------------------------------
2: //
3: // Module Name: PSLAYER.C
4: //
5: // Brief Description: This module contains the PSCRIPT driver's layer
6: // of PostScript translation routines.
7: //
8: // Author: Kent Settle (kentse)
9: // Created: 17-Dec-1990
10: //
11: // Copyright (c) 1990 - 1992 Microsoft Corporation
12: //
13: // This module contains routines to handle the outputting of the PostScript
14: // language commands to the output channel. One of the main functions of
15: // this pslayer is to help provide device independence, by shielding the
16: // output of the actual device resolution. The NT PostScript driver will
17: // output all PostScript commands in POINTS space; that is 72 dots per inch.
18: // This is the default user coordinates for ALL PostScript printers, so we
19: // will use it. As far as the DDI is concerned, it only knows of the actual
20: // device resolution. This pslayer will convert between device coordinates
21: // and the PostScript user coordinates.
22: //
23: // Coordinates will be output to the device using PS_FIX (24.8) numbers.
24: // It may be useful, therefore to note the following relations using
25: // PS_FIX numbers. PS_FIX / LONG = PS_FIX. LONG * PS_FIX = PS_FIX.
26: // (PS_FIX * PS_FIX) >> 8 = PS_FIX.
27: //--------------------------------------------------------------------------
28:
29: #include "pscript.h"
30: #include <memory.h>
31: #include "enable.h"
32:
33: extern LONG iHipot(LONG, LONG);
34:
35: //--------------------------------------------------------------------------
36: // VOID ps_setrgbcolor(pdev, pbgr)
37: // PDEVDATA pdev;
38: // BGR_PAL_ENTRY *pbgr;
39: //
40: // This routine is called by the driver to set the current color. PostScript
41: // printers only know about the current color. For example, if you are
42: // printing text in red and lines in blue, and you alternate printing text
43: // and a line, you also have to set the current color each time.
44: //
45: // For black and white devices the RGB color is converted to a gray scale
46: // between 0.0 (black) and 1.0 (white).
47: //
48: // Parameters:
49: // pdev:
50: // pointer to DEVDATA structure.
51: //
52: // lColor:
53: // RGB value of new color.
54: //
55: // Returns:
56: // This function returns no value.
57: //
58: // History:
59: // 17-Dec-1990 -by- Kent Settle (kentse)
60: // Wrote it.
61: //--------------------------------------------------------------------------
62:
63:
64: VOID ps_setrgbcolor(pdev, pbgr)
65: PDEVDATA pdev;
66: BGR_PAL_ENTRY *pbgr;
67: {
68: PS_FIX psfxRed, psfxGreen, psfxBlue;
69: PS_FIX psfxGray;
70:
71: // if the all colors to black flag is set, set all colors, except
72: // white to black.
73:
74: if (pdev->psdm.dwFlags & PSDEVMODE_BLACK)
75: {
76: // if the last color was non-white and the new color is non-white,
77: // or the last color was white and the new color is white, then
78: // we want to leave the color alone.
79:
80: if (((pdev->cgs.ulColor != RGB_WHITE) && (*(ULONG *)pbgr != RGB_WHITE)) ||
81: ((pdev->cgs.ulColor == RGB_WHITE) && (*(ULONG *)pbgr == RGB_WHITE)))
82: return;
83:
84: // the color must be updated in the printer.
85:
86: if (*(ULONG *)pbgr == RGB_WHITE)
87: PrintString(pdev, "1 g\n");
88: else
89: PrintString(pdev, "0 g\n");
90: }
91: else if (pdev->cgs.ulColor != *(ULONG *)pbgr)
92: {
93: // save the new color in the current graphics state structure.
94:
95: pdev->cgs.ulColor = *(ULONG *)pbgr;
96:
97: if (pdev->psdm.dm.dmColor == DMCOLOR_COLOR)
98: {
99: // each color component must be output to the printer
100: // in the range from 0.0 to 1.0, so normalize to this
101: // range by dividing by 255.
102:
103: psfxRed = LTOPSFX((ULONG)pbgr->bgrRed) / 255;
104: psfxGreen = LTOPSFX((ULONG)pbgr->bgrGreen) / 255;
105: psfxBlue = LTOPSFX((ULONG)pbgr->bgrBlue) / 255;
106:
107: // if each of the color components is equal, just output a
108: // gray scale. otherwise, output the RGB value.
109:
110: if ((psfxRed == psfxGreen) && (psfxRed == psfxBlue))
111: {
112: PrintPSFIX(pdev, 1, psfxRed);
113: PrintString(pdev, " g\n");
114: }
115: else
116: {
117: PrintPSFIX(pdev, 3, psfxRed, psfxGreen, psfxBlue);;
118: PrintString(pdev, " r\n");
119: }
120: }
121: else
122: {
123: // convert the RGB color to a gray scale and output to the
124: // printer.
125:
126: psfxGray = psfxRGBtoGray(pbgr);
127: PrintPSFIX(pdev, 1, psfxGray);
128: PrintString(pdev, " g\n");
129: }
130: }
131: }
132:
133:
134: //--------------------------------------------------------------------------
135: // VOID ps_newpath(pdev)
136: // PDEVDATA pdev;
137: //
138: // This routine is called by the driver to issue a newpath command to
139: // the printer.
140: //
141: // Parameters:
142: // pdev:
143: // pointer to DEVDATA structure.
144: //
145: // Returns:
146: // This function returns no value.
147: //
148: // History:
149: // 18-Dec-1990 -by- Kent Settle (kentse)
150: // Wrote it.
151: //--------------------------------------------------------------------------
152:
153: VOID ps_newpath(pdev)
154: PDEVDATA pdev;
155: {
156: if (pdev->cgs.dwFlags & CGS_PATHEXISTS)
157: {
158: PrintString(pdev, "n\n");
159:
160: // indicate that no path exists in the printer.
161:
162: pdev->cgs.dwFlags &= ~CGS_PATHEXISTS;
163: }
164: }
165:
166:
167: //--------------------------------------------------------------------------
168: // BOOL ps_save(pdev, bgsave)
169: // PDEVDATA pdev;
170: // BOOL bgsave;
171: //
172: // This routine is called by the driver to save the current graphics state.
173: //
174: // Parameters:
175: // pdev:
176: // pointer to DEVDATA structure.
177: //
178: // bgsave:
179: // TRUE if to perform gsave instead of save.
180: //
181: // Returns:
182: // This function returns no value.
183: //
184: // History:
185: // 18-Dec-1990 -by- Kent Settle (kentse)
186: // Wrote it.
187: // 06-Nov-1991 -by- Kent Settle [kentse]
188: // Rewrote it using linked list.
189: //--------------------------------------------------------------------------
190:
191: BOOL ps_save(pdev, bgsave)
192: PDEVDATA pdev;
193: BOOL bgsave;
194: {
195: CGS *pcgs;
196: CGS *pNew;
197: DLFONT *pDLFont;
198:
199: // save the current graphics state in a linked list.
200:
201: // get pointer to beginning of gsave linked list.
202:
203: pcgs = pdev->pcgsSave;
204:
205: // move to the last entry in the list.
206:
207: if (pcgs)
208: {
209: while(pcgs->pcgsNext)
210: pcgs = pcgs->pcgsNext;
211: }
212:
213: // allocate the new element of the linked list.
214:
215: if (!(pNew = (PCGS)HeapAlloc(pdev->hheap, 0, sizeof(CGS))))
216: {
217: RIP("PSCRIPT!ps_save: HeapAlloc for pNew failed.\n");
218: return(FALSE);
219: }
220:
221: // save the current graphics state in our new element.
222:
223: memcpy(pNew, &pdev->cgs, sizeof(CGS));
224:
225: // allocate a new set of DLFONT structures, then copy the existing ones
226: // to the new ones.
227:
228: if (!(pNew->pDLFonts = (DLFONT *)HeapAlloc(pdev->hheap, 0,
229: sizeof(DLFONT) * (pdev->iDLFonts + 1))))
230: {
231: RIP("PSCRIPT!ps_save: HeapAlloc for pDLFonts failed.\n");
232: HeapFree(pdev->hheap, 0, (PVOID)pNew);
233: return(FALSE);
234: }
235:
236: pDLFont = pNew->pDLFonts;
237:
238: memcpy(pDLFont, pdev->cgs.pDLFonts, sizeof(DLFONT) * (pdev->iDLFonts));
239:
240: // clear out the last entry.
241:
242: pDLFont += pdev->iDLFonts;
243: memset(pDLFont, 0, sizeof(DLFONT));
244:
245: // if this is first element in the list, set the pointer in our
246: // pdev, else update list to point to new element.
247:
248: if (!pcgs)
249: pdev->pcgsSave = pNew;
250: else
251: pcgs->pcgsNext = pNew;
252:
253: // initialize pointers in new element.
254:
255: pNew->pcgsPrev = pcgs; // NULL if first gsave.
256: pNew->pcgsNext = NULL;
257:
258: // output save command to printer.
259:
260: if (bgsave)
261: PrintString(pdev, "gs\n");
262: else
263: PrintString(pdev, "save\n");
264:
265: return(TRUE);
266: }
267:
268:
269: //--------------------------------------------------------------------------
270: // BOOL ps_restore(pdev, bgrestore)
271: // PDEVDATA pdev;
272: // BOOL bgrestore;
273: //
274: // This routine is called by the driver to restore a previously saved
275: // graphics state.
276: //
277: // Parameters:
278: // pdev:
279: // pointer to DEVDATA structure.
280: //
281: // Returns:
282: // This function returns no value.
283: //
284: // History:
285: // 18-Dec-1990 -by- Kent Settle (kentse)
286: // Wrote it.
287: // 06-Nov-1991 -by- Kent Settle [kentse]
288: // Rewrote it using linked list.
289: // 15-Feb-1993 -by- Rob Kiesler
290: // If a restore is being performed, reset pdev flags indicating that
291: // the Adobe PS utility, pattern, and image procsets have been downloaded.
292: //--------------------------------------------------------------------------
293:
294: BOOL ps_restore(pdev, bgrestore)
295: PDEVDATA pdev;
296: BOOL bgrestore;
297: {
298: CGS *pcgs;
299: CGS *pcgsTmp;
300: DLFONT *pDLFont;
301:
302: // restore the current graphics state from the last element
303: // of the graphics state save linked list.
304:
305: // get pointer to the linked list.
306:
307: pcgs = pdev->pcgsSave;
308:
309: // find the last element of the list.
310:
311: while (pcgs->pcgsNext)
312: pcgs = pcgs->pcgsNext;
313:
314: // we are about to copy the last saved CGS from the linked list into the
315: // current CGS. therefore, we must free up memory used in the CGS before
316: // we clobber the pointers.
317:
318: if (pdev->cgs.pDLFonts)
319: {
320: // point to the last DLFONT structure. this will have been filled
321: // in iff we have hit our downloaded font threshold. if it is filled
322: // in, free up the hglyph vector.
323:
324: pDLFont = pdev->cgs.pDLFonts;
325: pDLFont += pdev->iDLFonts;
326:
327: if (pDLFont->phgVector)
328: HeapFree(pdev->hheap, 0, (PVOID)pDLFont->phgVector);
329:
330: HeapFree(pdev->hheap, 0, (PVOID)pdev->cgs.pDLFonts);
331: }
332:
333: // restore the current graphics state.
334:
335: memcpy(&pdev->cgs, pcgs, sizeof(CGS));
336:
337: // back up one element, and free up the last element of the list.
338:
339: if (!(pcgsTmp = pcgs->pcgsPrev))
340: {
341: // restored back to original state. clear out pointer to
342: // linked list.
343:
344: pdev->pcgsSave = (CGS *)NULL;
345: }
346: else
347: {
348: // mark the current element as the last in the list.
349:
350: pcgsTmp->pcgsNext = (PCGS)NULL;
351: }
352:
353: // free up the save CGS.
354:
355: HeapFree(pdev->hheap, 0, (PVOID)pcgs);
356:
357: if (bgrestore)
358: PrintString(pdev, "gr\n");
359: else
360: {
361: //
362: // If the Adobe PS Utilites were downloaded, clean up after
363: // them before blowing them away with the restore.
364: //
365: if (pdev->dwFlags & PDEV_UTILSSENT)
366: {
367: PrintString(pdev, "Adobe_WinNT_Driver_Gfx dup /terminate get exec\n");
368: pdev->dwFlags &= ~(PDEV_UTILSSENT | PDEV_BMPPATSENT | PDEV_IMAGESENT);
369: }
370: PrintString(pdev, "restore\n");
371:
372: }
373:
374: return(TRUE);
375: }
376:
377:
378: //--------------------------------------------------------------------------
379: // VOID ps_clip(pdev, bWinding)
380: // PDEVDATA pdev;
381: // BOOL bWinding;
382: //
383: // This routine is called by the driver to intersect the current path with
384: // the clipping path and make this the nwe clipping path. The winding
385: // number rule is used to determine the area clipped, if bWinding is TRUE.
386: //
387: // Parameters:
388: // pdev:
389: // pointer to DEVDATA structure.
390: //
391: // Returns:
392: // This function returns no value.
393: //
394: // History:
395: // 13-Feb-1991 -by- Kent Settle (kentse)
396: // Wrote it.
397: //--------------------------------------------------------------------------
398:
399: VOID ps_clip(pdev, bWinding)
400: PDEVDATA pdev;
401: BOOL bWinding;
402: {
403: // output the clip command to the printer, then output a newpath
404: // command, since the clip command does not destroy the path in the
405: // printer.
406:
407: if (bWinding)
408: PrintString(pdev, "clip n\n");
409: else
410: PrintString(pdev, "eoclip n\n");
411:
412: // indicate that the path no longer exists.
413:
414: pdev->cgs.dwFlags &= ~CGS_PATHEXISTS;
415: }
416:
417:
418: //--------------------------------------------------------------------------
419: // VOID ps_show(pdev, pstro, flAccel, pdata)
420: // PDEVDATA pdev;
421: // STROBJ *pstro;
422: // FLONG flAccel;
423: // TEXTDATA *pdata;
424: //
425: // This routine is called by the driver to intersect the current path with
426: // the clipping path and make this the nwe clipping path. The winding
427: // number rule is used to determine the area clipped, if bWinding is TRUE.
428: //
429: // Parameters:
430: // pdev:
431: // pointer to DEVDATA structure.
432: //
433: // Returns:
434: // This function returns no value.
435: //
436: // History:
437: // 13-Feb-1991 -by- Kent Settle (kentse)
438: // Wrote it.
439: //--------------------------------------------------------------------------
440:
441: VOID ps_show(pdev, pstro, flAccel, pdata)
442: PDEVDATA pdev;
443: STROBJ *pstro;
444: FLONG flAccel;
445: TEXTDATA *pdata;
446: {
447: // close the string and send out the show command, abreviated
448: // by 't', or our version of the fixed pitched horizontal
449: // show command 'H', or the proportional horizontal show
450: // command 'h', or the fixed pitched vertical show command 'V',
451: // or the proportional vertical show command 'v'.
452:
453: if ((flAccel == 0) || (flAccel & SO_FLAG_DEFAULT_PLACEMENT) ||
454: (pstro->cGlyphs == 1))
455: PrintString(pdev, ")t\n");
456: else if (flAccel & SO_HORIZONTAL)
457: {
458: if (pstro->ulCharInc)
459: PrintString(pdev, ")H\n");
460: else
461: {
462: if (pdata->bJustification)
463: {
464: // if we calculated the text justification, and it turns
465: // out the the justification widths are zero, just to
466: // a reguluar show command, otherwise it is time for
467: // awidthshow.
468:
469: if ((pdata->ptSpace.x == 0) && (pdata->ptNonSpace.x == 0))
470: PrintString(pdev, ")t\n");
471: else
472: PrintString(pdev, ")aw\n");
473: }
474: else
475: PrintString(pdev, ")h\n");
476: }
477: }
478: else
479: {
480: if (pstro->ulCharInc)
481: PrintString(pdev, ")V\n");
482: else
483: PrintString(pdev, ")v\n");
484: }
485: }
486:
487:
488: //--------------------------------------------------------------------------
489: // VOID ps_box(pdev, prectl)
490: // PDEVDATA pdev;
491: // PRECTL prectl;
492: //
493: // This routine is called by the driver to send box drawing commands to
494: // the printer.
495: //
496: // Parameters:
497: // pdev:
498: // Pointer to DEVDATA structure.
499: //
500: // prectl:
501: // Pointer to RECTL defining the box.
502: //
503: // Returns:
504: // This function returns no value.
505: //
506: // History:
507: // 13-Feb-1991 -by- Kent Settle (kentse)
508: // Wrote it.
509: //--------------------------------------------------------------------------
510:
511: VOID ps_box(pdev, prectl)
512: PDEVDATA pdev;
513: PRECTL prectl;
514: {
515: RECTPSFX rectpsfx;
516:
517: // output the box command to the printer. remember to convert
518: // between device resolution and PostScript user coordinates.
519:
520: // get a local copy of the rectangle, turn it into FIX numbers,
521: // flip over the y coordinates since 0,0 is upper left under NT, and
522: // 0,0 is lower left under PostScript.
523:
524: rectpsfx.xLeft = X72DPI(prectl->left);
525: rectpsfx.yBottom = Y72DPI(prectl->bottom);
526: rectpsfx.xRight = X72DPI(prectl->right);
527: rectpsfx.yTop = Y72DPI(prectl->top);
528:
529: PrintPSFIX(pdev, 4, rectpsfx.xLeft, rectpsfx.yTop,
530: rectpsfx.xRight, rectpsfx.yBottom);
531: PrintString(pdev, " box\n");
532:
533: // indicate that a path now exists.
534:
535: pdev->cgs.dwFlags |= CGS_PATHEXISTS;
536: }
537:
538:
539: //--------------------------------------------------------------------------
540: // VOID ps_moveto(pdev, pptl)
541: // PDEVDATA pdev;
542: // PPOINTL pptl;
543: //
544: // This routine is called by the driver to update the current position
545: // in the printer.
546: //
547: // Parameters:
548: // pdev:
549: // Pointer to DEVDATA structure.
550: //
551: // pptl:
552: // Pointer to PPOINTL defining new current position.
553: //
554: // Returns:
555: // This function returns no value.
556: //
557: // History:
558: // 26-Apr-1991 -by- Kent Settle (kentse)
559: // Wrote it.
560: //--------------------------------------------------------------------------
561:
562: VOID ps_moveto(pdev, pptl)
563: PDEVDATA pdev;
564: PPOINTL pptl;
565: {
566: POINTPSFX ptpsfx;
567:
568: // output the moveto command if new position is different from
569: // the old position. remember to flip from top to bottom, since
570: // under NT 0,0 is top left, and under PostScript 0,0 is bottom left.
571: // also, we should output a moveto command even if we are at the
572: // current location, if a path does not exist.
573:
574: if ((pptl->x != pdev->cgs.ptlCurPos.x) ||
575: (pptl->y != pdev->cgs.ptlCurPos.y) ||
576: (!(pdev->cgs.dwFlags & CGS_PATHEXISTS)))
577: {
578: ptpsfx.x = X72DPI(pptl->x);
579: ptpsfx.y = Y72DPI(pptl->y);
580:
581: // output PostScript user coordinates to the printer.
582:
583: PrintPSFIX(pdev, 2, ptpsfx.x, ptpsfx.y);
584: PrintString(pdev, " M\n");
585:
586: // save the new current position in device coordinates.
587:
588: pdev->cgs.ptlCurPos = *pptl;
589:
590: // state that a path now exists in the printer.
591:
592: pdev->cgs.dwFlags |= CGS_PATHEXISTS;
593: }
594: }
595:
596:
597: //--------------------------------------------------------------------------
598: // VOID ps_showpage(pdev)
599: // PDEVDATA pdev;
600: //
601: // This routine issues a showpage command to the printer, and resets
602: // the current graphics state (which is done in the printer by the
603: // showpage command).
604: //
605: // Parameters:
606: // pdev:
607: // Pointer to DEVDATA structure.
608: //
609: // Returns:
610: // This function returns no value.
611: //
612: // History:
613: // 01-May-1991 -by- Kent Settle (kentse)
614: // Wrote it.
615: //--------------------------------------------------------------------------
616:
617: VOID ps_showpage(pdev)
618: PDEVDATA pdev;
619: {
620: // output the eject command to the printer.
621:
622: PrintString(pdev, "showpage\n");
623:
624: init_cgs(pdev);
625: }
626:
627:
628: //--------------------------------------------------------------------------
629: // VOID init_cgs(pdev)
630: // PDEVDATA pdev;
631: //
632: // This routine is called to reset the current graphics state.
633: //
634: // Parameters:
635: // pdev:
636: // Pointer to DEVDATA structure.
637: //
638: // Returns:
639: // This function returns no value.
640: //
641: // History:
642: // 01-May-1991 -by- Kent Settle (kentse)
643: // Wrote it.
644: //--------------------------------------------------------------------------
645:
646: VOID init_cgs(pdev)
647: PDEVDATA pdev;
648: {
649: PCGS pcgs;
650: DWORD i;
651: DLFONT *pDLFont, *pDLFontSave;
652:
653: pcgs = &pdev->cgs;
654:
655: // save pointer to DLFONT structures.
656:
657: pDLFont = pdev->cgs.pDLFonts;
658: pDLFontSave = pDLFont;
659:
660: // if any downloaded fonts currently exist, free up their memory.
661:
662: if (pDLFont)
663: {
664: for (i = 0; i < pcgs->cDownloadedFonts; i++)
665: {
666: if (pDLFont->phgVector)
667: HeapFree(pdev->hheap, 0, (PVOID)pDLFont->phgVector);
668:
669: pDLFont++;
670: }
671: }
672:
673: // clear all the softfont downloading bits, if any softfonts.
674:
675: if (pcgs->pSFArray)
676: memset(pcgs->pSFArray, 0, ((pdev->cSoftFonts + 7) / 8));
677:
678: // initialize the entire structure to zero, then fill in the
679: // elements we care about.
680:
681: memset(pcgs, 0, sizeof(CGS));
682:
683: pcgs->lineattrs.fl = LA_GEOMETRIC;
684: pcgs->lineattrs.iJoin = JOIN_MITER;
685: pcgs->lineattrs.iEndCap = ENDCAP_BUTT;
686: pcgs->psfxLineWidth = 0;
687: pcgs->lineattrs.eMiterLimit = (FLOAT)10.0;
688: pcgs->ulColor = RGB_BLACK;
689: pcgs->FontXform.eM11 = (float)1.0;
690: pcgs->FontXform.eM22 = (float)1.0;
691: pcgs->GeoLineXform.eM11 = (float)1.0;
692: pcgs->GeoLineXform.eM22 = (float)1.0;
693: pcgs->psfxScaleFactor = LTOPSFX(10L);
694:
695: // restore pointer to DLFONT structures.
696:
697: pcgs->pDLFonts = pDLFontSave;
698: }
699:
700:
701: //--------------------------------------------------------------------------
702: // VOID ps_stroke(pdev, pbo, pptl)
703: // PDEVDATA pdev;
704: // BRUSHOBJ *pbo;
705: // PPOINTL pptl;
706: //
707: // This routine is called to stroke the current path.
708: //
709: // Parameters:
710: // pdev:
711: // Pointer to DEVDATA structure.
712: //
713: // pbo:
714: // Pointer to BRUSHOBJ to use for stroking.
715: //
716: // pptl:
717: // Pointer to POINTL to use for brush origin.
718: //
719: // Returns:
720: // This function returns no value.
721: //
722: // History:
723: // 03-May-1991 -by- Kent Settle (kentse)
724: // Wrote it.
725: //--------------------------------------------------------------------------
726:
727: VOID ps_stroke(pdev, pbo, pptl)
728: PDEVDATA pdev;
729: BRUSHOBJ *pbo;
730: PPOINTL pptl;
731: {
732: UNREFERENCED_PARAMETER(pptl);
733:
734: // stroke the path if it exists.
735:
736: if (pdev->cgs.dwFlags & CGS_PATHEXISTS)
737: {
738: //!!! check into a path buffer. - kentse.
739:
740: PrintString(pdev, "s\n");
741: }
742: #if DBG
743: else
744: DbgPrint("PSCRIPT!ps_stroke: stroking a non-existent path.\n");
745: #endif
746:
747: // the path gets destroyed in the printer, when it is stroked, so
748: // mark it as such.
749:
750: pdev->cgs.dwFlags &= ~CGS_PATHEXISTS;
751: }
752:
753:
754: //--------------------------------------------------------------------------
755: // VOID ps_lineto(pdev, pptl)
756: // PDEVDATA pdev;
757: // PPOINTL pptl;
758: //
759: // This routine is called by the driver to output a lineto command, as
760: // well as update the current position.
761: //
762: // Parameters:
763: // pdev:
764: // Pointer to DEVDATA structure.
765: //
766: // pptl:
767: // Pointer to PPOINTL defining new current position.
768: //
769: // Returns:
770: // This function returns no value.
771: //
772: // History:
773: // 03-May-1991 -by- Kent Settle (kentse)
774: // Wrote it.
775: //--------------------------------------------------------------------------
776:
777: VOID ps_lineto(pdev, pptl)
778: PDEVDATA pdev;
779: PPOINTL pptl;
780: {
781: POINTPSFX ptpsfx;
782:
783: // output the lineto command and set the new current position in
784: // the printer. remember to flip from top to bottom, since
785: // under NT 0,0 is top left, and under PostScript 0,0 is bottom left.
786:
787: if ((pptl->x != pdev->cgs.ptlCurPos.x) ||
788: (pptl->y != pdev->cgs.ptlCurPos.y))
789: {
790: ptpsfx.x = X72DPI(pptl->x);
791: ptpsfx.y = Y72DPI(pptl->y);
792:
793: // output the lineto command using PostScript user coordinates,
794: // then update the current position.
795:
796: PrintPSFIX(pdev, 2, ptpsfx.x, ptpsfx.y);
797: PrintString(pdev, " L\n");
798:
799: // save the new current position in device coordinates.
800:
801: pdev->cgs.ptlCurPos = *pptl;
802:
803: // mark that we do indeed have a path.
804:
805: pdev->cgs.dwFlags |= CGS_PATHEXISTS;
806: }
807: }
808:
809:
810: //--------------------------------------------------------------------------
811: // VOID ps_curveto(pdev, pptl, pptl1, pptl2)
812: // PDEVDATA pdev;
813: // PPOINTL pptl;
814: // PPOINTL pptl1;
815: // PPOINTL pptl2;
816: //
817: // This routine is called by the driver to output a curveto command as well
818: // as update the current position.
819: //
820: // Parameters:
821: // pdev:
822: // Pointer to DEVDATA structure.
823: //
824: // pptl, pptl1, pptl2:
825: // Pointer to PPOINTLs defining the bezier curve to output.
826: //
827: // Returns:
828: // This function returns no value.
829: //
830: // History:
831: // 03-May-1991 -by- Kent Settle (kentse)
832: // Wrote it.
833: //--------------------------------------------------------------------------
834:
835: VOID ps_curveto(pdev, pptl, pptl1, pptl2)
836: PDEVDATA pdev;
837: PPOINTL pptl;
838: PPOINTL pptl1;
839: PPOINTL pptl2;
840: {
841: POINTPSFX ptpsfx;
842: POINTPSFX ptpsfx1;
843: POINTPSFX ptpsfx2;
844:
845: // output the curveto command and set the new current position in
846: // the printer. remember to flip from top to bottom, since
847: // under NT 0,0 is top left, and under PostScript 0,0 is bottom left.
848:
849: ptpsfx.x = X72DPI(pptl->x);
850: ptpsfx.y = Y72DPI(pptl->y);
851: ptpsfx1.x = X72DPI(pptl1->x);
852: ptpsfx1.y = Y72DPI(pptl1->y);
853: ptpsfx2.x = X72DPI(pptl2->x);
854: ptpsfx2.y = Y72DPI(pptl2->y);
855:
856: // output the curveto command using PostScript user coordinates,
857: // then update the current position to be the last point on the curve.
858:
859: PrintPSFIX(pdev, 6, ptpsfx.x, ptpsfx.y, ptpsfx1.x, ptpsfx1.y,
860: ptpsfx2.x, ptpsfx2.y);
861: PrintString(pdev, " c\n");
862:
863: // save the new current position in device coordinates.
864:
865: pdev->cgs.ptlCurPos = *pptl2;
866:
867: // mark that we do indeed have a path.
868:
869: pdev->cgs.dwFlags |= CGS_PATHEXISTS;
870:
871: return;
872: }
873:
874:
875: //--------------------------------------------------------------------------
876: // VOID ps_fill(pdev, flFillMode)
877: // PDEVDATA pdev;
878: // FLONG flFillMode;
879: //
880: // This routine is called by the driver to output a fill command to
881: // the printer.
882: //
883: // Parameters:
884: // pdev:
885: // Pointer to DEVDATA structure.
886: //
887: // Returns:
888: // This function returns no value.
889: //
890: // History:
891: // 03-May-1991 -by- Kent Settle (kentse)
892: // Wrote it.
893: //--------------------------------------------------------------------------
894:
895: VOID ps_fill(pdev, flFillMode)
896: PDEVDATA pdev;
897: FLONG flFillMode;
898: {
899: // output the fill command if we have an existing path.
900:
901: if (pdev->cgs.dwFlags & CGS_PATHEXISTS)
902: {
903: //!!! check into path buffer. - kentse.
904:
905: if (flFillMode & FP_WINDINGMODE)
906: {
907: // output the PostScript fill command to do a winding mode fill.
908:
909: PrintString(pdev, "f\n");
910: }
911: else
912: {
913: // output the PostScript eofill command to do an even odd, or
914: // alternate fill.
915:
916: PrintString(pdev, "e\n");
917: }
918:
919: // the fill operator deletes the path, so mark it as such.
920:
921: pdev->cgs.dwFlags &= ~CGS_PATHEXISTS;
922: }
923: #if DBG
924: else
925: DbgPrint("PSCRIPT!ps_fill: filling non-existent path.\n");
926: #endif
927: }
928:
929:
930: //--------------------------------------------------------------------------
931: // VOID ps_closepath(pdev)
932: // PDEVDATA pdev;
933: //
934: // This routine is called to close the current path.
935: //
936: // Parameters:
937: // pdev:
938: // Pointer to DEVDATA structure.
939: //
940: // Returns:
941: // This function returns no value.
942: //
943: // History:
944: // 03-May-1991 -by- Kent Settle (kentse)
945: // Wrote it.
946: //--------------------------------------------------------------------------
947:
948: VOID ps_closepath(pdev)
949: PDEVDATA pdev;
950: {
951: // if a path exists, close it.
952:
953: if (pdev->cgs.dwFlags & CGS_PATHEXISTS)
954: PrintString(pdev, "cp\n");
955: }
956:
957:
958: //--------------------------------------------------------------------------
959: // PS_FIX psfxRGBtoGray(pbgr)
960: // BGR_PAL_ENTRY *pbgr;
961: //
962: // This routine is called to convert an RGB value to a gray scale.
963: //
964: // Parameters:
965: // ppe:
966: // pointer to PALETTEENTRY color to convert.
967: //
968: // Returns:
969: // This function returns PS_FIX gray scale value.
970: //
971: // History:
972: // 21-May-1991 -by- Kent Settle (kentse)
973: // Wrote it.
974: //--------------------------------------------------------------------------
975:
976:
977: PS_FIX psfxRGBtoGray(pbgr)
978: BGR_PAL_ENTRY *pbgr;
979: {
980: PS_FIX psfxRed, psfxGreen, psfxBlue, psfxGray;
981:
982: // The gray value is computed as a normalized average of the
983: // three color components. The resultant gray level should
984: // range from 0.0 to 1.0
985:
986: psfxRed = (ULONG)pbgr->bgrRed * PSFXPERCENT_RED;
987: psfxGreen = (ULONG)pbgr->bgrGreen * PSFXPERCENT_GREEN;
988: psfxBlue = (ULONG)pbgr->bgrBlue * PSFXPERCENT_BLUE;
989:
990: psfxGray = (PS_FIX)((psfxRed + psfxGreen + psfxBlue) / 255);
991:
992: return (psfxGray);
993: }
994:
995:
996: //--------------------------------------------------------------------------
997: // VOID ps_setlinewidth(pdev, psfxLineWidth)
998: // PDEVDATA pdev;
999: // PS_FIX psfxLineWidth;
1000: //
1001: // This routine is called by the driver to set the current geometric linewidth.
1002: // The line width is specified in USER coordinates (1/72 inch).
1003: //
1004: // Parameters:
1005: // pdev:
1006: // pointer to DEVDATA structure.
1007: //
1008: // psfxLineWidth:
1009: // linewidth to set.
1010: //
1011: // Returns:
1012: // This function returns no value.
1013: //
1014: // History:
1015: // 05-July-1991 -by- Kent Settle (kentse)
1016: // Wrote it.
1017: //--------------------------------------------------------------------------
1018:
1019: VOID ps_setlinewidth(pdev, psfxLineWidth)
1020: PDEVDATA pdev;
1021: PS_FIX psfxLineWidth;
1022: {
1023: // only update the linewidth if the new value differs from the old.
1024:
1025: if (pdev->cgs.psfxLineWidth != psfxLineWidth)
1026: {
1027: // update the linewidth in our current graphics state.
1028:
1029: pdev->cgs.psfxLineWidth = psfxLineWidth;
1030:
1031: // update the printer's linewidth.
1032:
1033: PrintPSFIX(pdev, 1, psfxLineWidth);
1034: PrintString(pdev, " sl\n");
1035: }
1036:
1037: return;
1038: }
1039:
1040:
1041: //--------------------------------------------------------------------------
1042: // BOOL ps_setlineattrs(pdev, plineattrs, pxo)
1043: // PDEVDATA pdev;
1044: // PLINEATTRS plineattrs;
1045: // XFORMOBJ *pxo;
1046: //
1047: // This routine is called by the driver to set the current line attributes.
1048: //
1049: // Parameters:
1050: // pdev:
1051: // pointer to DEVDATA structure.
1052: //
1053: // plineattrs:
1054: // line attributes to set.
1055: //
1056: // Returns:
1057: // This function returns no value.
1058: //
1059: // History:
1060: // 19-Mar-1992 -by- Kent Settle (kentse)
1061: // Wrote it.
1062: //--------------------------------------------------------------------------
1063:
1064: BOOL ps_setlineattrs(pdev, plineattrs, pxo)
1065: PDEVDATA pdev;
1066: PLINEATTRS plineattrs;
1067: XFORMOBJ *pxo;
1068: {
1069: ULONG iJoin;
1070: ULONG iEndCap;
1071: PS_FIX psfxMiterLimit;
1072: PS_FIX psfxStyle, psfxScale;
1073: PS_FIX psfxWidth;
1074: BOOL bDiffer;
1075: DWORD i;
1076: FLOAT *pfloat1;
1077: FLOAT *pfloat2;
1078: LONG *plong1;
1079: LONG *plong2;
1080:
1081: // there are several line attributes which have meaning for a
1082: // geometric line, but not for a cosmetic. set each of them, if
1083: // necessary.
1084:
1085: if (plineattrs->fl & LA_GEOMETRIC)
1086: {
1087: // update the line join value, if it differs from the old one.
1088:
1089: if (plineattrs->iJoin != pdev->cgs.lineattrs.iJoin)
1090: {
1091: // update the line join value in our current graphics state.
1092:
1093: pdev->cgs.lineattrs.iJoin = plineattrs->iJoin;
1094:
1095: // update the printer's line join.
1096:
1097: switch (plineattrs->iJoin)
1098: {
1099: case JOIN_BEVEL:
1100: iJoin = PSCRIPT_JOIN_BEVEL;
1101: break;
1102:
1103: case JOIN_ROUND:
1104: iJoin = PSCRIPT_JOIN_ROUND;
1105: break;
1106:
1107: default:
1108: iJoin = PSCRIPT_JOIN_MITER;
1109: break;
1110: }
1111:
1112: PrintDecimal(pdev, 1, iJoin);
1113: PrintString(pdev, " j\n");
1114: }
1115:
1116: // update the end cap value, if it differs from the old one.
1117:
1118: if (plineattrs->iEndCap != pdev->cgs.lineattrs.iEndCap)
1119: {
1120: // update the end cap value in our current graphics state.
1121:
1122: pdev->cgs.lineattrs.iEndCap = plineattrs->iEndCap;
1123:
1124: // update the printer's end cap value.
1125:
1126: switch (plineattrs->iEndCap)
1127: {
1128: case ENDCAP_SQUARE:
1129: iEndCap = PSCRIPT_ENDCAP_SQUARE;
1130: break;
1131:
1132: case ENDCAP_ROUND:
1133: iEndCap = PSCRIPT_ENDCAP_ROUND;
1134: break;
1135:
1136: default:
1137: iEndCap = PSCRIPT_ENDCAP_BUTT;
1138: break;
1139: }
1140:
1141: PrintDecimal(pdev, 1, iEndCap);
1142: PrintString(pdev, " setlinecap\n");
1143: }
1144:
1145: // a miter limit less than one does not make sense. rather than
1146: // returning an error in this case, just default to one.
1147:
1148: plineattrs->eMiterLimit = max(plineattrs->eMiterLimit, (FLOAT)1.0);
1149:
1150: // update the miter limit value, if it differs from the old one.
1151:
1152: if (plineattrs->eMiterLimit != pdev->cgs.lineattrs.eMiterLimit)
1153: {
1154: // update the miter limit value in our current graphics state.
1155:
1156: pdev->cgs.lineattrs.eMiterLimit = plineattrs->eMiterLimit;
1157:
1158: // update the printer's miter limit value.
1159:
1160: psfxMiterLimit = ETOPSFX(plineattrs->eMiterLimit);
1161: PrintPSFIX(pdev, 1, psfxMiterLimit);
1162: PrintString(pdev, " setmiterlimit\n");
1163: }
1164:
1165: // update the geometric line width, if it differs from the old one.
1166: // we use pdev->cgs.psfxLineWidth to check against rather than
1167: // pdev->cgs.lineattrs.elWidth.e since we need to set the line width
1168: // at times in the driver when we do not have access to the
1169: // current transform to go from WORLD to DEVICE coordinates.
1170:
1171: psfxWidth = (ETOPSFX(plineattrs->elWidth.e) * PS_RESOLUTION) /
1172: pdev->psdm.dm.dmPrintQuality;
1173:
1174: if (psfxWidth != pdev->cgs.psfxLineWidth)
1175: {
1176: // update the line width value in our current graphics state.
1177:
1178: pdev->cgs.psfxLineWidth = psfxWidth;
1179:
1180: // update the printer's linewidth. the linewidth is specified
1181: // in user coordinates.
1182:
1183: PrintPSFIX(pdev, 1, psfxWidth);
1184: PrintString(pdev, " sl\n");
1185: }
1186:
1187: // time to deal with the line style. note: we don't want to output
1188: // the style code unless something about the style has actually
1189: // changed. specifically, only if the cStyle, elStyleState, or any element
1190: // of the array has changed will we output the code to change the
1191: // style.
1192:
1193: bDiffer = FALSE; // assume style the same.
1194:
1195: if ((plineattrs->cstyle != pdev->cgs.lineattrs.cstyle) ||
1196: (plineattrs->elStyleState.e != pdev->cgs.lineattrs.elStyleState.e))
1197: bDiffer = TRUE;
1198:
1199: if (!bDiffer)
1200: {
1201: pfloat1 = (FLOAT *)plineattrs->pstyle;
1202: pfloat2 = (FLOAT *)pdev->cgs.lineattrs.pstyle;
1203:
1204: #if DBG
1205: if ((plineattrs->cstyle == 0) && (plineattrs->pstyle != NULL))
1206: {
1207: RIP("PSCRIPT!ps_setlineattrs: cstyle == 0, but pstyle != NULL.\n");
1208: return(FALSE);
1209: }
1210: #endif
1211:
1212: for (i = 0; i < plineattrs->cstyle; i++)
1213: {
1214: if (*pfloat1++ != *pfloat2++)
1215: {
1216: bDiffer = TRUE;
1217: break;
1218: }
1219: }
1220: }
1221:
1222: // now change the line style in the printer, if something about
1223: // it has changed.
1224:
1225: if (bDiffer)
1226: {
1227: // handle the solid line case.
1228:
1229: if ((plineattrs->pstyle == NULL) || (plineattrs->cstyle == 0))
1230: PrintString(pdev, "[]0 sd\n");
1231: else // not a solid line.
1232: {
1233: PrintString(pdev, "[");
1234:
1235: pfloat1 = (FLOAT *)plineattrs->pstyle;
1236:
1237: for (i = 0; i < plineattrs->cstyle; i++)
1238: {
1239: psfxStyle = LTOPSFX((ETOL(*pfloat1++)) * PS_RESOLUTION) /
1240: pdev->psdm.dm.dmPrintQuality;
1241:
1242: PrintPSFIX(pdev, 1, psfxStyle);
1243: PrintString(pdev, " ");
1244: }
1245:
1246: PrintString(pdev, "]");
1247:
1248: // output the style state in user coordinates.
1249:
1250: psfxStyle = LTOPSFX((ETOL(plineattrs->elStyleState.e)) * PS_RESOLUTION) /
1251: pdev->psdm.dm.dmPrintQuality;
1252:
1253: PrintPSFIX(pdev, 1, psfxStyle);
1254: PrintString(pdev, " sd\n");
1255: }
1256:
1257: // something in the lineattrs may have changed, update the cgs.
1258:
1259: if (pdev->cgs.lineattrs.pstyle)
1260: HeapFree(pdev->hheap, 0, (PVOID)pdev->cgs.lineattrs.pstyle);
1261:
1262: pdev->cgs.lineattrs = *plineattrs;
1263:
1264: // allocate space to copy the style array to.
1265:
1266: if (!(pfloat1 = (FLOAT *)HeapAlloc(pdev->hheap, 0,
1267: sizeof(FLOAT) * plineattrs->cstyle)))
1268: {
1269: RIP("PSCRIPT!ps_setlineattrs: HeapAlloc for pfloat1 failed.\n");
1270: return(FALSE);
1271: }
1272:
1273: // copy the style array itself.
1274:
1275: pfloat2 = (FLOAT *)plineattrs->pstyle;
1276: pdev->cgs.lineattrs.pstyle = (PFLOAT_LONG)pfloat1;
1277:
1278: for (i = 0; i < plineattrs->cstyle; i++)
1279: *pfloat1++ = *pfloat2++;
1280: }
1281: }
1282: else // cosmetic lines.
1283: {
1284: // now handle cosmetic lines. iJoin, iEndCap and eMiterLimit make
1285: // no sense for cosmetic lines, so we won't worry about them.
1286:
1287: psfxWidth = LTOPSFX(plineattrs->elWidth.l * PS_RESOLUTION) /
1288: pdev->psdm.dm.dmPrintQuality;
1289:
1290: // update the cosmetic line width, if it differs from the old one.
1291: // we use pdev->cgs.psfxLineWidth to check against rather than
1292: // pdev->cgs.lineattrs.elWidth.e since we need to set the line width
1293: // at times in the driver when we do not have access to the
1294: // current transform to go from WORLD to DEVICE coordinates.
1295:
1296: if (psfxWidth != pdev->cgs.psfxLineWidth)
1297: {
1298: // update the line width value in our current graphics state.
1299:
1300: pdev->cgs.psfxLineWidth = psfxWidth;
1301:
1302: // update the printer's linewidth. the linewidth is specified
1303: // in user coordinates.
1304:
1305: PrintPSFIX(pdev, 1, psfxWidth);
1306: PrintString(pdev, " sl\n");
1307: }
1308:
1309: // the LA_ALTERNATE linestyle is a special cosmetic line style, where
1310: // every other pel is on. well, if we have a printer with 2500 dpi,
1311: // do we really want every other pel on? i don't think so. so,
1312: // for now at least, we will simply turn on every other user coordinate
1313: // pel.
1314:
1315: if (plineattrs->fl & LA_ALTERNATE)
1316: {
1317: //!!! perhaps we really want to do a .5 setgray. what about color. -kentse.
1318:
1319: PrintString(pdev, "[1] ");
1320: psfxStyle = LTOPSFX(plineattrs->elStyleState.l * PS_RESOLUTION) /
1321: pdev->psdm.dm.dmPrintQuality;
1322:
1323: PrintPSFIX(pdev, 1, psfxStyle);
1324: PrintString(pdev, " sd\n");
1325: }
1326: else
1327: {
1328: // time to deal with the line style. note: we don't want to output
1329: // the style code unless something about the style has actually
1330: // changed. specifically, only if the cStyle, elStyleState, or any element
1331: // of the array has changed will we output the code to change the
1332: // style.
1333:
1334: bDiffer = FALSE; // assume style the same.
1335:
1336: if ((plineattrs->cstyle != pdev->cgs.lineattrs.cstyle) ||
1337: (plineattrs->elStyleState.l != pdev->cgs.lineattrs.elStyleState.l))
1338: bDiffer = TRUE;
1339:
1340: if (!bDiffer)
1341: {
1342: plong1 = (LONG *)plineattrs->pstyle;
1343: plong2 = (LONG *)pdev->cgs.lineattrs.pstyle;
1344:
1345: #if DBG
1346: if ((plineattrs->cstyle == 0) && (plineattrs->pstyle != NULL))
1347: {
1348: RIP("PSCRIPT!ps_setlineattrs: cstyle == 0, but pstyle != NULL.\n");
1349: return(FALSE);
1350: }
1351: #endif
1352:
1353: for (i = 0; i < plineattrs->cstyle; i++)
1354: {
1355: if (*plong1++ != *plong2++)
1356: {
1357: bDiffer = TRUE;
1358: break;
1359: }
1360: }
1361: }
1362:
1363: // now change the line style in the printer, if something about
1364: // it has changed.
1365:
1366: if (bDiffer)
1367: {
1368: // handle the solid line case.
1369:
1370: if ((plineattrs->pstyle == NULL) || (plineattrs->cstyle == 0))
1371: PrintString(pdev, "[]0 sd\n");
1372: else // not a solid line.
1373: {
1374: PrintString(pdev, "[");
1375:
1376: plong1 = (LONG *)plineattrs->pstyle;
1377:
1378: // get style scaling factor.
1379:
1380: psfxScale = LTOPSFX(pdev->psdm.dm.dmPrintQuality / 25);
1381: psfxScale = (psfxScale * PS_RESOLUTION) /
1382: pdev->psdm.dm.dmPrintQuality;
1383:
1384: for (i = 0; i < plineattrs->cstyle; i++)
1385: {
1386: psfxStyle = (*plong1++) * psfxScale;
1387:
1388: PrintPSFIX(pdev, 1, psfxStyle);
1389: PrintString(pdev, " ");
1390: }
1391:
1392: PrintString(pdev, "]");
1393: psfxStyle = plineattrs->elStyleState.l * psfxScale;
1394:
1395: PrintPSFIX(pdev, 1, psfxStyle);
1396: PrintString(pdev, " sd\n");
1397: }
1398:
1399: // something in the lineattrs may have changed, update the cgs.
1400:
1401: if (pdev->cgs.lineattrs.pstyle)
1402: HeapFree(pdev->hheap, 0, (PVOID)pdev->cgs.lineattrs.pstyle);
1403:
1404: pdev->cgs.lineattrs = *plineattrs;
1405:
1406: // allocate space to copy the style array to.
1407:
1408: if (!(plong1 = (LONG *)HeapAlloc(pdev->hheap, 0,
1409: sizeof(LONG) * plineattrs->cstyle)))
1410: {
1411: RIP("PSCRIPT!ps_setlineattrs: HeapAlloc for plong1 failed.\n");
1412: return(FALSE);
1413: }
1414:
1415: // copy the style array itself.
1416:
1417: plong2 = (LONG *)plineattrs->pstyle;
1418: pdev->cgs.lineattrs.pstyle = (PFLOAT_LONG)plong1;
1419:
1420: for (i = 0; i < plineattrs->cstyle; i++)
1421: *plong1++ = *plong2++;
1422: }
1423: }
1424:
1425: }
1426:
1427: return(TRUE);
1428: }
1429:
1430:
1431: //--------------------------------------------------------------------------
1432: // VOID ps_geolinexform(pdev, plineattrs, pxo)
1433: // PDEVDATA pdev;
1434: // PLINEATTRS plineattrs;
1435: // XFORMOBJ *pxo;
1436: //
1437: // This routine is called by the driver to set the current line attributes.
1438: //
1439: // Parameters:
1440: // pdev:
1441: // pointer to DEVDATA structure.
1442: //
1443: // plineattrs:
1444: // line attributes to set.
1445: //
1446: // Returns:
1447: // This function returns no value.
1448: //
1449: // History:
1450: // 12-Mar-1993 -by- Kent Settle (kentse)
1451: // Wrote it.
1452: //--------------------------------------------------------------------------
1453:
1454: VOID ps_geolinexform(pdev, plineattrs, pxo)
1455: PDEVDATA pdev;
1456: PLINEATTRS plineattrs;
1457: XFORMOBJ *pxo;
1458: {
1459: ULONG ulComplexity;
1460: PS_FIX psfxM11, psfxM12, psfxM21, psfxM22, psfxdx, psfxdy;
1461:
1462: // update the printer's geometric line width. the line width
1463: // is given in WORLD coordinates for a geometric line. it needs
1464: // to be transformed into DEVICE space.
1465:
1466: ulComplexity = XFORMOBJ_iGetXform(pxo, &pdev->cgs.GeoLineXform);
1467:
1468: // assume no transform will be done.
1469:
1470: pdev->cgs.dwFlags &= ~CGS_GEOLINEXFORM;
1471:
1472: switch(ulComplexity)
1473: {
1474: case GX_IDENTITY:
1475: // there will be nothing to do in this case.
1476:
1477: break;
1478:
1479: case GX_SCALE:
1480: // output scale command, rather than entire transform.
1481:
1482: psfxM11 = ETOPSFX(pdev->cgs.GeoLineXform.eM11);
1483:
1484: psfxM22 = ETOPSFX(pdev->cgs.GeoLineXform.eM22);
1485:
1486: // save the current CTM, then output the scale command.
1487: // DrvStrokePath and DrvStrokeAndFillPath are
1488: // responsible for restoring the CTM.
1489:
1490: PrintString(pdev, "CM ");
1491: PrintPSFIX(pdev, 2, psfxM11, psfxM22);
1492: PrintString(pdev, " scale\n");
1493:
1494: pdev->cgs.dwFlags |= CGS_GEOLINEXFORM;
1495:
1496: break;
1497:
1498: default:
1499: // output a general transform.
1500:
1501: psfxM11 = ETOPSFX(pdev->cgs.GeoLineXform.eM11);
1502:
1503: psfxM12 = ETOPSFX(pdev->cgs.GeoLineXform.eM12);
1504:
1505: psfxM21 = ETOPSFX(pdev->cgs.GeoLineXform.eM21);
1506:
1507: psfxM22 = ETOPSFX(pdev->cgs.GeoLineXform.eM22);
1508:
1509: psfxdx = ETOPSFX(pdev->cgs.GeoLineXform.eDx);
1510:
1511: psfxdy = ETOPSFX(pdev->cgs.GeoLineXform.eDy);
1512:
1513: // save the current CTM, then output the concat command.
1514: // DrvStrokePath and DrvStrokeAndFillPath are
1515: // responsible for restoring the CTM.
1516:
1517: PrintString(pdev, "CM ");
1518: PrintString(pdev, "[");
1519: PrintPSFIX(pdev, 6, psfxM11, psfxM12, psfxM21, psfxM22,
1520: psfxdx, psfxdy);
1521: PrintString(pdev, "] concat\n");
1522:
1523: pdev->cgs.dwFlags |= CGS_GEOLINEXFORM;
1524:
1525: break;
1526: }
1527: }
1528:
1529: //--------------------------------------------------------------------------
1530: // VOID ps_begin_eps(pdev)
1531: // VOID ps_end_eps(pdev)
1532: //
1533: // These routines are called by the driver to issue commands to bracket EPS
1534: // files to the printer. They conform to the Guidelines for Importing EPS
1535: // Files version 3.0 by Adobe.
1536: //
1537: // Parameters:
1538: // pdev:
1539: // pointer to DEVDATA structure.
1540: //
1541: // Returns:
1542: // None.
1543: //
1544: // History:
1545: // Sat May 08 15:15:01 1993 -by- Hock San Lee [hockl]
1546: // Wrote it.
1547: //--------------------------------------------------------------------------
1548:
1549: PSZ apszEPSProc[] =
1550: {
1551: "/BeginEPSF {/b4_Inc_state save def /dict_count countdictstack def",
1552: "/op_count count 1 sub def userdict begin /showpage {} def",
1553: "0 setgray 0 setlinecap 1 setlinewidth 0 setlinejoin",
1554: "10 setmiterlimit [] 0 setdash newpath",
1555: "/languagelevel where {pop languagelevel 1 ne",
1556: "{false setstrokeadjust false setoverprint} if } if } bind def",
1557: "/EndEPSF {count op_count sub {pop} repeat",
1558: "countdictstack dict_count sub {end} repeat b4_Inc_state restore} bind def",
1559: NULL
1560: };
1561:
1562: VOID ps_begin_eps(pdev)
1563: PDEVDATA pdev;
1564: {
1565: PSZ *ppsz;
1566:
1567: // emit the EPS procedures if necessary.
1568:
1569: if (!(pdev->cgs.dwFlags & CGS_EPS_PROC))
1570: {
1571: ppsz = apszEPSProc;
1572: while (*ppsz)
1573: {
1574: PrintString(pdev, *ppsz++);
1575: PrintString(pdev, "\n");
1576: }
1577:
1578: pdev->cgs.dwFlags |= CGS_EPS_PROC;
1579: }
1580:
1581: PrintString(pdev, "BeginEPSF\n");
1582: }
1583:
1584: VOID ps_end_eps(pdev)
1585: PDEVDATA pdev;
1586: {
1587: if (!(pdev->cgs.dwFlags & CGS_EPS_PROC))
1588: {
1589: RIP("PSCRIPT!ps_end_eps: EndEPSF not defined.\n");
1590: }
1591:
1592: PrintString(pdev, "EndEPSF\n");
1593: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.