![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to enable.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 enable.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 root 1: //--------------------------------------------------------------------------
2: //
3: // Module Name: ENABLE.C
4: //
5: // Brief Description: This module contains the PSCRIPT driver's Enable
6: // and Disable functions and related routines.
7: //
8: // Author: Kent Settle (kentse)
9: // Created: 16-Oct-1990
10: //
11: // Copyright (c) 1990 - 1992 Microsoft Corporation
12: //
13: // The Engine uses DosGetProcAddr to locate the driver's Enable and Disable
14: // functions. The first call the Engine makes is to initialize the driver.
15: // This function is usually called when the Engine has been asked to create
16: // the first DC for the device. bEnableDriver will return an array holding
17: // all the available driver entry points to the Engine.
18: //
19: // After calling bEnableDriver, the Engine will typically ask for a physical
20: // device to be created with dhpdevEnablePDEV. This call identifies the
21: // exact device and mode that the Engine wishes to access. The Engine's
22: // PDEV is not considered complete until the call to bCompletePDEV is made.
23: //
24: // Finally, a surface will be created for the physical device with
25: // hsurfEnableSurface. Only after a surface is created will graphics output
26: // calls be sent to the device.
27: //
28: // The functions dealing with driver initialization are as follows.
29: //
30: // DrvEnableDriver
31: // DrvEnablePDEV
32: // DrvRestartPDEV
33: // DrvCompletePDEV
34: // DrvEnableSurface
35: // DrvDisableSurface
36: // DrvDisablePDEV
37: // DrvDisableDriver
38: //
39: // 05-Feb-1993 Fri 19:46:19 updated -by- Daniel Chou (danielc)
40: // Redo halftone part so that engine will do all the work for us, also
41: // have engine create the the best standard pattern for our devices
42: //
43: //--------------------------------------------------------------------------
44:
45: #define _HTUI_APIS_
46:
47: #include "pscript.h"
48: #include "winbase.h"
49: #include "string.h"
50: #include "enable.h"
51: #include "tables.h"
52: #include "halftone.h"
53: #include "resource.h"
54:
55: // our DRVFN table which tells the engine where to find the
56: // routines we support.
57:
58: static DRVFN gadrvfn[] =
59: {
60: {INDEX_DrvEnablePDEV, (PFN)DrvEnablePDEV },
61: {INDEX_DrvRestartPDEV, (PFN)DrvRestartPDEV },
62: {INDEX_DrvCompletePDEV, (PFN)DrvCompletePDEV },
63: {INDEX_DrvDisablePDEV, (PFN)DrvDisablePDEV },
64: {INDEX_DrvEnableSurface, (PFN)DrvEnableSurface },
65: {INDEX_DrvDisableSurface, (PFN)DrvDisableSurface },
66: {INDEX_DrvBitBlt, (PFN)DrvBitBlt },
67: {INDEX_DrvStretchBlt, (PFN)DrvStretchBlt },
68: {INDEX_DrvCopyBits, (PFN)DrvCopyBits },
69: {INDEX_DrvTextOut, (PFN)DrvTextOut },
70: {INDEX_DrvQueryFont, (PFN)DrvQueryFont },
71: {INDEX_DrvQueryFontTree, (PFN)DrvQueryFontTree },
72: {INDEX_DrvQueryFontData, (PFN)DrvQueryFontData },
73: {INDEX_DrvSendPage, (PFN)DrvSendPage },
74: {INDEX_DrvStrokePath, (PFN)DrvStrokePath },
75: {INDEX_DrvFillPath, (PFN)DrvFillPath },
76: {INDEX_DrvStrokeAndFillPath,(PFN)DrvStrokeAndFillPath},
77: {INDEX_DrvRealizeBrush, (PFN)DrvRealizeBrush },
78: {INDEX_DrvStartPage, (PFN)DrvStartPage },
79: {INDEX_DrvStartDoc, (PFN)DrvStartDoc },
80: {INDEX_DrvEscape, (PFN)DrvEscape },
81: {INDEX_DrvDrawEscape, (PFN)DrvDrawEscape },
82: {INDEX_DrvEndDoc, (PFN)DrvEndDoc },
83: {INDEX_DrvGetGlyphMode, (PFN)DrvGetGlyphMode },
84: #ifdef INDEX_PAL
85: {INDEX_DrvDitherColor, (PFN)DrvDitherColor },
86: #endif
87: {INDEX_DrvFontManagement, (PFN)DrvFontManagement },
88: {INDEX_DrvQueryAdvanceWidths, (PFN)DrvQueryAdvanceWidths}
89: };
90:
91: BYTE cxHTPatSize[] = { 2,2,4,4,6,6,8,8,10,10,12,12,14,14,16,16 };
92: BYTE cyHTPatSize[] = { 2,2,4,4,6,6,8,8,10,10,12,12,14,14,16,16 };
93:
94: #ifdef INDEX_PAL
95: ULONG PSMonoPalette[] =
96: {
97: RGB_BLACK,
98: RGB_WHITE
99: };
100:
101: ULONG PSColorPalette[] =
102: {
103: RGB_BLACK,
104: RGB_RED,
105: RGB_GREEN,
106: RGB_YELLOW,
107: RGB_BLUE,
108: RGB_MAGENTA,
109: RGB_CYAN,
110: RGB_WHITE,
111: RGB_BLACK,
112: RGB_RED,
113: RGB_GREEN,
114: RGB_YELLOW,
115: RGB_BLUE,
116: RGB_MAGENTA,
117: RGB_CYAN,
118: RGB_WHITE
119: };
120: #endif
121:
122: static DEVHTINFO DefDevHTInfo = {
123:
124: HT_FLAG_HAS_BLACK_DYE,
125: HT_PATSIZE_6x6_M,
126: 0, // fill in later
127:
128: {
129: { 6810, 3050, 0 }, // xr, yr, Yr
130: { 2260, 6550, 0 }, // xg, yg, Yg
131: { 1810, 500, 0 }, // xb, yb, Yb
132: { 2000, 2450, 0 }, // xc, yc, Yc
133: { 5210, 2100, 0 }, // xm, ym, Ym
134: { 4750, 5100, 0 }, // xy, yy, Yy
135: { 3324, 3474, 10000 }, // xw, yw, Yw
136:
137: 10000, // R gamma
138: 10000, // G gamma
139: 10000, // B gamma
140:
141: 1422, 952, // M/C, Y/C
142: 787, 495, // C/M, Y/M
143: 324, 248 // C/Y, M/Y
144: }
145: };
146:
147: static COLORADJUSTMENT DefHTClrAdj = {
148:
149: sizeof(COLORADJUSTMENT),
150: 0,
151: ILLUMINANT_DEVICE_DEFAULT,
152: 20000,
153: 20000,
154: 20000,
155: REFERENCE_BLACK_MIN,
156: REFERENCE_WHITE_MAX,
157: 0,
158: 0,
159: 0,
160: 0
161: };
162:
163:
164: // global declarations.
165:
166: HMODULE ghmodDrv; // GLOBAL MODULE HANDLE.
167:
168: // macro to convert from .001 mm to 1/72 inch.
169:
170: #define MM001TOUSER(a) ((a * 72) / 25400)
171:
172: #define INSAINLY_LARGE_FORM 7200000 // 100,000 inches.
173: #define DEFAULT_MINIMUM_MEMORY 240 // 240k.
174: #define KBYTES_PER_FONT 60 // allow 60kb per downloaded font.
175: #define INITIAL_FORM_DELTA 16384
176:
177: VOID IntersectImageableAreas(CURRENTFORM *, PSFORM *);
178:
179: // declarations of external routines.
180:
181: extern PNTPD GetNTPD(PDEVDATA, PWSTR);
182: extern BOOL SetDefaultPSDEVMODE(PSDEVMODE *, PWSTR, PNTPD, HANDLE);
183: extern BOOL ValidateSetDEVMODE(PSDEVMODE *, PSDEVMODE *, HANDLE, PNTPD);
184: extern int NameComp(CHAR *, CHAR *);
185: extern PNTFM GetFont(PDEVDATA, ULONG, HANDLE *);
186: extern DWORD
187: PickDefaultHTPatSize(
188: DWORD xDPI,
189: DWORD yDPI,
190: BOOL HTFormat8BPP
191: );
192:
193: //#define TESTING
194:
195: //--------------------------------------------------------------------------
196: //
197: // BOOL DrvEnableDriver(
198: // ULONG iEngineVersion,
199: // ULONG cb,
200: // PDRVENABLEDATA pded);
201: //
202: // Requests the driver to fill in a structure containing recognized
203: // functions and other control information.
204: //
205: // One-time initialization, such as the allocation of semaphores, may
206: // be performed at this time. The actual enabling of hardware, like
207: // a display device, should wait until dhpdevEnable is called.
208: //
209: // This is a required driver function.
210: //
211: // Parameters:
212: //
213: // iEngineVersion:
214: // DDI Version number of the Engine. This will be at least 0x00010000
215: // for drivers written to this specification.
216: //
217: // cb:
218: // The count of bytes in the DRVENABLEDATA structure. The driver
219: // should not write more than this number of bytes into the structure.
220: // If the structure is longer than expected, then any extra fields
221: // should be left unmodified.
222: //
223: // pded:
224: // Pointer to a DRVENABLEDATA structure. The Engine will zero fill
225: // cb bytes of this structure before the call. The driver fills in
226: // its own data.
227: //
228: // The DRVENABLEDATA structure is of the following form:
229: //
230: // DRVENABLEDATA
231: // {
232: // ULONG iDriverVersion; // Driver DDI version
233: // ULONG c; // Number of drvfn entries
234: // DRVFN *pdrvfn; // Pointer to drvfn entries
235: // };
236: //
237: // where the DRVFN structure is defined as:
238: //
239: // DRVFN
240: // {
241: // ULONG iFunc; // function index
242: // PFN pfn; // function address
243: // };
244: //
245: // Returns:
246: // This function returns TRUE if the driver is enabled; it returns FALSE
247: // if the driver was not enabled.
248: //
249: // Comments:
250: // If the driver was not enabled, this function should log the proper
251: // error code.
252: //
253: // History:
254: // 16-Oct-1990 -by- Kent Settle (kentse)
255: // Created stub.
256: //--------------------------------------------------------------------------
257:
258: BOOL DrvEnableDriver(
259: ULONG iEngineVersion,
260: ULONG cb,
261: PDRVENABLEDATA pded)
262: {
263: ghmodDrv = GetModuleHandle(L"pscript.dll");
264:
265: // make sure we have a valid engine version.
266:
267: if (iEngineVersion < 0x00010000)
268: {
269: RIP("PSCRIPT!DrvEnableDriver: Invalid Engine Version.");
270: SetLastError(ERROR_INVALID_PARAMETER);
271: return(FALSE);
272: }
273:
274: // make sure we were given enough room for the DRVENABLEDATA.
275:
276: if (cb < sizeof(DRVENABLEDATA))
277: {
278: RIP("PSCRIPT!DrvEnableDriver: Invalid cb.");
279: SetLastError(ERROR_INVALID_PARAMETER);
280: return(FALSE);
281: }
282:
283: // fill in the DRVENABLEDATA structure for the engine.
284:
285: //??? i gather we should check to make sure we do not
286: //??? write out more than cb bytes. -kentse.
287:
288: pded->iDriverVersion = DDI_DRIVER_VERSION;
289: pded->c = sizeof(gadrvfn) / sizeof(DRVFN);
290: pded->pdrvfn = gadrvfn;
291:
292: // One-time initialization, such as the allocation of semaphores, may
293: // be performed at this time. The actual enabling of hardware, like
294: // a display device, should wait until dhpdevEnable is called.
295:
296: //!!! loading a string table might be a good thing to do here.
297:
298: return(TRUE);
299: }
300:
301:
302: //--------------------------------------------------------------------------
303: // DHPDEV DrvEnablePDEV(
304: // PDEVMODE pdriv,
305: // PSZ pszLogAddress,
306: // ULONG cPatterns,
307: // PHSURF ahsurfPatterns,
308: // ULONG cjCaps,
309: // PULONG aulCaps,
310: // ULONG cb,
311: // PDEVINFO pdevinfo,
312: // PSZ pszDataFile,
313: // PSZ pszDeviceName,
314: // HANDLE hDriver);
315: //
316: // Informs the driver that a new physical device (PDEV) is required.
317: //
318: // The device driver itself represents a logical device, which is managed
319: // by the Graphics Engine. A single device driver may manage several
320: // physical devices. These physical devices may be differentiated by:
321: //
322: // 1 Type of hardware. The same device driver might support the
323: // LaserWhiz, LaserWhiz II, and LaserWhiz Super.
324: //
325: // 2 Logical address. The same driver could support printers attached
326: // to LPT1, LPT2, COM1, etc.
327: //
328: // 3 Surfaces. I.e. a printer driver could be working on two print
329: // jobs simultaneously. The two surfaces represent the two pieces
330: // of paper that will be printed.
331: //
332: // Some display drivers might be able to support only one physical device,
333: // or one physical device at a time. In this case, they should return
334: // an error for any call from the Engine requesting a second physical
335: // device.
336: //
337: // The device driver should allocate any memory required to support the
338: // physical device at this time, except that the actual surface need not
339: // be supported until the Engine calls hsurfEnableSurface. This means
340: // that if the device surface requires a bitmap to be allocated, or a
341: // journal to be created, these allocations need not be done at this time.
342: // This is done as an optimization, since applications will often want to
343: // get information about a device long before they actually write on the
344: // device. Waiting before allocating a large bitmap, for example, can
345: // save valuable resources.
346: //
347: // This is a required driver function.
348: //
349: // Parameters:
350: // pdriv:
351: // Pointer to a PSDEVMODE structure. Environment settings requested
352: // by the application. (WIN 3.0).
353: //
354: // where the DEVMODE structure is defined as follows:
355: //
356: // typedef struct _DEVMODE
357: // {
358: // CHAR dmDeviceName[32];
359: // SHORT dmSpecVersion;
360: // SHORT dmDriverVersion;
361: // SHORT dmSize;
362: // SHORT dmDriverExtra;
363: // LONG dmFields;
364: // SHORT dmOrientation;
365: // SHORT dmPaperSize;
366: // SHORT dmPaperLength;
367: // SHORT dmPaperWidth;
368: // SHORT dmScale;
369: // SHORT dmCopies;
370: // SHORT dmDefaultSource;
371: // SHORT dmPrintQuality;
372: // SHORT dmColor;
373: // SHORT dmDuplex;
374: // BYTE dmDriverData[1];
375: // } DEVMODE, *PDEVMODE;
376: //
377: // pszLogAddress:
378: // Points to a string describing the logical address of the device.
379: // Examples: "LPT1", "COM2", etc.
380: //
381: // cPatterns:
382: // This is the count of HSURF fields in the buffer pointed to by
383: // aulCaps. The driver must not touch memory beyond the end of the
384: // buffer.
385: //
386: // ahsurfPatterns:
387: // Points to a buffer which is to be filled with surfaces representing
388: // the basic fill patterns. The following patterns must be defined
389: // in order. Each pattern is the same as defined for PM 1.2.
390: //
391: // o PATSYM_DENSE1
392: // o PATSYM_DENSE2
393: // o PATSYM_DENSE3
394: // o PATSYM_DENSE4
395: // o PATSYM_DENSE5
396: // o PATSYM_DENSE6
397: // o PATSYM_DENSE7
398: // o PATSYM_DENSE8
399: // o PATSYM_VERT
400: // o PATSYM_HORIZ
401: // o PATSYM_DIAG1
402: // o PATSYM_DIAG2
403: // o PATSYM_DIAG3
404: // o PATSYM_DIAG4
405: // o PATSYM_NOSHADE
406: // o PATSYM_SOLID
407: // o PATSYM_HALFTONE
408: // o PATSYM_HATCH
409: // o PATSYM_DIAGHATCH
410: //
411: // When the Engine needs to realize a brush with a standard pattern,
412: // it will call cbRealizeBrush with one of these surfaces.
413: //
414: // For raster devices, if the Engine is going to do any drawing on DIBs
415: // for the device, each of these surfaces must be a monochrome (one bit
416: // per pixel) Engine bitmap. It is the device driver's job to choose
417: // patterns that will look most like the standard patterns when written
418: // on the device surface.
419: //
420: // In the case of a vector device, the Engine will never be required
421: // to use these brushes in its support routines, so the surfaces can be
422: // device supported surfaces which the cbRealizeBrush code will recognize
423: // as the various standard patterns.
424: //
425: // The Engine will zero fill this buffer before the call.
426: //
427: // ??? Can we create these surfaces before bCompletePDEV???
428: //
429: // cCaps:
430: // This is the count of ULONG fields in the buffer pointed to by
431: // aulCaps. The driver must not touch memory beyond the end of the
432: // buffer.
433: //
434: // aulCaps:
435: // Points to a buffer which is to be filled with the device caps array.
436: // The Engine has zero filled this buffer before the call was made.
437: // This is identical to the array returned by the QueryDeviceCaps call
438: // in PM 1.2, with the following exceptions.
439: //
440: // The fields CAPS_MOUSE_BUTTONS and CAPS_VIO_LOADABLE_FONTS no
441: // longer have any meaning and should be left zeroed.
442: //
443: // Three fields are added:
444: //
445: // CAPS_X_STYLE_STEP (call this dx)
446: // CAPS_Y_STYLE_STEP (call this dy)
447: // CAPS_DEN_STYLE_STEP (call this D)
448: //
449: // These fields define how a cosmetic line style should advance as
450: // we draw each pel of the line. The amount we advance for each
451: // pel is defined as a fraction which depends on whether the line
452: // is x-major or y-major. If the line extends over more pels in
453: // the horizontal direction than the vertical direction it is called
454: // x-major, and the style will advance by the fractional amount dx/D.
455: // Otherwise the line is y-major and the style advances by dy/D for
456: // each pel.
457: //
458: // The dots in the predefined line style LINETYPE_DOT are each one
459: // unit long. So if you define CAPS_X_STYLE_STEP to be 1 and
460: // CAPS_DEN_STYLE_STEP to be 5, a dotted horizontal line will consist
461: // of 5 pels on followed by 5 pels off, repeated.
462: //
463: // See the section titled Cosmetic Line Styling for a complete
464: // description of styling.
465: //
466: // Each of these three numbers must fit in a USHORT, even though
467: // the caps fields are ULONGs.
468: //
469: // These style steps are defined by the device driver to make sure
470: // that the dots and dashes in a line are a pleasing size on the
471: // output device. The horizontal and vertical steps may be different
472: // to correct for non trivial aspect ratios. For example, on an
473: // EGA display, whose pels are 33\% higher than they are wide, you
474: // could set:
475: //
476: // aulCaps[CAPS_X_STYLE_STEP] = 3; // For an EGA!
477: // aulCaps[CAPS_Y_STYLE_STEP] = 4;
478: // aulCaps[CAPS_DEN_STYLE_STEP] = 12;
479: //
480: //
481: // In this case, horizontal dotted lines are four on - four off,
482: // since the style advances by 3/12 or 1/4 for each pel. Vertical
483: // dotted lines are three on - three off.
484: //
485: // Styled lines look better if both the X and Y style steps divide
486: // evenly into the style denominator as they do in this example.
487: // This gives dashes and dots that are always the same length.
488: //
489: // The Engine needs this information so that its bitmap routines
490: // can emulate exactly what the device would do on its own surface.
491: // Applications may also want to access this information to determine
492: // exactly what pels will be turned on for styled lines.
493: //
494: // cbDevInfo:
495: // This is a count of the bytes in the DEVINFO structure pointed to
496: // by pdevinfo. The driver should modify no more than this number of
497: // bytes in the DEVINFO.
498: //
499: // pdevinfo:
500: // This structure provides information about the driver and the physical
501: // device. The driver should fill in as many fields as it understands,
502: // and leave the others untouched. The Engine will have zero filled
503: // this structure before this call.
504: //
505: // In general, these fields provide information needed by the Engine
506: // to support the device. Application programs do not have access to
507: // this information.
508: //
509: // flGraphicsCaps:
510: // These are flags describing the graphics capabilities that the
511: // driver has for this PDEV. The flags are:
512: //
513: // GCAPS_BEZIERS Can handle Beziers (cubic splines).
514: // GCAPS_GEOMETRICWIDE Can do geometric widening.
515: // GCAPS_ALTERNATEFILL Can do alternating fills.
516: // GCAPS_WINDINGFILL Can do winding mode fills.
517: // GCAPS_ROTATEBLT Can do an arbitrarily transformed Blt.
518: // GCAPS_BLANKRECT Can blank a rectangle in vDrawText.
519: //
520: // pffRaster:
521: // This is a pointer to the device's default raster font, if it has
522: // one. The pointer is NULL if the device has no default raster
523: // font.
524: //
525: // The Engine could also ask for this pointer directly with
526: // pvQueryResource(dhpdev,FONT,SFONT_RASTER). It is provided here
527: // as an optimization.
528: //
529: // pffVector:
530: // Same as the above, but points to the default vector font, if
531: // any.
532: //
533: // cxDither:
534: //
535: // cyDither:
536: // These are the dimensions of a dithered brush. If these are
537: // non-zero, the device is able to create a dithered brush for a
538: // given RGB color. See bDitherBrush.
539: //
540: //
541: // Returns:
542: // If this function is successful, it returns a handle which identifies
543: // the device; otherwise it returns 0x00000000.
544: //
545: // History:
546: // 16-Oct-1990 -by- Kent Settle (kentse)
547: // Created stub.
548: //
549: // 05-Feb-1993 Fri 19:44:35 updated -by- Daniel Chou (danielc)
550: // remove halftone stuff and let engine do the halftone work
551: //
552: //--------------------------------------------------------------------------
553:
554: DHPDEV DrvEnablePDEV(
555: PDEVMODE pdriv,
556: PWSTR pwstrLogAddress,
557: ULONG cPatterns,
558: PHSURF ahsurfPatterns,
559: ULONG cjGdiInfo,
560: ULONG *pGdiInfo,
561: ULONG cb,
562: PDEVINFO pdevinfo,
563: PWSTR pwstrDataFile,
564: PWSTR pwstrDeviceName,
565: HANDLE hPrinter)
566: {
567: PDEVDATA pdev; // pointer to our device data block.
568: HANDLE hheap;
569: DWORD i;
570: PNTFM pntfm;
571: HANDLE hFontRes;
572: GDIINFO *pgdiinfo;
573:
574: UNREFERENCED_PARAMETER(pwstrLogAddress);
575:
576: // create a heap and allocate memory for our DEVDATA block.
577:
578: if (!(hheap = (HANDLE)HeapCreate(HEAP_NO_SERIALIZE, START_HEAP_SIZE, 0)))
579: {
580: RIP("PSCRIPT!DrvEnablePDEV: HeapCreate failed.");
581: return(0L);
582: }
583:
584: // allocate the pdev and store the heap handle in there.
585:
586: if (!(pdev = (PDEVDATA)HeapAlloc(hheap, 0, sizeof(DEVDATA))))
587: {
588: RIP("PSCRIPT!DrvEnablePDEV: HeapAlloc for DEVDATA failed.");
589: return(0L);
590: }
591:
592: memset(pdev, 0, sizeof(DEVDATA));
593:
594: pdev->hheap = hheap;
595: pdev->hPrinter = hPrinter;
596: pdev->pwstrDocName = (PWSTR)NULL;
597:
598: if (!(pdev->pwstrPPDFile = (PWSTR)HeapAlloc(pdev->hheap, 0,
599: ((wcslen(pwstrDataFile) + 1) * sizeof(WCHAR)))))
600: {
601: RIP("PSCRIPT!DrvEnablePDEV: HeapAlloc for pdev->pstrPPDFile failed.");
602: return(0L);
603: }
604:
605: // copy pszDataFile into the allocated memory pointed to by
606: // pdev->pwstrPPDFile.
607:
608: wcscpy(pdev->pwstrPPDFile, pwstrDataFile);
609:
610: // get the current printer information from the .PPD file and
611: // store a pointer to it in the DEVDATA structure.
612:
613: pdev->pntpd = GetNTPD(pdev, pdev->pwstrPPDFile);
614:
615: if (!pdev->pntpd)
616: {
617: RIP("PSCRIPT!DrvEnablePDEV: GetNTPD failed.\n");
618: return(0L);
619: }
620:
621: // initialize our DEVMODE structure for the current printer.
622:
623: SetDefaultPSDEVMODE((PSDEVMODE *)&pdev->psdm, pwstrDeviceName,
624: pdev->pntpd, pdev->hPrinter);
625:
626: // call off to do the guts of the work.
627:
628: // validate the DEVMODE structure passed in by the user, if everything
629: // is OK, set the fields selected by the user.
630:
631: if (!ValidateSetDEVMODE((PSDEVMODE *)&pdev->psdm, (PSDEVMODE *)pdriv,
632: pdev->hPrinter, pdev->pntpd))
633: {
634: RIP("PSCRIPT!DrvEnablePDEV: ValidateSetDEVMODE failed.");
635: SetLastError(ERROR_INVALID_PARAMETER);
636: return(0L);
637: }
638:
639: //
640: // Allocate memory for default user's color adjustment
641: //
642:
643: if (!(pdev->pvDrvHTData = (LPVOID)HeapAlloc(hheap, 0, sizeof(DRVHTINFO)))) {
644:
645: RIP("PSCRIPT!FillMyDevmode: HeapAlloc(DRVHTINFO) failed.\n");
646: return(FALSE);
647: }
648:
649: ZeroMemory(pdev->pvDrvHTData, sizeof(DRVHTINFO));
650:
651: // fill in our DEVDATA structure.
652:
653: if (!FillMyDevData(pdev))
654: return(0);
655:
656: // fill in the device capabilities for the engine.
657:
658: vFillaulCaps(pdev, cjGdiInfo, pGdiInfo);
659:
660: // fill in DEVINFO structure.
661:
662: pgdiinfo = (GDIINFO *)pGdiInfo;
663:
664: if(!bFillMyDevInfo(pdev, cb, pdevinfo, pgdiinfo->ulHTPatternSize))
665: return(0);
666:
667: // this is a good place to allocate room for all the font metrics to
668: // support all the device fonts.
669:
670: if (!(pdev->pfmtable = (PFMPAIR *)HeapAlloc(pdev->hheap, 0,
671: (DWORD)(sizeof(PFMPAIR) * pdevinfo->cFonts))))
672: {
673: RIP("PSCRIPT!bFillMyDevInfo: HeapAlloc for pdev->pfmtable failed.");
674: return(FALSE);
675: }
676:
677: // initialize the pfm table.
678:
679: ZeroMemory(pdev->pfmtable, (pdevinfo->cFonts * sizeof(PFMPAIR)));
680:
681: for (i = 0; i < pdevinfo->cFonts; i++)
682: {
683: // get the font metrics for the specified font.
684:
685: if (!(pntfm = GetFont(pdev, (i + 1), &hFontRes)))
686: {
687: RIP("PSCRIPT!DrvEnablePDEV: GetFont failed.\n");
688: return((DHPDEV)0);
689: }
690:
691: // save the resource handle with the NTFM structure.
692:
693: pdev->pfmtable[i].pntfm = pntfm;
694: pdev->pfmtable[i].hFontRes = hFontRes;
695: }
696:
697:
698: //
699: // We will zero out all the hSurface for the pattern so that engine can
700: // automatically simulate the staandard pattern for us
701: //
702:
703: ZeroMemory(ahsurfPatterns, sizeof(HSURF) * cPatterns);
704:
705: // return a pointer to our DEVDATA structure. it is supposed to
706: // be a handle, but we know it is a pointer.
707:
708: return((DHPDEV)pdev);
709: }
710:
711:
712: //--------------------------------------------------------------------------
713: // BOOL DrvRestartPDEV(
714: // DHPDEV dhpdev,
715: // PDEVMODE pdriv,
716: // ULONG cPatterns,
717: // PHSURF ahsurfPatterns,
718: // ULONG cjGdiInfo,
719: // PGDIINFO pGdiInfo,
720: // ULONG cb,
721: // PDEVINFO pdevinfo);
722: //
723: // This call changes the device mode of an existing PDEV. This is used
724: // when an application wishes to print one document containing pages in
725: // different modes, like a mixture of portrait and landscape.
726: //
727: // The Engine will have called vDisableSurface before this call. In
728: // general, a change of mode will require a surface with a different
729: // shape.
730: //
731: // An error is returned if the new mode is not compatible with the
732: // previous mode.
733: //
734: // This call is required for output devices that want to allow mode
735: // changes in documents.
736: //
737: // Parameters:
738: // dhpdev:
739: // Identifies the existing PDEV to change.
740: //
741: // pdriv:
742: // Pointer to a PSDEVMODE structure. Enviroment settings requested
743: // by the application. (WIN 3.0)
744: //
745: // This is a pointer to the new PSDEVMODE. If the device name does not
746: // match the previous one, an error should be returned. If for any
747: // other reason the new mode is not compatible with the old mode, an
748: // error should be returned.
749: //
750: // Returns:
751: // This function returns TRUE if it was successful; otherwise it returns
752: // FALSE.
753: //
754: // Comments:
755: // All other arguments are the same as dhpdevEnablePDEV, and new caps and
756: // parameters should be returned for the new mode.
757: //
758: // History:
759: // 21-Oct-1990 -by- Kent Settle (kentse)
760: // Wrote it.
761: // 16-Oct-1990 -by- Kent Settle (kentse)
762: // Created stub.
763: //
764: // 05-Feb-1993 Fri 19:45:31 updated -by- Daniel Chou (danielc)
765: // Remove Disable halftone function since engine do the work
766: //
767: //--------------------------------------------------------------------------
768:
769: BOOL DrvRestartPDEV(
770: DHPDEV dhpdev,
771: PDEVMODE pdriv,
772: ULONG cPatterns,
773: PHSURF ahsurfPatterns,
774: ULONG cjGdiInfo,
775: ULONG *pGdiInfo,
776: ULONG cb,
777: PDEVINFO pdevinfo)
778: {
779: PDEVDATA pdev; // pointer to our devdata.
780: GDIINFO *pgdiinfo;
781:
782: // since this call changes the device mode of an existing PDEV,
783: // make sure we have an existing, valid PDEV.
784:
785: pdev = (PDEVDATA)dhpdev;
786:
787: if (bValidatePDEV(pdev) == FALSE)
788: {
789: RIP("PSCRIPT!DrvRestartPDEV: invalid pdev.\n");
790: SetLastError(ERROR_INVALID_PARAMETER);
791: return(FALSE);
792: }
793:
794: // validate the DEVMODE structure passed in by the user, if everything
795: // is OK, set the fields selected by the user.
796:
797: if (!ValidateSetDEVMODE((PSDEVMODE *)&pdev->psdm, (PSDEVMODE *)pdriv,
798: pdev->hPrinter, pdev->pntpd))
799: {
800: RIP("PSCRIPT!DrvRestartPDEV: ValidateSetDEVMODE failed.");
801: SetLastError(ERROR_INVALID_PARAMETER);
802: return(FALSE);
803: }
804:
805: // set up the metrics for the current form.
806:
807: SetFormMetrics(pdev);
808:
809: // set number of copies, this may get overwritten by SETCOPYCOUNT escape.
810:
811: pdev->cCopies = pdev->psdm.dm.dmCopies;
812:
813: // set the scaling factor from the DEVMODE.
814:
815: pdev->psfxScale = LTOPSFX(pdev->psdm.dm.dmScale) / 100;
816: pdev->ScaledDPI = ((pdev->psdm.dm.dmPrintQuality *
817: pdev->psdm.dm.dmScale) / 100);
818:
819: // fill in the device capabilities for the engine.
820:
821: vFillaulCaps(pdev, cjGdiInfo, pGdiInfo);
822:
823: // fill in DEVINFO structure.
824:
825: pgdiinfo = (GDIINFO *)pGdiInfo;
826:
827: if(!bFillMyDevInfo(pdev, cb, pdevinfo, pgdiinfo->ulHTPatternSize))
828: return(FALSE);
829:
830: //
831: // We will zero out all the hSurface for the pattern so that engine can
832: // automatically simulate the staandard pattern for us
833: //
834:
835: ZeroMemory(ahsurfPatterns, sizeof(HSURF) * cPatterns);
836:
837:
838: return(TRUE);
839: }
840:
841:
842: //--------------------------------------------------------------------------
843: // VOID DrvCompletePDEV(
844: // DHPDEV dhpdev,
845: // HPDEV hpdev)
846: //
847: // The Engine calls this function when its installation of the physical
848: // device is complete.
849: //
850: // Parameters:
851: // dhpdev:
852: // This is a device PDEV handle returned from a call to
853: // dhpdevEnablePDEV.
854: //
855: // hpdev:
856: // This is the Engine's handle for the physical device being created.
857: // The driver should retain this handle for use when calling various
858: // Engine services.
859: //
860: //
861: // Returns:
862: // This function returns TRUE if it was successful; otherwise it returns
863: // FALSE.
864: //
865: // History:
866: // 21-Oct-1990 -by- Kent Settle (kentse)
867: // Wrote it.
868: // 16-Oct-1990 -by- Kent Settle (kentse)
869: // Created stub.
870: //--------------------------------------------------------------------------
871:
872: VOID DrvCompletePDEV(
873: DHPDEV dhpdev,
874: HDEV hdev)
875: {
876: if (bValidatePDEV((PDEVDATA)dhpdev) == FALSE)
877: {
878: RIP("PSCRIPT!bCompletePDEV: invalid PDEV.");
879: SetLastError(ERROR_INVALID_PARAMETER);
880: return;
881: }
882:
883: // store the engine's handle to the physical device in our DEVDATA.
884:
885: ((PDEVDATA)dhpdev)->hdev = hdev;
886:
887: return;
888: }
889:
890:
891: //--------------------------------------------------------------------------
892: // HSURF DrvEnableSurface(
893: // DHPDEV dhpdev);
894: //
895: // Requests that the driver create a surface for an existing physical
896: // device.
897: //
898: // Depending on the device and circumstances, the device might do any
899: // of the following to get the HSURF.
900: //
901: // 1 If the driver manages its own surface it should call the Engine
902: // service hsurfCreate to get a surface handle for it.
903: //
904: // 2 If the device has a surface which resembles a standard format
905: // bitmap it may want the Engine to manage the surface completely.
906: // In that case, the driver should call the Engine service hbmCreate
907: // with a pointer to the device pels, in order to get a bitmap
908: // handle for it.
909: //
910: // 3 If the device wants the Engine to collect the graphics directly
911: // on an Engine bitmap, the driver should also call hbmCreate, but
912: // have the Engine allocate space for the pels.
913: //
914: // 4 If the device wants the Engine to collect the graphics output
915: // in a journal, for replaying several times, it should call the
916: // Engine service hjnlCreate.
917: //
918: // As explained in the section on surfaces, any Engine bitmap handle or
919: // journal handle will be accepted as a valid surface handle.
920: //
921: // This call will only be made when there is no surface for the given
922: // PDEV.
923: //
924: // This is a required driver function.
925: //
926: // Parameters:
927: // dhpdev:
928: // This is a device PDEV handle returned from a call to
929: // dhpdevEnablePDEV. It identifies the physical device that the surface
930: // is to be created for.
931: //
932: // Returns:
933: // This function returns a handle that identifies the surface if it is
934: // successful; otherwise it returns 0x00000000.
935: //
936: // History:
937: // 16-Oct-1990 -by- Kent Settle (kentse)
938: // Created stub.
939: //--------------------------------------------------------------------------
940:
941: HSURF DrvEnableSurface(
942: DHPDEV dhpdev)
943: {
944: PDEVDATA pdev;
945: PDRVHTINFO pDrvHTInfo;
946: SIZEL sizlDev;
947:
948: // get the pointer to our DEVDATA structure and make sure it is ours.
949:
950: pdev = (PDEVDATA)dhpdev;
951:
952: if (bValidatePDEV(pdev) == FALSE)
953: {
954: RIP("PSCRIPT!DrvEnableSurface: invalid pdev.\n");
955: SetLastError(ERROR_INVALID_PARAMETER);
956: return(0L);
957: }
958:
959: pDrvHTInfo = (PDRVHTINFO)(pdev->pvDrvHTData);
960:
961: if (pDrvHTInfo->HTBmpFormat == BMF_4BPP) {
962:
963: if (!(pDrvHTInfo->pHTXB)) {
964:
965: if (!(pDrvHTInfo->pHTXB = (PHTXB)HeapAlloc(pdev->hheap,
966: 0,
967: HTXB_TABLE_SIZE))) {
968:
969: RIP("DrvEnableSurface: HeapAlloc(HTXB_TABLE_SIZE) failed.\n");
970: return(0L);
971: }
972: }
973:
974: } else {
975:
976: if (pDrvHTInfo->pHTXB) {
977:
978: HeapFree(pdev->hheap, 0, (PVOID)pDrvHTInfo->pHTXB);
979: pDrvHTInfo->pHTXB = NULL;
980: }
981: }
982:
983: //
984: // Invalidate the PALXlate table, and initial any flags
985: //
986:
987: pDrvHTInfo->Flags = 0;
988: pDrvHTInfo->PalXlate[0] = 0xff;
989: pDrvHTInfo->HTPalXor = HTPALXOR_SRCCOPY;
990:
991: // call the engine to create a surface handle for us.
992:
993: // convert the imageable area from PostScript USER space into
994: // device space.
995:
996: sizlDev.cx = ((pdev->CurForm.imagearea.right - pdev->CurForm.imagearea.left) *
997: pdev->psdm.dm.dmPrintQuality) / PS_RESOLUTION;
998:
999: sizlDev.cy = ((pdev->CurForm.imagearea.top - pdev->CurForm.imagearea.bottom) *
1000: pdev->psdm.dm.dmPrintQuality) / PS_RESOLUTION;
1001:
1002: pdev->hsurf = EngCreateSurface((DHSURF)pdev, sizlDev);
1003:
1004: if (pdev->hsurf == 0L)
1005: {
1006: RIP("PSCRIPT!DrvEnableSurface: hsurfCreateSurface returned 0.");
1007: return(0L);
1008: }
1009:
1010: EngAssociateSurface(pdev->hsurf, (HDEV)pdev->hdev,
1011: (HOOK_BITBLT | HOOK_STRETCHBLT | HOOK_TEXTOUT |
1012: HOOK_STROKEPATH | HOOK_FILLPATH | HOOK_COPYBITS |
1013: HOOK_STROKEANDFILLPATH));
1014:
1015: // allocate memory for output buffer. when the driver sends output to
1016: // the output channel, it gets put into the output buffer. when the
1017: // buffer is full, or the channel is closed, then the buffer contents
1018: // are flushed out the channel.
1019:
1020: pdev->ioChannel.pBuffer = HeapAlloc(pdev->hheap, 0, OUTPUT_BUFFER_SIZE);
1021:
1022: if (pdev->ioChannel.pBuffer == NULL)
1023: {
1024: RIP("DrvEnableSurface: HeapAlloc for output buffer failed.\n");
1025: EngDeleteSurface(pdev->hsurf);
1026: return(0L);
1027: }
1028:
1029: memset(pdev->ioChannel.pBuffer, 0, OUTPUT_BUFFER_SIZE);
1030:
1031: // initialize output channel information.
1032:
1033: pdev->ioChannel.ulBufCount = 0;
1034:
1035: // return the handle to the caller.
1036:
1037: return(pdev->hsurf);
1038: }
1039:
1040:
1041: //--------------------------------------------------------------------------
1042: // VOID DrvDisableSurface(
1043: // DHPDEV dhpdev)
1044: //
1045: // Informs the driver that the surface created for the PDEV by
1046: // hsurfEnableSurface is no longer needed. If the surface ties up
1047: // valuable resources, for example a lot of RAM, the surface should be
1048: // destroyed. If the surface is cheap to keep around, then the driver
1049: // may decide to hold onto it in case it's needed again. If the driver
1050: // does hold onto the surface it should definitely be deleted when the
1051: // PDEV is disabled!
1052: //
1053: // The Engine will always call this routine before calling vDisablePDEV
1054: // if the PDEV has an enabled surface.
1055: //
1056: // This is a required driver function.
1057: //
1058: // Parameters:
1059: // dhpdev:
1060: // This is the PDEV with which the surface is associated.
1061: //
1062: //
1063: // Returns:
1064: // This function does not return a value.
1065: //
1066: // History:
1067: // 16-Oct-1990 -by- Kent Settle (kentse)
1068: // Created stub.
1069: //--------------------------------------------------------------------------
1070:
1071: VOID DrvDisableSurface(
1072: DHPDEV dhpdev)
1073: {
1074: PDEVDATA pdev;
1075: PDRVHTINFO pDrvHTInfo;
1076:
1077: // get the pointer to our DEVDATA structure and make sure it is ours.
1078:
1079: pdev = (PDEVDATA)dhpdev;
1080:
1081: if (bValidatePDEV(pdev) == FALSE)
1082: return;
1083:
1084: //
1085: // Free up xlate table
1086: //
1087:
1088: pDrvHTInfo = (PDRVHTINFO)(pdev->pvDrvHTData);
1089:
1090: if (pDrvHTInfo->pHTXB) {
1091:
1092: HeapFree(pdev->hheap, 0, (PVOID)pDrvHTInfo->pHTXB);
1093: pDrvHTInfo->pHTXB = NULL;
1094: }
1095:
1096: // free the memory used by the output buffer.
1097:
1098: if (pdev->ioChannel.pBuffer)
1099: {
1100: HeapFree(pdev->hheap, 0, (PVOID)pdev->ioChannel.pBuffer);
1101: pdev->ioChannel.pBuffer = NULL;
1102: }
1103:
1104: // delete our surface.
1105:
1106: if (pdev->hsurf != 0L);
1107: {
1108: // call the engine to delete the surface handle.
1109:
1110: EngDeleteSurface(pdev->hsurf);
1111:
1112: // zero out our the copy of the handle in our DEVDATA.
1113:
1114: pdev->hsurf = 0L;
1115: }
1116: }
1117:
1118: //--------------------------------------------------------------------------
1119: // VOID DrvDisablePDEV(
1120: // DHPDEV dhpdev)
1121: //
1122: // Informs the driver that the given physical device is no longer needed.
1123: // At this time, the driver should free any memory and resources used by
1124: // the given PDEV. It should also free any surface that was created for
1125: // this PDEV, but not yet deleted.
1126: //
1127: // This is a required driver function.
1128: //
1129: // Parameters:
1130: // dhpdev:
1131: // The physical device which is to be disabled.
1132: //
1133: // Returns:
1134: // This function does not return a value.
1135: //
1136: // History:
1137: // 16-Oct-1990 -by- Kent Settle (kentse)
1138: // Created stub.
1139: //
1140: // 05-Feb-1993 Fri 19:47:19 updated -by- Daniel Chou (danielc)
1141: // Remove delete pattern surfaces, since engine created them
1142: //
1143: //--------------------------------------------------------------------------
1144:
1145: VOID DrvDisablePDEV(
1146: DHPDEV dhpdev)
1147: {
1148: PDEVDATA pdev;
1149: DWORD i, cFonts;
1150:
1151: pdev = (PDEVDATA)dhpdev;
1152:
1153: if (bValidatePDEV(pdev) == FALSE)
1154: {
1155: RIP("PSCRIPT!DrvDisablePDEV: Invalid pdev.\n");
1156: SetLastError(ERROR_INVALID_PARAMETER);
1157: return;
1158: }
1159:
1160: // free up the font resources.
1161:
1162: cFonts = pdev->cDeviceFonts + pdev->cSoftFonts;
1163:
1164: for (i = 0; i < cFonts; i++)
1165: {
1166: FreeFont(pdev, i + 1, pdev->pfmtable[i].hFontRes,
1167: pdev->pfmtable[i].pntfm);
1168: }
1169:
1170: // free up our default device palette.
1171:
1172: if (pdev->hpal)
1173: EngDeletePalette(pdev->hpal);
1174:
1175: // destroy the heap.
1176:
1177: if (!HeapDestroy(pdev->hheap))
1178: RIP("vDisablePDEV: HeapDestroy failed.\n");
1179: }
1180:
1181:
1182: //--------------------------------------------------------------------------
1183: // VOID DrvDisableDriver()
1184: //
1185: // Informs the driver that the Engine will no longer be using it and
1186: // that it is about to be unloaded. All resources still allocated by
1187: // the driver should be freed.
1188: //
1189: // This is a required driver function.
1190: //
1191: // Parameters
1192: // None.
1193: //
1194: // Returns
1195: // This function does not return a value.
1196: //
1197: // History:
1198: // 16-Oct-1990 -by- Kent Settle (kentse)
1199: // Created stub.
1200: //--------------------------------------------------------------------------
1201:
1202: VOID DrvDisableDriver()
1203: {
1204: return;
1205: }
1206:
1207:
1208: //--------------------------------------------------------------------------
1209: // VOID FillMyDevData(pdev)
1210: // PDEVDATA pdev; // Pointer to our DEVDATA structure.
1211: //
1212: // This routine fills in our DEVDATA structure, using the PSDEVMODE passed
1213: // to us by the user.
1214: //
1215: // Parameters
1216: // pdev:
1217: // Pointer to our DEVDATA structure, which we will then fill in.
1218: //
1219: // Returns
1220: // This function does not return a value.
1221: //
1222: // History:
1223: // 18-Oct-1990 -by- Kent Settle (kentse)
1224: // Wrote it.
1225: //--------------------------------------------------------------------------
1226:
1227: BOOL FillMyDevData(pdev)
1228: PDEVDATA pdev; // Pointer to our DEVDATA structure.
1229: {
1230: WCHAR wcbuf[64];
1231: DWORD returnvalue;
1232: DWORD dwType, cb;
1233: BOOL bHostHalftoning;
1234: DWORD cbTable;
1235: TT_FONT_MAPPING *pTable;
1236: WCHAR *pbuf;
1237:
1238: // mark the DEVDATA structure as ours.
1239:
1240: pdev->dwID = DRIVER_ID;
1241: pdev->dwEndPDEV = DRIVER_ID;
1242:
1243: // set up the metrics for the current form.
1244:
1245: SetFormMetrics(pdev);
1246:
1247: // now, initialize the flags.
1248:
1249: pdev->dwFlags = 0L;
1250:
1251: // Get the current setting of the PS_HALFTONING flag from the
1252: // registry and initialize the check button.
1253:
1254: LoadString(ghmodDrv, (IDS_HALFTONE + STRING_BASE),
1255: wcbuf, (sizeof(wcbuf) / sizeof(wcbuf[0])));
1256:
1257: returnvalue = GetPrinterData(pdev->hPrinter, wcbuf, &dwType,
1258: (LPBYTE)&bHostHalftoning,
1259: sizeof(bHostHalftoning), &cb);
1260:
1261: // printer halftoning is OFF by default. ie, use the system halftoning.
1262:
1263: if ((returnvalue != ERROR_SUCCESS) || (bHostHalftoning))
1264: pdev->dwFlags &= ~PDEV_PSHALFTONE;
1265: else
1266: pdev->dwFlags |= PDEV_PSHALFTONE;
1267:
1268: // let's start at page 1.
1269:
1270: pdev->iPageNumber = 1;
1271:
1272: // set number of copies, this may get overwritten by SETCOPYCOUNT escape.
1273:
1274: pdev->cCopies = pdev->psdm.dm.dmCopies;
1275:
1276: LoadString(ghmodDrv, (IDS_FREEMEM + STRING_BASE),
1277: wcbuf, (sizeof(wcbuf) / sizeof(wcbuf[0])));
1278:
1279: returnvalue = GetPrinterData(pdev->hPrinter, wcbuf, &dwType,
1280: (LPBYTE)&pdev->dwCurVM,
1281: sizeof(pdev->dwCurVM), &cb);
1282:
1283: if (returnvalue != ERROR_SUCCESS)
1284: pdev->dwCurVM = DEFAULT_MINIMUM_MEMORY;
1285:
1286: // make sure we have a useable value.
1287:
1288: pdev->dwCurVM = max(pdev->dwCurVM, DEFAULT_MINIMUM_MEMORY);
1289:
1290: pdev->iDLFonts = pdev->dwCurVM / KBYTES_PER_FONT;
1291:
1292: // see if the tray to form assignment table has been written out
1293: // to the registry. first check for the size of the table.
1294:
1295: LoadString(ghmodDrv, (IDS_TRAY_FORM_SIZE + STRING_BASE),
1296: wcbuf, (sizeof(wcbuf) / sizeof(wcbuf[0])));
1297:
1298: returnvalue = GetPrinterData(pdev->hPrinter, wcbuf, &dwType,
1299: (LPBYTE)&cbTable, sizeof(cbTable), &cb);
1300:
1301: pdev->pTrayFormTable = (WCHAR *)NULL;
1302:
1303: if ((returnvalue == ERROR_SUCCESS) && (cbTable))
1304: {
1305: // the table does exist in the registry, so allocate a buffer to
1306: // copy it into.
1307:
1308: if (!(pbuf = HeapAlloc(pdev->hheap, 0, cbTable)))
1309: {
1310: RIP("PSCRIPT!FillMyDevData: HeapAlloc for pbuf failed.\n");
1311: return(FALSE);
1312: }
1313:
1314: // now grab the table itself from the registry.
1315:
1316: LoadString(ghmodDrv, (IDS_TRAY_FORM_TABLE + STRING_BASE),
1317: wcbuf, (sizeof(wcbuf) / sizeof(wcbuf[0])));
1318:
1319: returnvalue = GetPrinterData(pdev->hPrinter, wcbuf, &dwType,
1320: (LPBYTE)pbuf, cbTable, &cb);
1321:
1322: if ((cb != cbTable) || (returnvalue != ERROR_SUCCESS))
1323: {
1324: RIP("PSCRIPT!FillMyDevData: GetPrinterData for tray-form table failed.\n");
1325: return(FALSE);
1326: }
1327:
1328: // set pointer in the PDEV.
1329:
1330: pdev->pTrayFormTable = pbuf;
1331: }
1332:
1333: // see if the font mapping tables have been written out
1334: // to the registry. if nothing has yet been written out,
1335: // write out the default mapping table. store the table in our
1336: // PDEV for user later.
1337:
1338: LoadString(ghmodDrv, (IDS_FONT_SUBST_SIZE + STRING_BASE),
1339: wcbuf, (sizeof(wcbuf) / sizeof(wcbuf[0])));
1340:
1341: returnvalue = GetPrinterData(pdev->hPrinter, wcbuf, &dwType,
1342: (LPBYTE)&cbTable, sizeof(cbTable), &cb);
1343:
1344: if ((returnvalue == ERROR_SUCCESS) && (cbTable))
1345: {
1346: // copy the font substitution table from the registry to our PDEV.
1347:
1348: if (!(pbuf = HeapAlloc(pdev->hheap, 0, cbTable)))
1349: {
1350: RIP("PSCRIPT!FillMyDevData: HeapAlloc for pbuf failed.\n");
1351: return(FALSE);
1352: }
1353:
1354: LoadString(ghmodDrv, (IDS_FONT_SUBST_TABLE + STRING_BASE),
1355: wcbuf, (sizeof(wcbuf) / sizeof(wcbuf[0])));
1356:
1357: returnvalue = GetPrinterData(pdev->hPrinter, wcbuf, &dwType,
1358: (LPBYTE)pbuf, cbTable, &cb);
1359:
1360: if ((cb != cbTable) || (returnvalue != ERROR_SUCCESS))
1361: {
1362: RIP("PSCRIPT!FillMyDevData: GetPrinterData for subst table failed.\n");
1363: return(FALSE);
1364: }
1365:
1366: // keep a pointer to the table in our PDEV.
1367:
1368: pdev->pTTSubstTable = pbuf;
1369: }
1370: else
1371: {
1372: // there is no font substitution table in the registry, so put a
1373: // copy of our default table in our PDEV.
1374:
1375: pTable = TTFontTable;
1376:
1377: // calculate how much of a buffer we will need for the table.
1378:
1379: // allow room for double NULL terminator.
1380:
1381: cb = 1;
1382:
1383: while (pTable->pwstrTTFont)
1384: {
1385: cb += (wcslen(pTable->pwstrTTFont) + 1) +
1386: (wcslen(pTable->pwstrDevFont) + 1);
1387:
1388: pTable++;
1389: }
1390:
1391: cb *= sizeof(WCHAR);
1392:
1393: // allocate buffer.
1394:
1395: if (!(pbuf = HeapAlloc(pdev->hheap, 0, cb)))
1396: {
1397: RIP("PSCRIPT!FillMyDevData: HeapAlloc for pbuf failed.\n");
1398: return(FALSE);
1399: }
1400:
1401: // set pointer in our PDEV.
1402:
1403: pdev->pTTSubstTable = pbuf;
1404:
1405: // point back to start of table.
1406:
1407: pTable = TTFontTable;
1408:
1409: // now copy our default font mapping table into the buffer.
1410:
1411: while (pTable->pwstrTTFont)
1412: {
1413: wcscpy(pbuf, pTable->pwstrTTFont);
1414: pbuf += (wcslen(pTable->pwstrTTFont) + 1);
1415:
1416: wcscpy(pbuf, pTable->pwstrDevFont);
1417: pbuf += (wcslen(pTable->pwstrDevFont) + 1);
1418:
1419: pTable++;
1420: }
1421:
1422: // add the last NULL terminator;
1423:
1424: *pbuf = (WCHAR)'\0';
1425:
1426: }
1427:
1428: // initialize the current graphics state.
1429:
1430: pdev->pcgsSave = NULL;
1431:
1432: memset(&pdev->cgs, 0, sizeof(CGS));
1433: init_cgs(pdev);
1434:
1435: // allocate memory for the DLFONT structures.
1436:
1437: pdev->cgs.pDLFonts = (DLFONT *)HeapAlloc(pdev->hheap, 0,
1438: sizeof(DLFONT) * (pdev->iDLFonts + 1));
1439: if (!pdev->cgs.pDLFonts)
1440: {
1441: RIP("PSCRIPT!FillMyDevData: HeapAlloc for pDLFont failed.\n");
1442: return(FALSE);
1443: }
1444:
1445: // initialize the DLFONT array.
1446:
1447: memset(pdev->cgs.pDLFonts, 0, sizeof(DLFONT) * (pdev->iDLFonts + 1));
1448:
1449: // set the scaling factor from the DEVMODE.
1450:
1451: pdev->psfxScale = LTOPSFX(pdev->psdm.dm.dmScale) / 100;
1452: pdev->ScaledDPI = ((pdev->psdm.dm.dmPrintQuality *
1453: pdev->psdm.dm.dmScale) / 100);
1454:
1455: return(TRUE);
1456: }
1457:
1458:
1459: //--------------------------------------------------------------------------
1460: // BOOL bFillMyDevInfo(pdev, cb, pdevinfo, ulPatternSize)
1461: // PDEVDATA pdev;
1462: // ULONG cb; // size of pdevinfo structure.
1463: // PDEVINFO pdevinfo; // pointer to DEVINFO structure.
1464: // ULONG ulPatternSize;
1465: //
1466: // This routine fills in the DEVINFO structure pointed to by pdevinfo.
1467: // Since we have to worry about not writing out more than cb bytes to
1468: // pdevinfo, we will fill in a local buffer, then copy cb bytes to
1469: // pdevinfo.
1470: //
1471: // Parameters
1472: // cb:
1473: // Count of bytes to fill in DEVINFO structure.
1474: //
1475: // pdevinfo:
1476: // Pointer to DEVINFO structure to be filled in.
1477: //
1478: // Returns
1479: // This function returns TRUE if success, FALSE otherwise.
1480: //
1481: // History:
1482: // 14-Nov-1990 -by- Kent Settle (kentse)
1483: // Wrote it.
1484: //--------------------------------------------------------------------------
1485:
1486: BOOL bFillMyDevInfo(pdev, cb, pdevinfo, ulPatternSize)
1487: PDEVDATA pdev;
1488: ULONG cb; // size of pdevinfo structure.
1489: PDEVINFO pdevinfo; // pointer to DEVINFO structure.
1490: ULONG ulPatternSize;
1491: {
1492: DEVINFO mydevinfo;
1493: TABLE_ENTRY *pTable;
1494: USHORT usDefFont;
1495: HANDLE hPFMFile;
1496: WCHAR wcbuf[MAX_PATH];
1497: PWSTR pwstrPath;
1498: PWSTR pwstrFaceName;
1499: ULONG iFace;
1500: PSOFTFONTENTRY pSFList;
1501: DWORD cwBuf;
1502: WCHAR wstringbuf[256];
1503: WIN32_FIND_DATA FileFindData;
1504: BOOL bFound;
1505: PSOFTFONTENTRY psfeTemp;
1506: DWORD cColors;
1507: ULONG *pulColors;
1508:
1509: // fill in the graphics capabilities flags.
1510:
1511: #ifdef INDEX_PAL
1512: mydevinfo.flGraphicsCaps = GCAPS_BEZIERS | GCAPS_GEOMETRICWIDE |
1513: GCAPS_ALTERNATEFILL | GCAPS_WINDINGFILL |
1514: GCAPS_DITHERONREALIZE | GCAPS_ARBRUSHSTROKE |
1515: GCAPS_COLOR_DITHER | GCAPS_MONO_DITHER |
1516: GCAPS_ARBRUSHTEXT | GCAPS_ARBRUSHOPAQUE |
1517: GCAPS_OPAQUERECT | GCAPS_HALFTONE;
1518: #else
1519: mydevinfo.flGraphicsCaps = GCAPS_BEZIERS | GCAPS_GEOMETRICWIDE |
1520: GCAPS_ALTERNATEFILL | GCAPS_WINDINGFILL |
1521: GCAPS_OPAQUERECT | GCAPS_HALFTONE;
1522: #endif
1523:
1524: // fill in default font information. first get the default facename.
1525:
1526: usDefFont = pdev->pntpd->usDefaultFont;
1527:
1528: pTable = (TABLE_ENTRY *)FontTable;
1529:
1530: while(pTable->szStr)
1531: {
1532: if ((USHORT)pTable->iValue == usDefFont)
1533: break;
1534:
1535: pTable++;
1536: }
1537:
1538: memset(&mydevinfo.lfDefaultFont, 0, sizeof(LOGFONT));
1539:
1540: // convert to face name UNICODE, then store in LOGFONT structure.
1541:
1542: if (pTable->szStr)
1543: {
1544: if (!(pwstrFaceName = (PWSTR)HeapAlloc(pdev->hheap, 0,
1545: ((strlen(pTable->szStr) + 1) * 2))))
1546: {
1547: RIP("PSCRIPT!bFillMyDevInfo: HeapAlloc for pwstrFaceName failed.");
1548: return(FALSE);
1549: }
1550:
1551: strcpy2WChar(pwstrFaceName, pTable->szStr);
1552:
1553: wcsncpy(mydevinfo.lfDefaultFont.lfFaceName, pwstrFaceName,
1554: (sizeof(mydevinfo.lfDefaultFont.lfFaceName) / 2));
1555:
1556: HeapFree(pdev->hheap, 0, (PVOID)pwstrFaceName);
1557: }
1558:
1559:
1560: //!!! at some point, we need to fill in the rest of lfDefaultFont.
1561:
1562: // hardcoded for 10 point courier.
1563:
1564: #if 0
1565: // get the font metrics for the default font.
1566:
1567: pfont = (BYTE *)pdev->pntpd + pdev->pntpd->loFonts;
1568:
1569: bFound = FALSE;
1570:
1571: for (iFace = 1; iFace <= (ULONG)pdev->pntpd->cFonts + 1; iFace++)
1572: {
1573: iFont = (ULONG)pfont[iFace - 1];
1574: if (iFont == COURIER)
1575: {
1576: pntfm = pdev->pfmtable[iFace - 1].pntfm;
1577: bFound = TRUE;
1578: break;
1579: }
1580: }
1581:
1582: if (!bFound)
1583: {
1584: RIP("Default Courier font not found.\n");
1585: return(FALSE);
1586: }
1587: #endif
1588:
1589: mydevinfo.lfDefaultFont.lfEscapement = 0;
1590: mydevinfo.lfDefaultFont.lfOrientation = 0;
1591:
1592: mydevinfo.lfDefaultFont.lfHeight = - (pdev->psdm.dm.dmPrintQuality*10+36) / 72;
1593:
1594: //!!! HACK - what should go here??? can we get avecharwith for this font?
1595: mydevinfo.lfDefaultFont.lfWidth = (27 * pdev->psdm.dm.dmPrintQuality) / 300;
1596: //!!!
1597:
1598: mydevinfo.lfDefaultFont.lfWeight = 400;
1599: mydevinfo.lfDefaultFont.lfItalic = 0;
1600: mydevinfo.lfDefaultFont.lfUnderline = 0;
1601: mydevinfo.lfDefaultFont.lfStrikeOut = 0;
1602: mydevinfo.lfDefaultFont.lfPitchAndFamily = FF_MODERN | FIXED_PITCH;
1603:
1604: // Copy default info ANSI_FIXED and ANSI_VARIABLE log fonts
1605:
1606: CopyMemory(&mydevinfo.lfAnsiVarFont, &mydevinfo.lfDefaultFont, sizeof(LOGFONT));
1607: CopyMemory(&mydevinfo.lfAnsiFixFont, &mydevinfo.lfDefaultFont, sizeof(LOGFONT));
1608:
1609: // Now insert ANSI_FIXED and ANSI_VAR facenames
1610:
1611: wcscpy((PWSTR)mydevinfo.lfAnsiVarFont.lfFaceName, L"Helvetica");
1612: mydevinfo.lfAnsiVarFont.lfPitchAndFamily = FF_SWISS | VARIABLE_PITCH;
1613:
1614: wcscpy((PWSTR)mydevinfo.lfAnsiFixFont.lfFaceName, L"Courier");
1615: mydevinfo.lfAnsiFixFont.lfPitchAndFamily = FF_MODERN | FIXED_PITCH;
1616:
1617: // get the count of device fonts for the current printer.
1618:
1619: mydevinfo.cFonts = (ULONG)pdev->pntpd->cFonts;
1620: pdev->cDeviceFonts = mydevinfo.cFonts;
1621: pdev->cSoftFonts = 0;
1622:
1623: // now add in any installed soft fonts.
1624:
1625: //!!! perhaps all the .PFM files should be put into one file at
1626: //!!! some stage, but this can be looked into later. -kentse.
1627:
1628: // copy the fully qualified path name of the data file into
1629: // local buffer. extract the directory name, as this is the
1630: // same directory font files are in.
1631:
1632: wcsncpy(wcbuf, pdev->pwstrPPDFile, MAX_PATH);
1633:
1634: pwstrPath = wcbuf;
1635: cwBuf = wcslen(wcbuf);
1636: pwstrPath += cwBuf;
1637:
1638: // back up over the data file name to get the subdirectory.
1639:
1640: while(*pwstrPath-- != (WCHAR)'\\')
1641: ;
1642:
1643: // overwrite the character after the backslash with the NULL
1644: // terminator.
1645:
1646: pwstrPath += 2;
1647: *pwstrPath = (WCHAR)'\0';
1648:
1649: // append *.PFM to qualified path.
1650:
1651: LoadString(ghmodDrv, (IDS_ALL_PFM_FILES + STRING_BASE),
1652: wstringbuf, (sizeof(wstringbuf) / 2));
1653:
1654: wcsncat(wcbuf, wstringbuf, (sizeof(wcbuf) / 2) - cwBuf);
1655:
1656: hPFMFile = FindFirstFile(wcbuf, &FileFindData);
1657:
1658: if (hPFMFile != (HANDLE)-1)
1659: {
1660: // we have at least one installed font. search for all the
1661: // font files, inserting them into a list for later use.
1662:
1663: // insert each font name found into the installed fonts
1664: // list box.
1665:
1666: bFound = TRUE;
1667:
1668: // allocate memory for the first element of a linked list of
1669: // softfonts.
1670:
1671: pdev->pSFList = (PSOFTFONTENTRY)HeapAlloc(pdev->hheap, 0, sizeof(SOFTFONTENTRY));
1672:
1673: if (pdev->pSFList == NULL)
1674: {
1675: RIP("PSCRIPT!bFillMyDevInfo: HeapAlloc for pdev->pSFList failed.\n");
1676: return(FALSE);
1677: }
1678:
1679: memset(pdev->pSFList, 0, sizeof(SOFTFONTENTRY));
1680:
1681: pSFList = pdev->pSFList;
1682: pSFList->psfePrev = NULL;
1683: pSFList->psfeNext = NULL;
1684:
1685: // set the face number for the first softfont to be one greater
1686: // than the number of built in device fonts.
1687:
1688: iFace = mydevinfo.cFonts + 1;
1689:
1690: while(bFound)
1691: {
1692: // fill in the current SOFTFONTENTRY.
1693:
1694: pSFList->iFace = iFace++;
1695: pSFList->pwstrPFMFile = (PWSTR)HeapAlloc(pdev->hheap, 0,
1696: ((wcslen(FileFindData.cFileName) + 1) * sizeof(WCHAR)));
1697:
1698: if (pSFList->pwstrPFMFile == NULL)
1699: {
1700: RIP("PSCRIPT!bFillMyDevInfo: HeapAlloc for pSFList->pwstrPFMFile failed.\n");
1701: return(FALSE);
1702: }
1703:
1704: wcscpy(pSFList->pwstrPFMFile, FileFindData.cFileName);
1705:
1706: // allocate memory for the next element in the linked list.
1707:
1708: pSFList->psfeNext = (struct _SOFTFONTENTRY *)HeapAlloc(pdev->hheap, 0,
1709: sizeof(SOFTFONTENTRY));
1710:
1711: if (pSFList->psfeNext == NULL)
1712: {
1713: RIP("PSCRIPT!bFillMyDevInfo: HeapAlloc for pdev->pSFList failed.\n");
1714: return(FALSE);
1715: }
1716:
1717: memset(pSFList->psfeNext, 0, sizeof(SOFTFONTENTRY));
1718:
1719: // update count of supported fonts.
1720:
1721: pdev->cSoftFonts++;
1722:
1723: // initialize next entry in list, then move to it.
1724:
1725: psfeTemp = pSFList;
1726: pSFList = (PSOFTFONTENTRY)pSFList->psfeNext;
1727: pSFList->psfePrev = (struct _SOFTFONTENTRY *)psfeTemp;
1728: pSFList->psfeNext = NULL;
1729:
1730: bFound = FindNextFile(hPFMFile, &FileFindData);
1731: }
1732: }
1733:
1734: mydevinfo.cFonts = pdev->cDeviceFonts + pdev->cSoftFonts;
1735:
1736: // now that we know the number of softfonts that exist, allocate a
1737: // bit for each one, which will be set when the font is downloaded.
1738:
1739: pdev->cgs.pSFArray = (BYTE *)HeapAlloc(pdev->hheap, 0, ((pdev->cSoftFonts + 7) / 8));
1740:
1741: if (pdev->cgs.pSFArray == NULL)
1742: {
1743: RIP("PSCRIPT!bFillMyDevInfo: HeapAlloc for pdev->cgs.pSFArray failed.\n");
1744: return(FALSE);
1745: }
1746:
1747: memset(pdev->cgs.pSFArray, 0, ((pdev->cSoftFonts + 7) / 8));
1748:
1749: // since this can get called from DrvRestartPDEV, delete a palette if one
1750: // exists, then create a new one.
1751:
1752: if (pdev->hpal)
1753: EngDeletePalette(pdev->hpal);
1754:
1755: // create the default device palette. let the engine know we are an
1756: // RGB device.
1757:
1758: #ifdef INDEX_PAL
1759: mydevinfo.cxDither = cxHTPatSize[ulPatternSize];
1760: mydevinfo.cyDither = cyHTPatSize[ulPatternSize];
1761:
1762: if ((pdev->pntpd->flFlags & COLOR_DEVICE) &&
1763: (pdev->psdm.dm.dmColor == DMCOLOR_COLOR))
1764: {
1765: cColors = 16;
1766: pulColors = PSColorPalette;
1767: mydevinfo.iDitherFormat = BMF_4BPP;
1768: }
1769: else
1770: {
1771: // fill in the palette for a monochrome device. put zero is black,
1772: // and 1 is white, 'cause that's that way windows likes it.
1773:
1774: cColors = 2;
1775: pulColors = PSMonoPalette;
1776: mydevinfo.iDitherFormat = BMF_1BPP;
1777: }
1778:
1779: if (!(mydevinfo.hpalDefault = EngCreatePalette(PAL_INDEXED, cColors,
1780: pulColors, 0, 0, 0)))
1781: #else
1782:
1783: // we don't want the engine doing any dithering for us, we are
1784: // a 24BPP device, let the printer do the work.
1785:
1786: mydevinfo.cxDither = 0;
1787: mydevinfo.cyDither = 0;
1788:
1789: mydevinfo.iDitherFormat = BMF_24BPP;
1790:
1791: if (!(mydevinfo.hpalDefault = EngCreatePalette(PAL_BGR, 0, 0, 0, 0, 0)))
1792: #endif
1793: {
1794: RIP("PSCRIPT!bFillMyDevInfo: EngCreatePalette failed.\n");
1795: return(FALSE);
1796: }
1797:
1798: // store the palette handle in our PDEV.
1799:
1800: pdev->hpal = mydevinfo.hpalDefault;
1801:
1802: // now copy the DEVINFO structure.
1803:
1804: memcpy((LPVOID)pdevinfo, (LPVOID)&mydevinfo, cb);
1805:
1806: return(TRUE);
1807: }
1808:
1809:
1810: //--------------------------------------------------------------------------
1811: // VOID vFillaulCaps(pdev, cjGdiInfo, pGdiInfo)
1812: // PDEVDATA pdev;
1813: // ULONG cjGdiInfo;
1814: // PGDIINFO pGdiInfo;
1815: //
1816: // This routine fills in the device caps for the engine.
1817: //
1818: // Parameters
1819: // cjGdiInfo:
1820: // Size of device capabilities buffer. This routine must not fill
1821: // beyond the given size of the buffer.
1822: //
1823: // pGdiInfo:
1824: // Pointer of place to store device caps.
1825: //
1826: // Returns
1827: // This function does not return a value.
1828: //
1829: // History:
1830: // 18-Oct-1990 -by- Kent Settle (kentse)
1831: // Wrote it.
1832: //
1833: // 05-Feb-1993 Fri 19:48:11 updated -by- Daniel Chou (danielc)
1834: // Set all halftone related data to gdiinfo, will get it from the
1835: // registry because we save them at UI pop up time
1836: //--------------------------------------------------------------------------
1837:
1838: VOID vFillaulCaps(pdev, cjGdiInfo, pGdiInfo)
1839: PDEVDATA pdev;
1840: ULONG cjGdiInfo;
1841: ULONG *pGdiInfo;
1842: {
1843: DEVHTINFO CurDevHTInfo;
1844: PDRVHTINFO pDrvHTInfo;
1845: GDIINFO gdiinfo;
1846: DWORD dwType;
1847: DWORD cbNeeded;
1848: FLOAT tmpfloat;
1849:
1850: pDrvHTInfo = (PDRVHTINFO)pdev->pvDrvHTData;
1851:
1852: // make sure we don't overrun anything..
1853:
1854: cjGdiInfo = min(cjGdiInfo, sizeof(GDIINFO));
1855:
1856: // since we have to worry about the size of the buffer, and
1857: // we will most always be asked for full structure of information,
1858: // fill in the entire structure locally, then copy the appropriate
1859: // number of entries into the aulCaps buffer.
1860:
1861: //!!! need to check on the version number and what it means.
1862: // fill in the version number.
1863:
1864: gdiinfo.ulVersion = GDI_VERSION;
1865:
1866: // fill in the device classification index.
1867:
1868: gdiinfo.ulTechnology = DT_RASPRINTER;
1869:
1870: // fill in the printable area in millimeters. the printable areas
1871: // are provided in the PPD files in points. A point is 1/72 of an
1872: // inch. There are 25.4 mm per inch. So, if X is the width in
1873: // points, (X * 25.4) / 72 gives the number of millimeters.
1874: // We then take into account the scaling factor of 100% Things to
1875: // note: 2540 / 4 = 635. 72 / 4 = 18.
1876:
1877: // new item: make the number negative, and it is now micrometers.
1878: // this will make transforms just a bit more accurate.
1879:
1880: tmpfloat = (FLOAT)((pdev->CurForm.imagearea.right -
1881: pdev->CurForm.imagearea.left) * 635.0) /
1882: (18 * pdev->psdm.dm.dmScale);
1883:
1884: gdiinfo.ulHorzSize = (ULONG)-(LONG)(tmpfloat * 1000);
1885:
1886: tmpfloat = (FLOAT)((pdev->CurForm.imagearea.top -
1887: pdev->CurForm.imagearea.bottom) * 635.0) /
1888: (18 * pdev->psdm.dm.dmScale);
1889:
1890: gdiinfo.ulVertSize = (ULONG)-(LONG)(tmpfloat * 1000);
1891:
1892: // fill in the printable area in device units. the printable areas
1893: // are provided in the PPD files in points. A point is 1/72 of an
1894: // inch. The device resolution is given in device units per inch.
1895: // So if X is the width in points, (X * resolution) / 72 gives the
1896: // width in device units.
1897:
1898: gdiinfo.ulHorzRes = ((pdev->CurForm.imagearea.right -
1899: pdev->CurForm.imagearea.left) *
1900: pdev->psdm.dm.dmPrintQuality) / PS_RESOLUTION;
1901:
1902: gdiinfo.ulVertRes = ((pdev->CurForm.imagearea.top -
1903: pdev->CurForm.imagearea.bottom) *
1904: pdev->psdm.dm.dmPrintQuality) / PS_RESOLUTION;
1905:
1906: // fill in the default bitmap format information fields.
1907:
1908: gdiinfo.cBitsPixel = GDIINFO_BITSPERPEL;
1909: gdiinfo.cPlanes = 1;
1910:
1911: gdiinfo.ulDACRed = 0;
1912: gdiinfo.ulDACGreen = 0;
1913: gdiinfo.ulDACBlue = 0;
1914:
1915: // fill in number of physical, non-dithered colors printer can print.
1916:
1917: if (pdev->pntpd->flFlags & COLOR_DEVICE)
1918: gdiinfo.ulNumColors = NUM_PURE_COLORS;
1919: else
1920: gdiinfo.ulNumColors = NUM_PURE_GRAYS;
1921:
1922: gdiinfo.flRaster = 0;
1923:
1924: // it is assumed all postscript printers have 1:1 aspect ratio.
1925: // fill in the pixels per inch.
1926:
1927: gdiinfo.ulLogPixelsX = pdev->ScaledDPI;
1928: gdiinfo.ulLogPixelsY = pdev->ScaledDPI;
1929:
1930: // !!! [GilmanW] 16-Apr-1992 hack-attack
1931: // !!! Return the new flTextCaps flags. I think these are alright, but
1932: // !!! you better check them over, KentSe.
1933:
1934: gdiinfo.flTextCaps =
1935: TC_OP_CHARACTER /* Can do OutputPrecision CHARACTER */
1936: | TC_OP_STROKE /* Can do OutputPrecision STROKE */
1937: | TC_CP_STROKE /* Can do ClipPrecision STROKE */
1938: | TC_CR_ANY /* Can do CharRotAbility ANY */
1939: | TC_SF_X_YINDEP /* Can do ScaleFreedom X_YINDEPENDENT */
1940: | TC_SA_DOUBLE /* Can do ScaleAbility DOUBLE */
1941: | TC_SA_INTEGER /* Can do ScaleAbility INTEGER */
1942: | TC_SA_CONTIN /* Can do ScaleAbility CONTINUOUS */
1943: | TC_UA_ABLE /* Can do UnderlineAbility ABLE */
1944: | TC_SO_ABLE; /* Can do StrikeOutAbility ABLE */
1945:
1946:
1947: gdiinfo.xStyleStep = 1L;
1948: gdiinfo.yStyleStep = 1L;
1949:
1950: gdiinfo.ulAspectX = pdev->psdm.dm.dmPrintQuality;
1951: gdiinfo.ulAspectY = gdiinfo.ulAspectX;
1952: gdiinfo.ulAspectXY = (gdiinfo.ulAspectX * 1414) / 1000; // ~sqrt(2).
1953:
1954: // interesting value. it makes a dotted line have 25 dots per inch,
1955: // and it matches RASDD.
1956:
1957: gdiinfo.denStyleStep = pdev->psdm.dm.dmPrintQuality / 25;
1958:
1959: // let the world know of our margins!!
1960:
1961: gdiinfo.ptlPhysOffset.x = (pdev->CurForm.imagearea.left *
1962: pdev->psdm.dm.dmPrintQuality) / PS_RESOLUTION;
1963:
1964: gdiinfo.ptlPhysOffset.y = ((pdev->CurForm.sizlPaper.cy -
1965: pdev->CurForm.imagearea.top) *
1966: pdev->psdm.dm.dmPrintQuality) /
1967: PS_RESOLUTION;
1968:
1969: // let 'em know how big our piece of paper is.
1970:
1971: gdiinfo.szlPhysSize.cx = (pdev->CurForm.sizlPaper.cx *
1972: pdev->psdm.dm.dmPrintQuality) / PS_RESOLUTION;
1973: gdiinfo.szlPhysSize.cy = (pdev->CurForm.sizlPaper.cy *
1974: pdev->psdm.dm.dmPrintQuality) / PS_RESOLUTION;
1975:
1976: // !!! Where is the halftoning information? [donalds]
1977:
1978: //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1979: //
1980: // We will do in following sequence, and exit the sequence if sucessful
1981: //
1982: // 1. Read from registry if one present (USER ADJUSTMENT)
1983: // 2. Read from mini driver's default if one present (DEVICE DEFAULT)
1984: // 3. Set standard halftone default (HALFTONE DEFAULT)
1985: //
1986: //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1987:
1988: //======================================================================
1989: // 1st: Try to see if user modify anything
1990: //======================================================================
1991:
1992: if ((GetPrinterData(pdev->hPrinter,
1993: REGKEY_CUR_DEVHTINFO,
1994: &dwType,
1995: (BYTE *)&CurDevHTInfo,
1996: sizeof(DEVHTINFO),
1997: &cbNeeded) == NO_ERROR) &&
1998: (cbNeeded == sizeof(DEVHTINFO))) {
1999:
2000: gdiinfo.ciDevice = CurDevHTInfo.ColorInfo;
2001: gdiinfo.ulDevicePelsDPI = (ULONG)CurDevHTInfo.DevPelsDPI;
2002: gdiinfo.ulHTPatternSize = (ULONG)CurDevHTInfo.HTPatternSize;
2003:
2004: } else {
2005:
2006: //!!! still need to do this post product 1.
2007: //==================================================================
2008: // 2nd: Try to see if .PPD has halftone data present
2009: //==================================================================
2010:
2011: //=============================================================
2012: // 3rd: SET HALFTONE STANDARD DEFAULT
2013: //=============================================================
2014:
2015: gdiinfo.ciDevice = DefDevHTInfo.ColorInfo;
2016: gdiinfo.ulDevicePelsDPI = (ULONG)DefDevHTInfo.DevPelsDPI;
2017: gdiinfo.ulHTPatternSize = PickDefaultHTPatSize(gdiinfo.ulLogPixelsX,
2018: gdiinfo.ulLogPixelsY,
2019: FALSE);
2020: }
2021:
2022: //
2023: // Validate this data, we do not want to have gdi go crazy.
2024: //
2025:
2026: if (gdiinfo.ulHTPatternSize > HT_PATSIZE_16x16_M) {
2027:
2028: gdiinfo.ulHTPatternSize = (ULONG)DefDevHTInfo.HTPatternSize;
2029: }
2030:
2031: //======================================================================
2032: // 4th: Get default color adjustment if one exist in registry
2033: //======================================================================
2034:
2035: if ((GetPrinterData(pdev->hPrinter,
2036: REGKEY_CUR_HTCLRADJ,
2037: &dwType,
2038: (BYTE *)&(pDrvHTInfo->ca),
2039: sizeof(COLORADJUSTMENT),
2040: &cbNeeded) != NO_ERROR) ||
2041: (cbNeeded != sizeof(COLORADJUSTMENT)) ||
2042: (pDrvHTInfo->ca.caSize != sizeof(COLORADJUSTMENT))) {
2043:
2044: pDrvHTInfo->ca = DefHTClrAdj;
2045: }
2046:
2047: //
2048: // PrimaryOrder ABC = RGB, which B=Plane1, G=Plane2, R=Plane3
2049: //
2050:
2051: gdiinfo.flHTFlags = HT_FLAG_HAS_BLACK_DYE;
2052: #ifdef INDEX_PAL
2053: gdiinfo.ulPrimaryOrder = (ULONG)PRIMARY_ORDER_ABC;
2054: #else
2055: gdiinfo.ulPrimaryOrder = (ULONG)PRIMARY_ORDER_CBA;
2056: #endif
2057:
2058: if ((pdev->pntpd->flFlags & COLOR_DEVICE) &&
2059: (pdev->psdm.dm.dmColor == DMCOLOR_COLOR)) {
2060:
2061: pDrvHTInfo->HTPalCount = 8;
2062: pDrvHTInfo->HTBmpFormat = (BYTE)BMF_4BPP;
2063: pDrvHTInfo->AltBmpFormat = (BYTE)BMF_1BPP;
2064: gdiinfo.ulHTOutputFormat = HT_FORMAT_4BPP;
2065:
2066: } else {
2067:
2068: pDrvHTInfo->HTPalCount = 2;
2069: pDrvHTInfo->HTBmpFormat = (BYTE)BMF_1BPP;
2070: pDrvHTInfo->AltBmpFormat = (BYTE)0xff;
2071: gdiinfo.ulHTOutputFormat = HT_FORMAT_1BPP;
2072: }
2073:
2074: pDrvHTInfo->Flags = 0;
2075: pDrvHTInfo->PalXlate[0] = 0xff;
2076: pDrvHTInfo->HTPalXor = HTPALXOR_SRCCOPY;
2077:
2078: // copy cjGdiInfo elements of gdiinfo to aulCaps.
2079:
2080: CopyMemory(pGdiInfo, &gdiinfo, cjGdiInfo);
2081: }
2082:
2083:
2084:
2085: //--------------------------------------------------------------------------
2086: // BOOL bValidatePDEV(pdev)
2087: // PDEVDATA pdev;
2088: //
2089: // This routine validates the PDEVDATA.
2090: //
2091: // Parameters
2092: // pdev:
2093: // Pointer to DEVDATA structure.
2094: //
2095: // Returns
2096: // This function returns TRUE if the DEVDATA is valid, FALSE otherwise.
2097: //
2098: // History:
2099: // 21-Oct-1990 -by- Kent Settle (kentse)
2100: // Wrote it.
2101: //--------------------------------------------------------------------------
2102:
2103: BOOL bValidatePDEV(pdev)
2104: PDEVDATA pdev;
2105: {
2106: if ((pdev == NULL) || (pdev->dwID != DRIVER_ID) ||
2107: (pdev->dwEndPDEV != DRIVER_ID))
2108: return(FALSE);
2109:
2110: return(TRUE);
2111: }
2112:
2113:
2114: //--------------------------------------------------------------------------
2115: // VOID SetFormMetrics(pdev)
2116: // PDEVDATA pdev;
2117: //
2118: // This routine fills in a PSFORM structure for the current form. This
2119: // PSFORM structure is located within the DEVDATA structure.
2120: //
2121: // Parameters
2122: // pdev:
2123: // Pointer to DEVDATA structure.
2124: //
2125: // Returns
2126: // This function returns no value.
2127: //
2128: // History:
2129: // 13-Dec-1992 -by- Kent Settle (kentse)
2130: // Wrote it.
2131: //--------------------------------------------------------------------------
2132:
2133: VOID SetFormMetrics(pdev)
2134: PDEVDATA pdev;
2135: {
2136: FORM_INFO_1 *pdbForm, *pdbForms;
2137: DWORD cbNeeded, cReturned, i;
2138: DEVMODE *pdevmode;
2139: PNTPD pntpd;
2140: BOOL bFound;
2141:
2142: pdevmode = &pdev->psdm.dm;
2143: pntpd = pdev->pntpd;
2144:
2145: // the first thing to do is to enumerate the forms database so we have
2146: // ready access to all the defined forms.
2147:
2148: bFound = FALSE;
2149:
2150: if (!EnumForms(pdev->hPrinter, 1, NULL, 0, &cbNeeded, &cReturned))
2151: {
2152: if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
2153: {
2154: if (pdbForms = (PFORM_INFO_1)HeapAlloc(pdev->hheap, 0, cbNeeded))
2155: {
2156: if (EnumForms(pdev->hPrinter, 1, (LPBYTE)pdbForms,
2157: cbNeeded, &cbNeeded, &cReturned))
2158: bFound = TRUE;
2159: }
2160: }
2161: }
2162:
2163: if (!bFound)
2164: {
2165: // enumeration of the font database failed. fill in default
2166: // values and hope for the best.
2167:
2168: SetCurrentFormToDefault(pdev);
2169: return;
2170: }
2171:
2172: // the idea here is to select the proper form from the DEVMODE structure.
2173: // there are three ways to do this. the REAL NT way of doing this is
2174: // that dmFormName will be filled in, then we can just grab the metrics
2175: // from the forms database. if dmFormName is not filled in, we then look
2176: // at dmPaperLength and dmPaperWidth. if these are filled in, then we
2177: // look through the forms database to see if we have a matching form.
2178: // if we can find one, we then check to see if it is loaded in a paper
2179: // tray. if it is, use it. if it is not, then use the default form.
2180: // the third method of selecting the form is to look at dmPaperSize.
2181: // dmPaperSize will be an index into the forms database. use this form.
2182:
2183: // one thing to keep in mind is that the CURRENTFORM structure stores
2184: // the form metrics in postscript USER coordinates, and the FORM_INFO_1
2185: // structure uses .001 mm units.
2186:
2187: if ((pdevmode->dmFields & DM_PAPERLENGTH) &&
2188: (pdevmode->dmFields & DM_PAPERWIDTH))
2189: {
2190: // the user has supplied us with a custom form size. we will handle
2191: // this in the following way: search the forms database for a form
2192: // of matching size, if one is found, use it. otherwise, use the
2193: // default form.
2194:
2195: bFound = FALSE;
2196: pdbForm = pdbForms;
2197:
2198: for (i = 0; i < cReturned; i++)
2199: {
2200: if (((pdevmode->dmPaperWidth * 100) < pdbForm->Size.cx + 50) &&
2201: ((pdevmode->dmPaperWidth * 100) > pdbForm->Size.cx - 50) &&
2202: ((pdevmode->dmPaperLength * 100) < pdbForm->Size.cx + 50) &&
2203: ((pdevmode->dmPaperLength * 100) > pdbForm->Size.cx - 50))
2204: {
2205: // pdbForm now points to the specified form. fill in the CURRENTFORM
2206: // structure.
2207:
2208: FillInCURRENTFORM(pdev, pdbForm);
2209:
2210: bFound = TRUE;
2211: break;
2212: }
2213:
2214: pdbForm++;
2215: }
2216:
2217: if (!bFound)
2218: {
2219: // the specified form was not found, use the default.
2220:
2221: SetCurrentFormToDefault(pdev);
2222: HeapFree(pdev->hheap, 0, (PVOID)pdbForms);
2223: return;
2224: }
2225:
2226:
2227: }
2228: else if (pdevmode->dmFields & DM_PAPERSIZE)
2229: {
2230: // use default form if invalid dmPaperSize was supplied.
2231:
2232: if ((pdevmode->dmPaperSize < 0) || (pdevmode->dmPaperSize >= (int)cReturned))
2233: {
2234: SetCurrentFormToDefault(pdev);
2235: HeapFree(pdev->hheap, 0, (PVOID)pdbForms);
2236: return;
2237: }
2238:
2239: // pdevmode->dmPaperSize should be a valid index into the forms
2240: // database. simply index into it to find the form.
2241:
2242: pdbForm = pdbForms;
2243: pdbForm += (pdevmode->dmPaperSize - DMPAPER_FIRST);
2244:
2245: // pdbForm now points to the specified form. fill in the CURRENTFORM
2246: // structure.
2247:
2248: FillInCURRENTFORM(pdev, pdbForm);
2249: }
2250: else if (pdevmode->dmFields & DM_FORMNAME)
2251: {
2252: // search each form in the forms database to find a form name match.
2253:
2254: bFound = FALSE;
2255: pdbForm = pdbForms;
2256:
2257: for (i = 0; i < cReturned; i++)
2258: {
2259: if (!(wcscmp(pdevmode->dmFormName, pdbForm->pName)))
2260: {
2261: // pdbForm now points to the specified form. fill in the CURRENTFORM
2262: // structure.
2263:
2264: FillInCURRENTFORM(pdev, pdbForm);
2265:
2266: bFound = TRUE;
2267: break;
2268: }
2269:
2270: pdbForm++;
2271: }
2272:
2273: if (!bFound)
2274: {
2275: // the specified form was not found, use the default.
2276:
2277: SetCurrentFormToDefault(pdev);
2278: HeapFree(pdev->hheap, 0, (PVOID)pdbForms);
2279: return;
2280: }
2281: }
2282: else
2283: {
2284: // no valid form was found in the DEVMODE structure, use the default.
2285:
2286: SetCurrentFormToDefault(pdev);
2287: HeapFree(pdev->hheap, 0, (PVOID)pdbForms);
2288: return;
2289: }
2290: }
2291:
2292:
2293: //--------------------------------------------------------------------------
2294: // VOID SetCurrentFormToDefault(pdev)
2295: // PDEVDATA pdev;
2296: //
2297: // This routine fills the CURRENTFORM structure in the DEVDATA with the
2298: // default form, as defined by NTPD.
2299: //
2300: // Parameters
2301: // pdev:
2302: // Pointer to DEVDATA structure.
2303: //
2304: // Returns
2305: // This function returns no value.
2306: //
2307: // History:
2308: // 13-Dec-1992 -by- Kent Settle (kentse)
2309: // Wrote it.
2310: //--------------------------------------------------------------------------
2311:
2312: VOID SetCurrentFormToDefault(pdev)
2313: PDEVDATA pdev;
2314: {
2315: PNTPD pntpd;
2316: PSFORM *pPSForm;
2317: DWORD i;
2318:
2319: pntpd = pdev->pntpd;
2320:
2321: // find the metrics for the default form.
2322:
2323: pPSForm = (PSFORM *)((CHAR *)pntpd + pntpd->loPSFORMArray);
2324:
2325: for (i = 0; i < pntpd->cPSForms; i++)
2326: {
2327: if (!(NameComp((CHAR *)pntpd + pntpd->loDefaultForm,
2328: (CHAR *)pntpd + pPSForm->loFormName)))
2329: {
2330: strcpy(pdev->CurForm.FormName, (CHAR *)pntpd + pntpd->loDefaultForm);
2331: strcpy(pdev->CurForm.PrinterForm, (CHAR *)pntpd + pntpd->loDefaultForm);
2332: pdev->CurForm.imagearea = pPSForm->imagearea;
2333: pdev->CurForm.sizlPaper = pPSForm->sizlPaper;
2334: AdjustForLandscape(pdev);
2335: return;
2336: }
2337:
2338: // point to the next PSFORM.
2339:
2340: pPSForm++;
2341: }
2342:
2343: // the default form was not found. select the first one in the ppd file.
2344:
2345: pPSForm = (PSFORM *)((CHAR *)pntpd + pntpd->loPSFORMArray);
2346: strcpy(pdev->CurForm.FormName, (CHAR *)pntpd + pPSForm->loFormName);
2347: strcpy(pdev->CurForm.PrinterForm, (CHAR *)pntpd + pPSForm->loFormName);
2348: pdev->CurForm.imagearea = pPSForm->imagearea;
2349: pdev->CurForm.sizlPaper = pPSForm->sizlPaper;
2350:
2351: AdjustForLandscape(pdev);
2352: }
2353:
2354:
2355: //--------------------------------------------------------------------------
2356: // VOID AdjustForLandscape(pdev)
2357: // PDEVDATA pdev;
2358: //
2359: // This routine adjusts the CURRENTFORM structure in the DEVDATA,
2360: // depending on the orientation.
2361: //
2362: // Parameters
2363: // pdev:
2364: // Pointer to DEVDATA structure.
2365: //
2366: // Returns
2367: // This function returns no value.
2368: //
2369: // History:
2370: // 13-Dec-1992 -by- Kent Settle (kentse)
2371: // Wrote it.
2372: //--------------------------------------------------------------------------
2373:
2374: VOID AdjustForLandscape(pdev)
2375: PDEVDATA pdev;
2376: {
2377: LONG lTmp;
2378: RECTL imagearea;
2379:
2380: // if we are about to print in landscape mode, flip over the form
2381: // metrics.
2382:
2383: if (pdev->psdm.dm.dmFields & DM_ORIENTATION)
2384: {
2385: if (pdev->psdm.dm.dmOrientation == DMORIENT_LANDSCAPE)
2386: {
2387: lTmp = pdev->CurForm.sizlPaper.cx;
2388: pdev->CurForm.sizlPaper.cx = pdev->CurForm.sizlPaper.cy;
2389: pdev->CurForm.sizlPaper.cy = lTmp;
2390:
2391: #ifdef LANDSCAPE_270_ROTATE
2392: imagearea.left = pdev->CurForm.sizlPaper.cx -
2393: pdev->CurForm.imagearea.top;
2394: imagearea.top = pdev->CurForm.imagearea.right;
2395: imagearea.right = pdev->CurForm.sizlPaper.cx -
2396: pdev->CurForm.imagearea.bottom;
2397: imagearea.bottom = pdev->CurForm.imagearea.left;
2398: #else // 90 degree rotate case.
2399: imagearea.left = pdev->CurForm.imagearea.bottom;
2400: imagearea.top = pdev->CurForm.sizlPaper.cy -
2401: pdev->CurForm.imagearea.left;
2402: imagearea.right = pdev->CurForm.imagearea.top;
2403: imagearea.bottom = pdev->CurForm.sizlPaper.cy -
2404: pdev->CurForm.imagearea.right;
2405: #endif
2406:
2407: pdev->CurForm.imagearea = imagearea;
2408: }
2409: }
2410: }
2411:
2412:
2413: //--------------------------------------------------------------------------
2414: // VOID AdjustFormToPrinter(pdev)
2415: // PDEVDATA pdev;
2416: //
2417: // This routine searches the NTPD structure for a PSFORM structure which
2418: // matches the name specified by pwstrFormName. When it finds a match, it
2419: // intersects the imageable areas as defined in the CURRENTFORM structure
2420: // in the DEVDATA, and in the PSFORM structure in the NTPD. If a name match
2421: // is not found, then try to fit it to the smallest form which is large
2422: // enough to print on.
2423: //
2424: // Parameters
2425: // pdev:
2426: // Pointer to DEVDATA structure.
2427: //
2428: // Returns
2429: // This function returns no value.
2430: //
2431: // History:
2432: // 13-Dec-1992 -by- Kent Settle (kentse)
2433: // Wrote it.
2434: //--------------------------------------------------------------------------
2435:
2436: VOID AdjustFormToPrinter(pdev)
2437: PDEVDATA pdev;
2438: {
2439: PNTPD pntpd;
2440: PSFORM *pPSForm;
2441: DWORD i;
2442: CURRENTFORM *pcurform;
2443: BOOL bFound;
2444: SIZEL sizldelta, sizltmp;
2445:
2446: // get some local pointers.
2447:
2448: pntpd = pdev->pntpd;
2449: pcurform = &pdev->CurForm;
2450:
2451: // find the printer's form metrics from the NTPD.
2452:
2453: pPSForm = (PSFORM *)((CHAR *)pntpd + pntpd->loPSFORMArray);
2454:
2455: // first try to match a form by name.
2456:
2457: bFound = FALSE;
2458:
2459: for (i = 0; i < pntpd->cPSForms; i++)
2460: {
2461: if (!(NameComp(pcurform->FormName, (CHAR *)pntpd + pPSForm->loFormName)))
2462: {
2463: // in this case, the printer form name and the database form
2464: // name are the same.
2465:
2466: // check to see if the form is changing within a document.
2467:
2468: if ((*pcurform->PrinterForm) &&
2469: strncmp(pcurform->PrinterForm, pcurform->FormName, CCHFORMNAME))
2470: pdev->dwFlags |= PDEV_CHANGEFORM;
2471: else
2472: pdev->dwFlags &= ~PDEV_CHANGEFORM;
2473:
2474: strncpy(pcurform->PrinterForm, pcurform->FormName, CCHFORMNAME);
2475:
2476: IntersectImageableAreas(pcurform, pPSForm);
2477:
2478: bFound = TRUE;
2479: break;
2480: }
2481:
2482: // point to the next PSFORM.
2483:
2484: pPSForm++;
2485: }
2486:
2487: // if we did not find a name match, try to locate a form by size.
2488:
2489: if (!bFound)
2490: {
2491: // get pointer to first form in NTPD.
2492:
2493: pPSForm = (PSFORM *)((CHAR *)pntpd + pntpd->loPSFORMArray);
2494:
2495: // sizldelta is used to hold the difference between form sizes.
2496: // initialize to large value.
2497:
2498: sizldelta.cx = sizldelta.cy = INITIAL_FORM_DELTA;
2499:
2500: for (i = 0; i < pntpd->cPSForms; i++)
2501: {
2502: sizltmp.cx = pPSForm->sizlPaper.cx - pcurform->sizlPaper.cx;
2503: sizltmp.cy = pPSForm->sizlPaper.cy - pcurform->sizlPaper.cy;
2504:
2505: // see if we have an exact match on size.
2506:
2507: if ((sizltmp.cx == 0) && (sizltmp.cy == 0))
2508: {
2509: // we have an exact match on size, so overwrite the form
2510: // name with the name the printer knows about.
2511:
2512: strncpy(pcurform->PrinterForm,
2513: (CHAR *)pntpd + pPSForm->loFormName, CCHFORMNAME);
2514:
2515: IntersectImageableAreas(pcurform, pPSForm);
2516:
2517: bFound = TRUE;
2518: break;
2519: }
2520:
2521: // not an exact match, but see if we could fit on this form.
2522:
2523: if ((sizltmp.cx >= 0) && (sizltmp.cy >= 0))
2524: {
2525: // we can fit on this form. let's see if it is the smallest.
2526:
2527: if ((sizltmp.cx <= sizldelta.cx) &&
2528: (sizltmp.cy <= sizldelta.cy))
2529: {
2530: // this form is the smallest yet.
2531:
2532: sizldelta = sizltmp;
2533: strncpy(pcurform->PrinterForm,
2534: (CHAR *)pntpd + pPSForm->loFormName, CCHFORMNAME);
2535:
2536: IntersectImageableAreas(pcurform, pPSForm);
2537:
2538: bFound = TRUE;
2539: }
2540: }
2541:
2542: // point to the next PSFORM.
2543:
2544: pPSForm++;
2545: }
2546: }
2547:
2548: // if we found a useable form, use it, otherwise set to default form.
2549:
2550: if (bFound)
2551: AdjustForLandscape(pdev);
2552: else
2553: SetCurrentFormToDefault(pdev);
2554: }
2555:
2556:
2557: //--------------------------------------------------------------------------
2558: // VOID IntersectImageableAreas(pcurform, pPSForm);
2559: // CURRENTFORM *pcurform;
2560: // PSFORM *pPSForm;
2561: //
2562: // This routine intersects the imageable areas of the form found in the
2563: // forms database, with the printer form.
2564: //
2565: // Returns
2566: // This function returns no value.
2567: //
2568: // History:
2569: // 13-Dec-1992 -by- Kent Settle (kentse)
2570: // Wrote it.
2571: //--------------------------------------------------------------------------
2572:
2573: VOID IntersectImageableAreas(pcurform, pPSForm)
2574: CURRENTFORM *pcurform;
2575: PSFORM *pPSForm;
2576: {
2577: pcurform->imagearea.left = max(pPSForm->imagearea.left,
2578: pcurform->imagearea.left);
2579: pcurform->imagearea.top = min(pPSForm->imagearea.top,
2580: pcurform->imagearea.top);
2581: pcurform->imagearea.right = min(pPSForm->imagearea.right,
2582: pcurform->imagearea.right);
2583: pcurform->imagearea.bottom = max(pPSForm->imagearea.bottom,
2584: pcurform->imagearea.bottom);
2585: }
2586:
2587:
2588: //--------------------------------------------------------------------------
2589: // VOID FillInCURRENTFORM(pdev, pdbForm)
2590: // PDEVDATA pdev;
2591: // FORM_INFO_1 *pdbForm;
2592: //
2593: // This routine fills in the CURRENTFORM structure in the DEVDATA, using
2594: // the FORM_INFO_1 structure passed in.
2595: //
2596: // Parameters
2597: // pdev:
2598: // Pointer to DEVDATA structure.
2599: //
2600: // pdbForm:
2601: // Pointer to FORM_INFO_1 structure from forms database.
2602: //
2603: // Returns
2604: // This function returns no value.
2605: //
2606: // History:
2607: // 13-Dec-1992 -by- Kent Settle (kentse)
2608: // Wrote it.
2609: //--------------------------------------------------------------------------
2610:
2611: VOID FillInCURRENTFORM(pdev, pdbForm)
2612: PDEVDATA pdev;
2613: FORM_INFO_1 *pdbForm;
2614: {
2615: DWORD i;
2616:
2617: // pdbForm now points to the specified form. fill in the CURRENTFORM
2618: // structure.
2619:
2620: // get the ANSI form name.
2621:
2622: i = wcslen(pdbForm->pName) + 1;
2623:
2624: WideCharToMultiByte(CP_ACP, 0, (LPWSTR)pdbForm->pName, i,
2625: (LPSTR)pdev->CurForm.FormName, i, NULL, NULL);
2626:
2627: pdev->CurForm.sizlPaper.cx = MM001TOUSER(pdbForm->Size.cx);
2628: pdev->CurForm.sizlPaper.cy = MM001TOUSER(pdbForm->Size.cy);
2629:
2630: // fill in the imageable area. NOTE: pdev->CurForm stores the
2631: // imageable area in USER coordinates. This means we need to
2632: // flip over the y coordinates.
2633:
2634: pdev->CurForm.imagearea.left =
2635: MM001TOUSER(pdbForm->ImageableArea.left);
2636: pdev->CurForm.imagearea.top =
2637: MM001TOUSER(pdbForm->Size.cy) -
2638: MM001TOUSER(pdbForm->ImageableArea.top);
2639: pdev->CurForm.imagearea.right =
2640: MM001TOUSER(pdbForm->ImageableArea.right);
2641: pdev->CurForm.imagearea.bottom =
2642: MM001TOUSER(pdbForm->Size.cy) -
2643: MM001TOUSER(pdbForm->ImageableArea.bottom);
2644:
2645: // make sure the printer can print it.
2646:
2647: AdjustFormToPrinter(pdev);
2648: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.