![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to output.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 output.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 root 1: //--------------------------------------------------------------------------
2: //
3: // Module Name: OUTPUT.C
4: //
5: // Brief Description: This module contains the PSCRIPT driver's output
6: // functions and related routines.
7: //
8: // Author: Kent Settle (kentse)
9: // Created: 20-Nov-1990
10: //
11: // Copyright (c) 1990 - 1993 Microsoft Corporation
12: //
13: // This routine contains routines to handle opening, writing to, and
14: // closing the output channel.
15: //--------------------------------------------------------------------------
16:
17: #include "stdlib.h"
18: #include "pscript.h"
19: #include "enable.h"
20: #include "stdarg.h"
21:
22: // external declarations.
23:
24: extern BOOL bOutputHeader(PDEVDATA);
25:
26: // declarations of routines residing within this module.
27:
28: DWORD PSFIXToBuffer(CHAR *, PS_FIX);
29:
30: // we are using PS_FIX numbers, which are 24.8. therefore, there are only
31: // 256 possible fractional values, so here is a table containing their
32: // ASCII equivalents.
33:
34: static char *Fracs[] =
35: {
36: "", // 0.00000 0 / 256.
37: "004", // 0.00391 1 / 256.
38: "008", // 0.00781 2 / 256.
39: "012", // 0.01172 3 / 256.
40: "016", // 0.01563 4 / 256.
41: "020", // 0.01953 5 / 256.
42: "023", // 0.02344 6 / 256.
43: "027", // 0.02734 7 / 256.
44: "031", // 0.03125 8 / 256.
45: "035", // 0.03516 9 / 256.
46: "039", // 0.03906 10 / 256.
47: "043", // 0.04297 11 / 256.
48: "047", // 0.04688 12 / 256.
49: "051", // 0.05078 13 / 256.
50: "055", // 0.05469 14 / 256.
51: "059", // 0.05859 15 / 256.
52: "063", // 0.06250 16 / 256.
53: "066", // 0.06641 17 / 256.
54: "070", // 0.07031 18 / 256.
55: "074", // 0.07422 19 / 256.
56: "078", // 0.07813 20 / 256.
57: "082", // 0.08203 21 / 256.
58: "086", // 0.08594 22 / 256.
59: "090", // 0.08984 23 / 256.
60: "094", // 0.09375 24 / 256.
61: "098", // 0.09766 25 / 256.
62: "102", // 0.10156 26 / 256.
63: "105", // 0.10547 27 / 256.
64: "109", // 0.10938 28 / 256.
65: "113", // 0.11328 29 / 256.
66: "117", // 0.11719 30 / 256.
67: "121", // 0.12109 31 / 256.
68: "125", // 0.12500 32 / 256.
69: "129", // 0.12891 33 / 256.
70: "133", // 0.13281 34 / 256.
71: "137", // 0.13672 35 / 256.
72: "141", // 0.14063 36 / 256.
73: "145", // 0.14453 37 / 256.
74: "148", // 0.14844 38 / 256.
75: "152", // 0.15234 39 / 256.
76: "156", // 0.15625 40 / 256.
77: "160", // 0.16016 41 / 256.
78: "164", // 0.16406 42 / 256.
79: "168", // 0.16797 43 / 256.
80: "172", // 0.17188 44 / 256.
81: "176", // 0.17578 45 / 256.
82: "180", // 0.17969 46 / 256.
83: "184", // 0.18359 47 / 256.
84: "188", // 0.18750 48 / 256.
85: "191", // 0.19141 49 / 256.
86: "195", // 0.19531 50 / 256.
87: "199", // 0.19922 51 / 256.
88: "203", // 0.20313 52 / 256.
89: "207", // 0.20703 53 / 256.
90: "211", // 0.21094 54 / 256.
91: "215", // 0.21484 55 / 256.
92: "219", // 0.21875 56 / 256.
93: "223", // 0.22266 57 / 256.
94: "227", // 0.22656 58 / 256.
95: "230", // 0.23047 59 / 256.
96: "234", // 0.23438 60 / 256.
97: "238", // 0.23828 61 / 256.
98: "242", // 0.24219 62 / 256.
99: "246", // 0.24609 63 / 256.
100: "25", // 0.25000 64 / 256.
101: "254", // 0.25391 65 / 256.
102: "258", // 0.25781 66 / 256.
103: "262", // 0.26172 67 / 256.
104: "266", // 0.26563 68 / 256.
105: "270", // 0.26953 69 / 256.
106: "273", // 0.27344 70 / 256.
107: "277", // 0.27734 71 / 256.
108: "281", // 0.28125 72 / 256.
109: "285", // 0.28516 73 / 256.
110: "289", // 0.28906 74 / 256.
111: "293", // 0.29297 75 / 256.
112: "297", // 0.29688 76 / 256.
113: "301", // 0.30078 77 / 256.
114: "305", // 0.30469 78 / 256.
115: "309", // 0.30859 79 / 256.
116: "313", // 0.31250 80 / 256.
117: "316", // 0.31641 81 / 256.
118: "320", // 0.32031 82 / 256.
119: "324", // 0.32422 83 / 256.
120: "328", // 0.32813 84 / 256.
121: "332", // 0.33203 85 / 256.
122: "336", // 0.33594 86 / 256.
123: "340", // 0.33984 87 / 256.
124: "344", // 0.34375 88 / 256.
125: "348", // 0.34766 89 / 256.
126: "352", // 0.35156 90 / 256.
127: "355", // 0.35547 91 / 256.
128: "359", // 0.35938 92 / 256.
129: "363", // 0.36328 93 / 256.
130: "367", // 0.36719 94 / 256.
131: "371", // 0.37109 95 / 256.
132: "375", // 0.37500 96 / 256.
133: "379", // 0.37891 97 / 256.
134: "383", // 0.38281 98 / 256.
135: "387", // 0.38672 99 / 256.
136: "391", // 0.39063 100 / 256.
137: "394", // 0.39453 101 / 256.
138: "398", // 0.39844 102 / 256.
139: "402", // 0.40234 103 / 256.
140: "406", // 0.40625 104 / 256.
141: "410", // 0.41016 105 / 256.
142: "414", // 0.41406 106 / 256.
143: "418", // 0.41797 107 / 256.
144: "422", // 0.42188 108 / 256.
145: "426", // 0.42578 109 / 256.
146: "430", // 0.42969 110 / 256.
147: "434", // 0.43359 111 / 256.
148: "438", // 0.43750 112 / 256.
149: "441", // 0.44141 113 / 256.
150: "445", // 0.44531 114 / 256.
151: "449", // 0.44922 115 / 256.
152: "453", // 0.45313 116 / 256.
153: "457", // 0.45703 117 / 256.
154: "461", // 0.46094 118 / 256.
155: "465", // 0.46484 119 / 256.
156: "469", // 0.46875 120 / 256.
157: "473", // 0.47266 121 / 256.
158: "477", // 0.47656 122 / 256.
159: "480", // 0.48047 123 / 256.
160: "484", // 0.48438 124 / 256.
161: "488", // 0.48828 125 / 256.
162: "492", // 0.49219 126 / 256.
163: "496", // 0.49609 127 / 256.
164: "5", // 0.50000 128 / 256.
165: "504", // 0.50391 129 / 256.
166: "508", // 0.50781 130 / 256.
167: "512", // 0.51172 131 / 256.
168: "516", // 0.51563 132 / 256.
169: "520", // 0.51953 133 / 256.
170: "523", // 0.52344 134 / 256.
171: "527", // 0.52734 135 / 256.
172: "531", // 0.53125 136 / 256.
173: "535", // 0.53516 137 / 256.
174: "539", // 0.53906 138 / 256.
175: "543", // 0.54297 139 / 256.
176: "547", // 0.54688 140 / 256.
177: "551", // 0.55078 141 / 256.
178: "555", // 0.55469 142 / 256.
179: "559", // 0.55859 143 / 256.
180: "563", // 0.56250 144 / 256.
181: "566", // 0.56641 145 / 256.
182: "570", // 0.57031 146 / 256.
183: "574", // 0.57422 147 / 256.
184: "578", // 0.57813 148 / 256.
185: "582", // 0.58203 149 / 256.
186: "586", // 0.58594 150 / 256.
187: "590", // 0.58984 151 / 256.
188: "594", // 0.59375 152 / 256.
189: "598", // 0.59766 153 / 256.
190: "602", // 0.60156 154 / 256.
191: "605", // 0.60547 155 / 256.
192: "609", // 0.60938 156 / 256.
193: "613", // 0.61328 157 / 256.
194: "617", // 0.61719 158 / 256.
195: "621", // 0.62109 159 / 256.
196: "625", // 0.62500 160 / 256.
197: "629", // 0.62891 161 / 256.
198: "633", // 0.63281 162 / 256.
199: "637", // 0.63672 163 / 256.
200: "641", // 0.64063 164 / 256.
201: "645", // 0.64453 165 / 256.
202: "648", // 0.64844 166 / 256.
203: "652", // 0.65234 167 / 256.
204: "656", // 0.65625 168 / 256.
205: "660", // 0.66016 169 / 256.
206: "664", // 0.66406 170 / 256.
207: "668", // 0.66797 171 / 256.
208: "672", // 0.67188 172 / 256.
209: "676", // 0.67578 173 / 256.
210: "680", // 0.67969 174 / 256.
211: "684", // 0.68359 175 / 256.
212: "688", // 0.68750 176 / 256.
213: "691", // 0.69141 177 / 256.
214: "691", // 0.69531 178 / 256.
215: "699", // 0.69922 179 / 256.
216: "703", // 0.70313 180 / 256.
217: "707", // 0.70703 181 / 256.
218: "711", // 0.71094 182 / 256.
219: "715", // 0.71484 183 / 256.
220: "719", // 0.71875 184 / 256.
221: "723", // 0.72266 185 / 256.
222: "727", // 0.72656 186 / 256.
223: "730", // 0.73047 187 / 256.
224: "734", // 0.73438 188 / 256.
225: "738", // 0.73828 189 / 256.
226: "742", // 0.74219 190 / 256.
227: "746", // 0.74609 191 / 256.
228: "75", // 0.75000 192 / 256.
229: "754", // 0.75391 193 / 256.
230: "758", // 0.75781 194 / 256.
231: "762", // 0.76172 195 / 256.
232: "766", // 0.76563 196 / 256.
233: "770", // 0.76953 197 / 256.
234: "773", // 0.77344 198 / 256.
235: "777", // 0.77734 199 / 256.
236: "781", // 0.78125 200 / 256.
237: "785", // 0.78516 201 / 256.
238: "789", // 0.78906 202 / 256.
239: "793", // 0.79297 203 / 256.
240: "797", // 0.79688 204 / 256.
241: "801", // 0.80078 205 / 256.
242: "805", // 0.80469 206 / 256.
243: "809", // 0.80859 207 / 256.
244: "813", // 0.81250 208 / 256.
245: "816", // 0.81641 209 / 256.
246: "820", // 0.82031 210 / 256.
247: "824", // 0.82422 211 / 256.
248: "828", // 0.82813 212 / 256.
249: "832", // 0.83203 213 / 256.
250: "836", // 0.83594 214 / 256.
251: "840", // 0.83984 215 / 256.
252: "844", // 0.84375 216 / 256.
253: "848", // 0.84766 217 / 256.
254: "852", // 0.85156 218 / 256.
255: "856", // 0.85547 219 / 256.
256: "859", // 0.85938 220 / 256.
257: "863", // 0.86328 221 / 256.
258: "867", // 0.86719 222 / 256.
259: "871", // 0.87109 223 / 256.
260: "875", // 0.87500 224 / 256.
261: "879", // 0.87891 225 / 256.
262: "883", // 0.88281 226 / 256.
263: "887", // 0.88672 227 / 256.
264: "891", // 0.89063 228 / 256.
265: "895", // 0.89453 229 / 256.
266: "898", // 0.89844 230 / 256.
267: "902", // 0.90234 231 / 256.
268: "906", // 0.90625 232 / 256.
269: "910", // 0.91016 233 / 256.
270: "914", // 0.91406 234 / 256.
271: "918", // 0.91797 235 / 256.
272: "922", // 0.92188 236 / 256.
273: "926", // 0.92578 237 / 256.
274: "930", // 0.92969 238 / 256.
275: "934", // 0.93359 239 / 256.
276: "938", // 0.93750 240 / 256.
277: "941", // 0.94141 241 / 256.
278: "945", // 0.94531 242 / 256.
279: "949", // 0.94922 243 / 256.
280: "953", // 0.95313 244 / 256.
281: "957", // 0.95703 245 / 256.
282: "961", // 0.96094 246 / 256.
283: "965", // 0.96484 247 / 256.
284: "969", // 0.96875 248 / 256.
285: "973", // 0.97266 249 / 256.
286: "977", // 0.97656 250 / 256.
287: "980", // 0.98047 251 / 256.
288: "984", // 0.98438 252 / 256.
289: "988", // 0.98828 253 / 256.
290: "992", // 0.99219 254 / 256.
291: "996" // 0.99609 255 / 256.
292: };
293:
294: #define LOCAL_BUFFER_SIZE 64
295:
296:
297: //--------------------------------------------------------------------------
298: // BOOL PrintString(pdev, psz)
299: // PDEVDATA pdev;
300: // PSZ psz;
301: //
302: // This routine takes cNumbers of decimal numbers and outputs them to
303: // the printers, with a space following each number.
304: //
305: // Parameters:
306: // pdev:
307: // pointer to DEVDATA structure.
308: //
309: // cNumbers:
310: // count of decimal numbers to output.
311: //
312: // iStack:
313: // place holder for parameters on stack.
314: //
315: // Returns:
316: // This function returns TRUE if the numbers were sent out, else FALSE.
317: //
318: // History:
319: // 08-Nov-1991 -by- Kent Settle (kentse)
320: // Wrote it.
321: //--------------------------------------------------------------------------
322:
323: BOOL PrintString(pdev, psz)
324: PDEVDATA pdev;
325: PSZ psz;
326: {
327: // simply send the string to the printer. yes, we want strlen bytes
328: // passed to bPSWrite. we don't want the NULL terminator.
329:
330: return(bPSWrite(pdev, psz, strlen(psz)));
331: }
332:
333:
334: //--------------------------------------------------------------------------
335: // BOOL PrintDecimal(pdev, cNumbers, ...)
336: // PDEVDATA pdev;
337: // DWORD cNumbers;
338: //
339: // This routine takes cNumbers of decimal numbers and outputs them to
340: // the printers, with a space following each number.
341: //
342: // Parameters:
343: // pdev:
344: // pointer to DEVDATA structure.
345: //
346: // cNumbers:
347: // count of decimal numbers to output.
348: //
349: // iStack:
350: // place holder for parameters on stack.
351: //
352: // Returns:
353: // This function returns TRUE if the numbers were sent out, else FALSE.
354: //
355: // History:
356: // 08-Nov-1991 -by- Kent Settle (kentse)
357: // Wrote it.
358: //--------------------------------------------------------------------------
359:
360: BOOL PrintDecimal(
361: PDEVDATA pdev,
362: DWORD cNumbers,
363: ...
364: )
365: {
366: CHAR Buffer[LOCAL_BUFFER_SIZE];
367: CHAR *pBuffer;
368: DWORD cb = 0;
369: DWORD cbTotal = 0;
370: LONG lNum;
371: va_list pvarg;
372:
373: // initialize some pointers.
374:
375: pBuffer = Buffer;
376: va_start(pvarg, cNumbers);
377:
378: while (cNumbers--)
379: {
380: // get the next decimal number from the stack, convert it to
381: // ASCII and put it into the output buffer.
382:
383: lNum = va_arg(pvarg, LONG);
384: itoa(lNum, pBuffer, 10);
385:
386: // how many characters, excluding the NULL terminator, did we place
387: // into the output buffer.
388:
389: cb = strlen(pBuffer);
390: if ((cbTotal + cb) >= (LOCAL_BUFFER_SIZE - 1))
391: {
392: RIP("PSCRIPT!PrintDecimal: overran the output buffer.\n");
393: SetLastError(ERROR_BUFFER_OVERFLOW);
394: return(FALSE);
395: }
396:
397: // update the buffer pointer.
398:
399: pBuffer += cb;
400:
401: // output the trailing space.
402:
403: if (cNumbers >= 1)
404: {
405: *pBuffer++ = ' '; // overwrites NULL terminator from itoa.
406: cb++;
407: }
408:
409: // update the total bytes to buffer counter.
410:
411: cbTotal += cb;
412: }
413:
414: // we have now build the entire string in our local output buffer.
415: // send it out to the printer.
416:
417: return(bPSWrite(pdev, Buffer, cbTotal));
418: }
419:
420:
421: //--------------------------------------------------------------------------
422: // BOOL PrintPSFIX(pdev, cNumbers, iStack)
423: // PDEVDATA pdev;
424: // DWORD cNumbers;
425: // DWORD iStack;
426: //
427: // This routine takes cNumbers of PS_FIX numbers and outputs them to
428: // the printers, with a space following each number.
429: //
430: // Parameters:
431: // pdev:
432: // pointer to DEVDATA structure.
433: //
434: // cNumbers:
435: // count of PS_FIX numbers to output.
436: //
437: // iStack:
438: // place holder for parameters on stack.
439: //
440: // Returns:
441: // This function returns TRUE if the numbers were sent out, else FALSE.
442: //
443: // History:
444: // 08-Nov-1991 -by- Kent Settle (kentse)
445: // Wrote it.
446: //--------------------------------------------------------------------------
447:
448: BOOL PrintPSFIX(
449: PDEVDATA pdev,
450: DWORD cNumbers,
451: ...
452: )
453: {
454: CHAR Buffer[LOCAL_BUFFER_SIZE];
455: CHAR *pBuffer;
456: PS_FIX psfxNum;
457: DWORD cb = 0;
458: DWORD cbTotal = 0;
459: va_list pvarg;
460:
461: // initialize some pointers.
462:
463: pBuffer = Buffer;
464: va_start(pvarg, cNumbers);
465:
466: while (cNumbers--)
467: {
468: // get the next PS_FIX number from the stack.
469:
470: psfxNum = (PS_FIX)va_arg(pvarg, LONG);
471:
472: cb = PSFIXToBuffer(pBuffer, psfxNum);
473:
474: pBuffer += cb;
475:
476: // output the trailing space if not last number in array.
477:
478: if (cNumbers >= 1)
479: {
480: *pBuffer++ = ' '; // overwrites NULL terminator from strcpy.
481: cb++;
482: }
483:
484: cbTotal += cb;
485: if (cbTotal >= (LOCAL_BUFFER_SIZE - 1))
486: {
487: RIP("PSCRIPT!PrintPSFIX: overran the output buffer.\n");
488: SetLastError(ERROR_BUFFER_OVERFLOW);
489: return(FALSE);
490: }
491: }
492:
493: // we have now built the entire string in our local output buffer.
494: // send it out to the printer.
495:
496: return(bPSWrite(pdev, Buffer, cbTotal));
497: }
498:
499:
500: //--------------------------------------------------------------------------
501: // BOOL bPSWrite(pdev, pbSrc, ulCount)
502: // PDEVDATA pdev;
503: // PBYTE pbSrc; // pointer to source to write to channel.
504: // ULONG ulCount; // length of pbSrc.
505: //
506: // This routine writes to the output buffer. When the output buffer
507: // becomes full, or the channel is closed, the buffer is flushed to the
508: // output channel.
509: //
510: // Parameters:
511: // pdev:
512: // pointer to DEVDATA structure.
513: //
514: // pbSrc:
515: // pointer to source, which gets written to the output buffer.
516: //
517: // ulCount:
518: // number of bytes in bpSrc.
519: //
520: // Returns:
521: // This function returns TRUE if the channel was successfully closed,
522: // FALSE otherwise.
523: //
524: // History:
525: // 20-Nov-1990 -by- Kent Settle (kentse)
526: // Wrote it.
527: //--------------------------------------------------------------------------
528:
529: BOOL bPSWrite(pdev, pbSrc, ulCount)
530: PDEVDATA pdev;
531: PBYTE pbSrc; // pointer to source to write to channel.
532: ULONG ulCount; // length of pbSrc.
533: {
534: ULONG ulFree; // free space in buffer.
535: PBYTE pbDst, pbSource;
536:
537: // output nothing if the document has been cancelled.
538:
539: if (pdev->dwFlags & PDEV_CANCELDOC)
540: return(TRUE);
541:
542: // output nothing if a startdoc call has not been issued.
543:
544: if (!(pdev->dwFlags & PDEV_STARTDOC))
545: return(TRUE);
546:
547: // get a local source pointer to munge with.
548:
549: pbSource = pbSrc;
550:
551: // output our header if it has not yet been done.
552:
553: bOutputHeader(pdev);
554:
555: while(ulCount > 0)
556: {
557: // get a local pointer to the current position in the buffer.
558:
559: pbDst = ((PBYTE)pdev->ioChannel.pBuffer) + pdev->ioChannel.ulBufCount;
560:
561: // get the current number of free bytes in the output buffer.
562:
563: ulFree = OUTPUT_BUFFER_SIZE - pdev->ioChannel.ulBufCount;
564:
565: // if the entire source will fit into the buffer, put it there.
566:
567: if (ulCount < ulFree)
568: {
569: // update the buffer counter.
570:
571: pdev->ioChannel.ulBufCount += ulCount;
572:
573: memcpy(pbDst, pbSource, ulCount);
574:
575: return(TRUE);
576: }
577: else
578: {
579:
580: // control comes here if the source will not fit into the
581: // buffer. copy ulFree bytes into the buffer, flush the
582: // buffer, and try again.
583:
584: ulCount -= ulFree;
585:
586: memcpy(pbDst, pbSource, ulFree);
587:
588: // update the source pointer.
589:
590: pbSource += ulFree;
591:
592: // set the buffer position holder to the end of the buffer.
593:
594: pdev->ioChannel.ulBufCount = OUTPUT_BUFFER_SIZE;
595:
596: // flush the buffer to the output channel. ulBufCount
597: // get reset to zero by bPSFlush.
598:
599: bPSFlush(pdev);
600: }
601: }
602:
603: return(TRUE);
604: }
605:
606:
607: //--------------------------------------------------------------------------
608: // BOOL bPSFlush(pdev)
609: // PDEVDATA pdev;
610: //
611: // This routine flushes the output buffer to the output channel.
612: //
613: // Parameters:
614: // pdev:
615: // pointer to DEVDATA structure.
616: //
617: // Returns:
618: // This function returns TRUE if the buffer was successfully flushed,
619: // FALSE otherwise.
620: //
621: // History:
622: // 21-Nov-1990 -by- Kent Settle (kentse)
623: // Wrote it.
624: //--------------------------------------------------------------------------
625:
626: BOOL bPSFlush(pdev)
627: PDEVDATA pdev;
628: {
629: DWORD cWritten;
630:
631: while (pdev->ioChannel.ulBufCount &&
632: !(pdev->dwFlags & PDEV_CANCELDOC))
633: {
634: if (!WritePrinter(pdev->hPrinter, pdev->ioChannel.pBuffer,
635: pdev->ioChannel.ulBufCount, &cWritten))
636: {
637: DbgPrint("bPSFlush: WritePrinter failed, will not call again.\n");
638: pdev->dwFlags |= PDEV_CANCELDOC;
639:
640: }
641: else
642: pdev->ioChannel.ulBufCount -= cWritten;
643: }
644:
645: if (pdev->dwFlags & PDEV_CANCELDOC)
646: {
647: pdev->ioChannel.ulBufCount = 0;
648: return TRUE;
649: }
650:
651: return(TRUE);
652: }
653:
654:
655: //--------------------------------------------------------------------------
656: // VOID vHexOut(pdev, pbSrc, nbSrc)
657: // PDEVDATA pdev; // pointer to the DC instance
658: // PBYTE pbSrc; // pointer to the output buffer to send
659: // LONG nbSrc; // Size of the output buffer
660: //
661: // This routine converts a byte string to hexadecimal and sends the
662: // result to the output channel.
663: //
664: // Parameters:
665: // pdev:
666: // pointer to DEVDATA structure.
667: //
668: // pbSrc:
669: // pointer to byte string.
670: //
671: // nbSrc:
672: // number of bytes in string.
673: //
674: // Returns:
675: // This function returns no value.
676: //
677: // History:
678: // Wed Dec 26, 1990 -by- Kent Settle (kentse)
679: // Wrote it.
680: //--------------------------------------------------------------------------
681:
682: VOID vHexOut(pdev, pbSrc, nbSrc)
683: PDEVDATA pdev; // pointer to the DC instance
684: PBYTE pbSrc; // pointer to the output buffer to send
685: LONG nbSrc; // Size of the output buffer
686: {
687: register LONG nwFree; // Number of 16 bit words available
688: register PBYTE pbDst, pbSource;
689: int b1, b2;
690: BOOL bFitsInBuffer;
691:
692: // output nothing if the document has been cancelled.
693:
694: if (pdev->dwFlags & PDEV_CANCELDOC)
695: return;
696:
697: // output nothing if a startdoc call has not been issued.
698:
699: if (!(pdev->dwFlags & PDEV_STARTDOC))
700: return;
701:
702: // get a local source pointer to munge with.
703:
704: pbSource = pbSrc;
705:
706: // output our header if it has not yet been done.
707:
708: bOutputHeader(pdev);
709:
710: // Loop once for each byte and stuff each byte into the output
711: // buffer. When the buffer becomes full, call FlushChannel to
712: // empty it.
713:
714: while (nbSrc > 0)
715: {
716: // get a pointer to the current location within the output buffer.
717: // then calculate how many WORDS are free in the output buffer.
718:
719: pbDst = ((PBYTE)pdev->ioChannel.pBuffer) + pdev->ioChannel.ulBufCount;
720: nwFree = ((OUTPUT_BUFFER_SIZE - 1) - pdev->ioChannel.ulBufCount) >> 1;
721:
722: // we will be converting one source byte into two destination
723: // bytes, so it is proper to compare the number of source bytes
724: // with the number of destination words.
725:
726: bFitsInBuffer = FALSE;
727:
728: if (nbSrc < nwFree)
729: {
730: nwFree = nbSrc;
731: bFitsInBuffer = TRUE;
732: }
733:
734: nbSrc -= nwFree;
735: pdev->ioChannel.ulBufCount += (nwFree << 1);
736:
737: while (nwFree-- > 0)
738: {
739: // Get a byte and convert it to two hex digits
740:
741: b1 = *pbSource++;
742: b2 = (b1 >> 4) & 0x0f;
743: b1 &= 0x0f;
744:
745: //!!! during the code review it was suggested to use itoa here.
746: //!!! is that really worth doing??? - kentse.
747:
748: if (b2 >= 10)
749: b2 += ('A' - 10);
750: else
751: b2 += '0';
752:
753: if (b1 >= 10)
754: b1 += ('A' - 10);
755: else
756: b1 += '0';
757:
758: *pbDst++ = (CHAR)b2;
759: *pbDst++ = (CHAR)b1;
760: }
761:
762: // flush the buffer when it is full.
763:
764: if (!bFitsInBuffer)
765: bPSFlush(pdev);
766: }
767: }
768:
769: // These two routines support four cases for Bitmaps:
770: //
771: // DataType Form
772: // -----------|-------------
773: // 0 | Unpacked binary data - level1
774: // 1 | Unpacked hex data - level1
775: // 2 | Packed binary data( RLE only) - level2
776: // 3 | Packed ascii85 data(RLE + ascii85) - level2
777: SHORT PSBitMapType(PDEVDATA pdev, BOOL BinaryClearChannel)
778: {
779:
780: if(!BinaryClearChannel)
781: {
782: if(pdev->pntpd->LangLevel == 2)
783: {
784: if (pdev->pntpd->flFlags & BCP_PROTOCOL)
785: return(3);
786: else
787: return(1);
788: }
789: else
790: return(1);
791: }
792: else
793: {
794: if(pdev->pntpd->LangLevel == 2)
795: {
796: if (pdev->pntpd->flFlags & TBCP_PROTOCOL)
797: return(2);
798: else
799: return(0);
800: }
801: else
802: return(0);
803: }
804: }
805:
806:
807: //--------------------------------------------------------------------------
808: // DWORD PSFIXToBuffer(pbuffer, psfx)
809: // CHAR *pbuffer;
810: // PS_FIX psfx;
811: //
812: // This routine takes a PS_FIX (24.8) number and outputs its ASCII
813: // equivalent to pbuffer.
814: //
815: // Parameters:
816: // pbuffer:
817: // pointer to output buffer.
818: //
819: // psfx:
820: // PS_FIX number.
821: //
822: // Returns:
823: // This function returns number of BYTES written to pbuffer.
824: //
825: // History:
826: // 07-May-1993 -by- Kent Settle (kentse)
827: // broke out of PrintPSFIX.
828: //--------------------------------------------------------------------------
829:
830: DWORD PSFIXToBuffer(pbuffer, psfx)
831: CHAR *pbuffer;
832: PS_FIX psfx;
833: {
834: DWORD cb;
835: BOOL bNegative;
836: LONG lNum;
837: PSZ pszFrac;
838:
839: // handle negative numbers.
840:
841: bNegative = FALSE;
842:
843: if (psfx < 0)
844: {
845: psfx *= -1;
846: *pbuffer++ = '-';
847: bNegative = TRUE;
848: }
849:
850: // grab the integer portion of the number, convert it to ASCII
851: // and put it into the output buffer.
852:
853: lNum = PSFXTOL(psfx);
854: itoa(lNum, pbuffer, 10);
855:
856: // how many characters, excluding the NULL terminator, did we place
857: // into the output buffer.
858:
859: if (bNegative)
860: pbuffer--;
861: cb = strlen(pbuffer);
862:
863: // update the buffer pointer.
864:
865: pbuffer += cb;
866:
867: // now see if we have a fractional portion of the number to
868: // worry about.
869:
870: lNum = (psfx & PS_FIX_MASK);
871: pszFrac = Fracs[lNum];
872:
873: // output a decimal point if we have a non-zero fraction, otherwise
874: // output the trailing space.
875:
876: if (*pszFrac)
877: *pbuffer++ = '.'; // overwrites NULL terminator from itoa.
878: else
879: return(cb); // we are done.
880:
881: // account for the decimal point.
882:
883: cb++;
884:
885: // output the fractional portion number of the if there is one.
886:
887: // copy the fractional number to the output buffer.
888:
889: strcpy(pbuffer, pszFrac);
890:
891: // how many characters, excluding the NULL terminator, did we place
892: // into the output buffer.
893:
894: cb += strlen(pszFrac);
895:
896: return(cb);
897: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.