![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pscrptui.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / print / pscrptui|
Return to pscrptui.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscrptui |
1.1 root 1: //--------------------------------------------------------------------------
2: //
3: // Module Name: PSCRPTUI.C
4: //
5: // Brief Description: This module contains the PSCRIPT driver's User
6: // Interface functions and related routines.
7: //
8: // Author: Kent Settle (kentse)
9: // Created: 11-Jul-1991
10: //
11: // Copyright (c) 1991-1992 Microsoft Corporation
12: //
13: // This module contains routines supporting the setting of Printer and
14: // Job Property dialogs for the NT Windows PostScript printer driver.
15: //
16: // The general outline for much of the code was taken from the NT RASDD
17: // printer driver's user interface code, which was written by Steve
18: // Cathcart (stevecat).
19: //--------------------------------------------------------------------------
20:
21: #define _HTUI_APIS_
22:
23: #include <stddef.h>
24: #include <stdlib.h>
25: #include <string.h>
26: #include "pscript.h"
27: #include "shellapi.h"
28: #include <winspool.h>
29: #include "dlgdefs.h"
30: #include "pscrptui.h"
31: #include "help.h"
32:
33: #define UNINITIALIZED_FORM -1
34: #define TRANSLATED_TRAYS 0x00000001
35: #define TRANSLATED_FORMS 0x00000002
36: #define INITIAL_FORM_DELTA 16384
37:
38: // declarations of routines defined within this module.
39:
40: LONG PrtPropDlgProc( HWND, UINT, DWORD, LONG );
41: LONG AboutDlgProc( HWND, UINT, DWORD, LONG );
42: BOOL InitComboBoxes(HWND, PRINTDATA *);
43: BOOL bAbout(HWND, PNTPD);
44: VOID GetPrinterForm(PNTPD, FORM_INFO_1 *, PWSTR);
45:
46: // external routines and data.
47:
48: extern LONG FontInstDlgProc( HWND, UINT, DWORD, LONG);
49: extern LONG TTFontDialogProc(HWND, UINT, DWORD, LONG);
50: extern TT_FONT_MAPPING TTFontTable[]; // ..\pscript\tables.h.
51: extern PFORM_INFO_1 GetFormsDataBase(HANDLE, DWORD *, PNTPD);
52: extern int NameComp(CHAR *, CHAR *);
53:
54: extern
55: void
56: vDoDeviceHTDataUI(
57: LPSTR pDeviceName,
58: BOOL ColorDevice,
59: BOOL bUpdate
60: );
61:
62: extern
63: void
64: vGetDeviceHTData(
65: HANDLE hPrinter,
66: PDEVHTINFO pDefaultDevHTInfo
67: );
68:
69:
70: extern
71: BOOL
72: bSaveDeviceHTData(
73: HANDLE hPrinter,
74: BOOL bForce // TRUE if always update
75: );
76:
77: // global Data
78:
79: DWORD Type=1;
80:
81: BYTE PP_AnsiDeviceName[128];
82:
83: #define MAX_TRAYS 9
84: #define INVALID_TRAY -1L
85: #define INVALID_FORM -1L
86: #define MAX_SKIP 5
87: #define SMALL_BUF 32
88:
89: #define RESOURCE_STRING_LENGTH 128
90:
91: //--------------------------------------------------------------------------
92: // BOOL PrinterProperties(HWND hwnd, LPPRINTER lpPrinter)
93: //
94: // This function first retrieves and displays the current set of printer
95: // properties for the printer. The user is allowed to change the current
96: // printer properties from the displayed dialog box.
97: //
98: // Returns:
99: // This function returns -1L if it fails in any way. If the dialog is
100: // actually displayed, it returns either IDOK or IDCANCEL, depending on
101: // what the user chose. If no dialog box was displayed and the function
102: // is successful, IDOK is returned.
103: //
104: // History:
105: // 11-Jul-1991 -by- Kent Settle (kentse)
106: // Wrote it.
107: //--------------------------------------------------------------------------
108:
109: BOOL PrinterProperties(HWND hwnd, HANDLE hPrinter)
110: {
111: int nResult;
112: PRINTDATA printdata;
113: WCHAR wcbuf[32];
114: DWORD dwTmp;
115: DWORD rc;
116:
117: // fill in PRINTDATA structure.
118:
119: printdata.hPrinter = hPrinter;
120: printdata.iFreeMemory = 0;
121: printdata.pntpd = (PNTPD)NULL;
122: printdata.psetforms = (PLONG)NULL;
123: printdata.bHostHalftoning = TRUE;
124:
125: // simply try to write out to the registry to see if the caller
126: // has permission to change anything.
127:
128: LoadString(hModule, (IDS_PERMISSION + STRING_BASE), wcbuf,
129: (sizeof(wcbuf) / sizeof(wcbuf[0])));
130:
131: dwTmp = 1;
132:
133: rc = SetPrinterData(hPrinter, wcbuf, REG_DWORD, (LPBYTE)&dwTmp,
134: sizeof(DWORD));
135:
136: if (rc == ERROR_SUCCESS)
137: printdata.bPermission = TRUE;
138: else
139: printdata.bPermission = FALSE;
140:
141: // call the printer properties dialog routine.
142:
143: nResult = DialogBoxParam (hModule, MAKEINTRESOURCE(PRINTER_PROP), hwnd,
144: (DLGPROC)PrtPropDlgProc, (LPARAM)&printdata);
145:
146: return(nResult);
147: }
148:
149:
150: //--------------------------------------------------------------------------
151: // LONG APIENTRY AboutDlgProc (HWND hDlg, UINT message, DWORD wParam,
152: // LONG lParam)
153: //
154: // This function processes messages for the "About" dialog box.
155: //
156: // Returns:
157: // This function returns TRUE if successful, FALSE otherwise.
158: //
159: // History:
160: // 11-Jul-1991 -by- Kent Settle (kentse)
161: // Wrote it.
162: //--------------------------------------------------------------------------
163:
164: LONG AboutDlgProc(
165: HWND hDlg,
166: UINT message,
167: DWORD wParam,
168: LONG lParam
169: )
170: {
171: UNREFERENCED_PARAMETER (lParam);
172:
173: switch (message)
174: {
175: case WM_INITDIALOG:
176: return (TRUE);
177:
178: case WM_COMMAND:
179: if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
180: {
181: EndDialog (hDlg, IDOK);
182: return (TRUE);
183: }
184: break;
185: }
186: return (FALSE);
187: }
188:
189:
190: //--------------------------------------------------------------------------
191: // LONG APIENTRY PrtPropDlgProc(HWND hwnd, UINT usMsg, DWORD wParam,
192: // LONG lParam)
193: //
194: // This function processes messages for the "About" dialog box.
195: //
196: // Returns:
197: // This function returns TRUE if successful, FALSE otherwise.
198: //
199: // History:
200: // 11-Jul-1991 -by- Kent Settle (kentse)
201: // Wrote it.
202: //--------------------------------------------------------------------------
203:
204: LONG APIENTRY PrtPropDlgProc(HWND hwnd, UINT usMsg, DWORD wParam,
205: LONG lParam)
206: {
207: LPWSTR pwDeviceName;
208: int i, rc;
209: int iSelect;
210: WCHAR wcbuf1[SMALL_BUF];
211: WCHAR wcbuf2[MAX_FONTNAME * 2];
212: WCHAR wcbuf3[MAX_FONTNAME];
213: DWORD cbNeeded, cbTrayForm;
214: int cTrays;
215: int iForm, iTray;
216: LONG lReturn;
217: BOOL bTmp;
218: DWORD returnvalue;
219: WCHAR SlotName[MAX_SLOT_NAME];
220: WCHAR FormName[CCHFORMNAME];
221: WCHAR PrinterForm[CCHFORMNAME];
222: PRINTDATA *pdata;
223: PLONG psetform;
224: WCHAR *pwstr;
225: WCHAR *pwstrsave;
226: FORM_INFO_1 *pForm;
227:
228: switch (usMsg)
229: {
230: case WM_INITDIALOG:
231: pdata = (PRINTDATA *)lParam;
232:
233: if (!pdata)
234: {
235: RIP("PSCRPTUI!PrtPropDlgProc: null pdata.\n");
236: return(FALSE);
237: }
238:
239: // save the PRINTDATA.
240:
241: SetWindowLong(hwnd, GWL_USERDATA, lParam);
242:
243: if (!(pdata->pntpd = MapPrinter(pdata->hPrinter)))
244: {
245: RIP("PSCRPTUI!PrtPropDlgProc: MapPrinter failed.\n");
246: return(FALSE);
247: }
248:
249: //
250: // Make up ANSI version of the device name for later halftone
251: // UI to use
252: //
253:
254: pwDeviceName = (LPWSTR)((PSTR)pdata->pntpd +
255: pdata->pntpd->lowszPrinterName);
256:
257: WideCharToMultiByte(CP_ACP,
258: 0,
259: (LPWSTR)pwDeviceName,
260: (INT)(wcslen(pwDeviceName) + 1),
261: PP_AnsiDeviceName,
262: sizeof(PP_AnsiDeviceName),
263: NULL,
264: NULL);
265:
266: //
267: // First read in the current DEVHTINFO data
268: //
269: // !!! If you can read the DEVHTINFO from MINI DRIVERS, then pass that
270: // !!! pointer to the GetDeviceHTData(), the DEVHTINFO is at end of
271: // !!! winddi.h, it includes COLORINFO, DevPelSize, HTPatternSize and
272: // !!! so on. If a NULL is passed then standard halftone default will
273: // !!! be used to set in the registry at first time
274: //
275:
276: vGetDeviceHTData(pdata->hPrinter, NULL);
277:
278:
279: // fill in the default printer memory configuration. first
280: // check to see if a value has been saved in the registry.
281: // if so, use it, otherwise, get the default value from
282: // the PPD file.
283:
284: LoadString(hModule, (IDS_FREEMEM + STRING_BASE),
285: wcbuf2, (sizeof(wcbuf2) / sizeof(wcbuf2[0])));
286:
287: returnvalue = GetPrinterData(pdata->hPrinter, wcbuf2, &Type,
288: (LPBYTE)&pdata->iFreeMemory,
289: sizeof(pdata->iFreeMemory), &cbNeeded);
290:
291: if (returnvalue != NO_ERROR)
292: pdata->iFreeMemory = pdata->pntpd->cbFreeVM;
293:
294: SetDlgItemInt(hwnd, IDD_MEMORY_EDIT_BOX, pdata->iFreeMemory, FALSE);
295:
296: // initialize the printer model name.
297:
298: SetDlgItemText(hwnd, IDD_MODEL_TEXT,
299: (PWSTR)((PSTR)pdata->pntpd + pdata->pntpd->lowszPrinterName));
300:
301: // initialize the paper tray and paper size list boxes.
302:
303: if (!InitComboBoxes(hwnd, pdata))
304: RIP("PrtPropDlgProc: InitComboBoxes failed.\n");
305:
306:
307: // Get the current setting of the PS_HALFTONING flag from the
308: // registry and initialize the check button.
309:
310: LoadString(hModule, (IDS_HALFTONE + STRING_BASE),
311: wcbuf3, (sizeof(wcbuf3) / sizeof(wcbuf3[0])));
312:
313: returnvalue = GetPrinterData(pdata->hPrinter,
314: wcbuf3,
315: &Type,
316: (LPBYTE)&(pdata->bHostHalftoning),
317: sizeof(pdata->bHostHalftoning),
318: &cbNeeded);
319:
320: // printer halftoning is OFF by default. ie, use system halftoning.
321:
322: if (returnvalue != NO_ERROR)
323: {
324: pdata->bHostHalftoning = TRUE;
325: }
326:
327: CheckDlgButton(hwnd,
328: IDD_USE_HOST_HALFTONING,
329: !((pdata->bHostHalftoning)));
330:
331: // if the user has selected printer halfoning, disable the system halftoning
332: // push button.
333:
334: if (pdata->bHostHalftoning)
335: EnableWindow(GetDlgItem(hwnd, IDD_HALFTONE_PUSH_BUTTON), TRUE);
336: else
337: EnableWindow(GetDlgItem(hwnd, IDD_HALFTONE_PUSH_BUTTON), FALSE);
338:
339: // intialize the help stuff.
340:
341: vHelpInit();
342:
343: // disable a bunch of stuff if the user does not have
344: // permission to change it.
345:
346: if (!pdata->bPermission)
347: {
348: EnableWindow(GetDlgItem(hwnd, IDD_PAPER_LIST_BOX), FALSE);
349: EnableWindow(GetDlgItem(hwnd, IDD_MEMORY_EDIT_BOX), FALSE);
350: EnableWindow(GetDlgItem(hwnd, IDD_USE_HOST_HALFTONING), FALSE);
351: }
352: return TRUE;
353: break;
354:
355: case WM_COMMAND:
356: pdata = (PRINTDATA *)GetWindowLong(hwnd, GWL_USERDATA);
357:
358: switch (LOWORD(wParam))
359: {
360: case IDD_ABOUT_BUTTON:
361: return(bAbout(hwnd, pdata->pntpd));
362:
363: case IDD_FONTS_BUTTON:
364: lReturn = DialogBoxParam (hModule, MAKEINTRESOURCE(FONTINST), hwnd,
365: (DLGPROC)FontInstDlgProc,
366: (LPARAM)pdata);
367:
368: if (lReturn == -1)
369: {
370: RIP("PSCRPTUI!PrtPropDlgProc: DialogBoxParam for FONTINST failed.\n");
371: return(FALSE);
372: }
373:
374: return (TRUE);
375:
376: case IDD_FONT_SUBST_PUSH_BUTTON:
377: lReturn = DialogBoxParam(hModule, MAKEINTRESOURCE(IDD_TT_DIALOG),
378: hwnd, (DLGPROC)TTFontDialogProc,
379: (LPARAM)pdata);
380:
381: if (lReturn == -1)
382: {
383: RIP("PSCRPTUI!PrtPropDlgProc: DialogBoxParam for TTFONTS failed.\n");
384: return(FALSE);
385: }
386:
387: return (TRUE);
388:
389: //
390: // Button for toggling host versus device halftoning mode.
391: // -- DJS
392: case IDD_USE_HOST_HALFTONING:
393:
394: if(IsDlgButtonChecked(hwnd, IDD_USE_HOST_HALFTONING))
395: {
396: pdata->bHostHalftoning = FALSE;
397: EnableWindow(GetDlgItem(hwnd, IDD_HALFTONE_PUSH_BUTTON),
398: FALSE);
399: }
400: else
401: {
402: pdata->bHostHalftoning = TRUE;
403: EnableWindow(GetDlgItem(hwnd, IDD_HALFTONE_PUSH_BUTTON),
404: TRUE);
405: }
406:
407: break;
408:
409: return(TRUE);
410:
411: case IDD_HALFTONE_PUSH_BUTTON:
412:
413: vDoDeviceHTDataUI(PP_AnsiDeviceName,
414: (pdata->pntpd->flFlags & COLOR_DEVICE),
415: pdata->bPermission);
416:
417: return(TRUE);
418:
419: case IDD_TRAY_LIST_BOX:
420: if (HIWORD (wParam) != CBN_SELCHANGE)
421: return (FALSE);
422:
423: // get the index for the currently selected tray.
424:
425: iTray = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX,
426: CB_GETCURSEL, (WPARAM)0,
427: (LPARAM)0);
428:
429: // get the index of the corresponding form.
430:
431: iForm = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX,
432: CB_GETITEMDATA,
433: (WPARAM)iTray,
434: (LPARAM)0);
435:
436: // highlight the form that has previously been
437: // associated with this tray.
438:
439: SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX, CB_SETCURSEL,
440: (WPARAM)iForm, (LPARAM)0);
441:
442: // write this association to our selected forms list.
443:
444: psetform = pdata->psetforms;
445:
446: psetform[iTray] = iForm;
447:
448: break;
449:
450: case IDD_PAPER_LIST_BOX:
451: if (HIWORD (wParam) != CBN_SELCHANGE)
452: return (FALSE);
453:
454: // get the index for the currently selected tray.
455:
456: iTray = SendDlgItemMessage (hwnd, IDD_TRAY_LIST_BOX,
457: CB_GETCURSEL, (WPARAM)0,
458: (LPARAM)0);
459:
460: // get the index for the currently selected form.
461:
462: iForm = SendDlgItemMessage (hwnd, IDD_PAPER_LIST_BOX,
463: CB_GETCURSEL, (WPARAM)0,
464: (LPARAM)0);
465:
466: // associate the current form with the current tray.
467:
468: SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_SETITEMDATA,
469: (WPARAM)iTray, (LPARAM)iForm);
470:
471: // write this association to our selected forms list.
472:
473: psetform = pdata->psetforms;
474:
475: psetform[iTray] = iForm;
476:
477: break;
478:
479: case IDD_HELP_BUTTON:
480: vShowHelp(hwnd, HELP_CONTEXT, HLP_PRINTER_SETUP,
481: pdata->hPrinter);
482: return(TRUE);
483:
484: case IDOK:
485: if (pdata->bPermission)
486: {
487: // get the new value from the memory edit box.
488:
489: i = GetDlgItemInt(hwnd, IDD_MEMORY_EDIT_BOX, &bTmp, FALSE);
490:
491: // if the user has changed the memory setting,
492: // pop up a message box.
493:
494: if (i != (int)pdata->iFreeMemory)
495: {
496: // warn the user that changing the memory setting
497: // is dangerous.
498:
499: LoadString(hModule,
500: (IDS_MEMWARN + STRING_BASE),
501: (LPWSTR)wcbuf2,
502: (sizeof(wcbuf2) / sizeof(wcbuf2[0])));
503:
504: LoadString(hModule,
505: (IDS_CAUTION + STRING_BASE),
506: (LPWSTR)wcbuf1,
507: (sizeof(wcbuf1) / sizeof(wcbuf1[0])));
508:
509: iSelect = MessageBox(hwnd, wcbuf2, wcbuf1,
510: MB_DEFBUTTON2 |
511: MB_ICONEXCLAMATION | MB_YESNO);
512:
513: if (iSelect == IDYES)
514: pdata->iFreeMemory = i;
515: else
516: {
517: // reset the memory edit box.
518:
519: SendDlgItemMessage(hwnd, IDD_MEMORY_EDIT_BOX,
520: EM_SETSEL, 0, 0x7FFF0000);
521:
522: SetDlgItemInt(hwnd, IDD_MEMORY_EDIT_BOX,
523: pdata->iFreeMemory, FALSE);
524:
525: break;
526: }
527: }
528:
529: // output the free memory to the .INI file.
530:
531: LoadString(hModule, (IDS_FREEMEM + STRING_BASE),
532: wcbuf2, (sizeof(wcbuf2) / sizeof(wcbuf2[0])));
533:
534: #if DBG
535: if (SetPrinterData(pdata->hPrinter, wcbuf2, REG_BINARY,
536: (LPBYTE)&pdata->iFreeMemory,
537: sizeof(pdata->iFreeMemory)))
538: RIP("PSCRPTUI!PrtPropDlgProc: SetPrinterData FreeMem failed.\n");
539: #else
540: SetPrinterData(pdata->hPrinter, wcbuf2, REG_BINARY,
541: (LPBYTE)&pdata->iFreeMemory,
542: sizeof(pdata->iFreeMemory));
543: #endif
544:
545:
546: // Set Halftone flag in Registry
547:
548: LoadString(hModule, (IDS_HALFTONE + STRING_BASE),
549: wcbuf3, (sizeof(wcbuf3) / sizeof(wcbuf3[0])));
550:
551: SetPrinterData(pdata->hPrinter,
552: wcbuf3,
553: REG_BINARY,
554: (LPBYTE)&(pdata->bHostHalftoning),
555: sizeof(pdata->bHostHalftoning));
556:
557: // output the corresponding tray - form pairs to the
558: // registry.
559:
560: cTrays = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX,
561: CB_GETCOUNT, (WPARAM)0,
562: (LPARAM)0);
563:
564: psetform = pdata->psetforms;
565:
566: // first calculate what size buffer we need.
567: // allow room for double NULL terminator.
568:
569: cbTrayForm = 1;
570:
571: for (i = 0; i < cTrays; i++)
572: {
573: // only output the pair if it has been selected by
574: // the user.
575:
576: if (*psetform++ != UNINITIALIZED_FORM)
577: {
578: // get the tray name.
579:
580: SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX,
581: CB_GETLBTEXT, (WPARAM)i,
582: (LPARAM)SlotName);
583:
584: // now get the corresponding form name.
585:
586: iForm = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX,
587: CB_GETITEMDATA, (WPARAM)i,
588: (LPARAM)0);
589:
590: if (iForm != CB_ERR)
591: {
592: // get the form name, and write the tray-form
593: // pair to the registry.
594:
595: rc = SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX,
596: CB_GETLBTEXT, (WPARAM)iForm,
597: (LPARAM)FormName);
598:
599: // now that we have the selected form name
600: // match it to a form which the printer
601: // supports, and save the printer form
602: // name as well.
603:
604: // first, get the metrics for the selected
605: // form from the forms database.
606:
607: GetForm(pdata->hPrinter, FormName, 1,
608: NULL, 0, &cbNeeded);
609:
610: if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
611: {
612: #if DBG
613: DbgPrint("PSCRPTUI!PrinterPropDlgProc: GetForm returns error %x\n",
614: GetLastError());
615: #endif
616: return(FALSE);
617: }
618:
619: pForm = (FORM_INFO_1 *)GlobalAlloc(GMEM_FIXED |
620: GMEM_ZEROINIT,
621: cbNeeded);
622: if (pForm == NULL)
623: return(FALSE);
624:
625: GetForm(pdata->hPrinter, FormName, 1,
626: (BYTE *)pForm, cbNeeded, &cbNeeded);
627:
628: GetPrinterForm(pdata->pntpd, pForm,
629: PrinterForm);
630:
631: GlobalFree((HGLOBAL)pForm);
632:
633: if (rc != CB_ERR)
634: {
635: cbTrayForm += (wcslen(SlotName) + 1);
636: cbTrayForm += (wcslen(FormName) + 1);
637: cbTrayForm += (wcslen(PrinterForm) + 1);
638: }
639: }
640: }
641: }
642:
643: cbTrayForm *= sizeof(WCHAR);
644:
645: // allocate a buffer.
646:
647: if (!(pwstr = (WCHAR *)GlobalAlloc(GMEM_FIXED |
648: GMEM_ZEROINIT,
649: cbTrayForm)))
650: {
651: RIP("PSCRPTUI!PrtPropDialogProc: GlobalAlloc pwstr failed.\n");
652: return(FALSE);
653: }
654:
655: psetform = pdata->psetforms;
656:
657: pwstrsave = pwstr;
658:
659: // write the tray form pairs in the following form:
660: // a NULL terminated UNICODE Tray (Slot) name followed
661: // by the matching NULL terminated form name, then
662: // followed by the matching NULL terminated printer
663: // for name. this sequence is repeated until a double
664: // NULL terminator ends the table.
665:
666: for (i = 0; i < cTrays; i++)
667: {
668: // only output the triplet if it has been selected by
669: // the user.
670:
671: if (*psetform++ != UNINITIALIZED_FORM)
672: {
673: // get the tray name.
674:
675: SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX,
676: CB_GETLBTEXT, (WPARAM)i,
677: (LPARAM)SlotName);
678:
679: // now get the corresponding form name.
680:
681: iForm = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX,
682: CB_GETITEMDATA, (WPARAM)i,
683: (LPARAM)0);
684:
685: if (iForm != CB_ERR)
686: {
687: // get the form name, and write the tray-form
688: // pair to the registry.
689:
690: rc = SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX,
691: CB_GETLBTEXT, (WPARAM)iForm,
692: (LPARAM)FormName);
693:
694: // first, get the metrics for the selected
695: // form from the forms database.
696:
697: GetForm(pdata->hPrinter, FormName, 1,
698: NULL, 0, &cbNeeded);
699:
700: if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
701: {
702: #if DBG
703: DbgPrint("PSCRPTUI!PrinterPropDlgProc: GetForm returns error %x\n",
704: GetLastError());
705: #endif
706: return(FALSE);
707: }
708:
709: pForm = (FORM_INFO_1 *)GlobalAlloc(GMEM_FIXED |
710: GMEM_ZEROINIT,
711: cbNeeded);
712: if (pForm == NULL)
713: return(FALSE);
714:
715: GetForm(pdata->hPrinter, FormName, 1,
716: (BYTE *)pForm, cbNeeded, &cbNeeded);
717:
718: GetPrinterForm(pdata->pntpd, pForm,
719: PrinterForm);
720:
721: GlobalFree((HGLOBAL)pForm);
722:
723: if (rc != CB_ERR)
724: {
725: // write pair to the buffer.
726:
727: wcscpy(pwstr, SlotName);
728: pwstr += (wcslen(SlotName) + 1);
729: wcscpy(pwstr, FormName);
730: pwstr += (wcslen(FormName) + 1);
731: wcscpy(pwstr, PrinterForm);
732: pwstr += (wcslen(PrinterForm) + 1);
733: }
734: }
735: }
736: }
737:
738: // add the last NULL terminator.
739:
740: *pwstr = (WCHAR)'\0';
741:
742: // now output the tray-form table to the registry.
743:
744: LoadString(hModule, (IDS_TRAY_FORM_TABLE + STRING_BASE),
745: wcbuf3, (sizeof(wcbuf3) / sizeof(wcbuf3[0])));
746:
747: SetPrinterData(pdata->hPrinter, wcbuf3, REG_BINARY,
748: (LPBYTE)pwstrsave, cbTrayForm);
749:
750: // now output the table size to the registry.
751:
752: LoadString(hModule, (IDS_TRAY_FORM_SIZE + STRING_BASE),
753: wcbuf3, (sizeof(wcbuf3) / sizeof(wcbuf3[0])));
754:
755: SetPrinterData(pdata->hPrinter, wcbuf3, REG_DWORD,
756: (LPBYTE)&cbTrayForm, sizeof(cbTrayForm));
757:
758: // free up buffer.
759:
760: GlobalFree((HGLOBAL)pwstrsave);
761:
762: //
763: // save that halftone device data back into registry
764: //
765:
766: bSaveDeviceHTData(pdata->hPrinter, FALSE);
767: }
768:
769: if (pdata->pntpd)
770: {
771: GlobalFree((HGLOBAL)pdata->pntpd);
772: pdata->pntpd = NULL;
773: }
774:
775: if (pdata->psetforms)
776: {
777: GlobalFree((HGLOBAL)pdata->psetforms);
778: pdata->psetforms = NULL;
779: }
780:
781: EndDialog (hwnd, IDOK);
782: return TRUE;
783:
784: case IDCANCEL:
785: if (pdata->pntpd)
786: {
787: GlobalFree((HGLOBAL)pdata->pntpd);
788: pdata->pntpd = NULL;
789: }
790:
791: if (pdata->psetforms)
792: {
793: GlobalFree((HGLOBAL)pdata->psetforms);
794: pdata->psetforms = NULL;
795: }
796:
797: EndDialog (hwnd, IDCANCEL);
798: return TRUE;
799:
800: default:
801: return (FALSE);
802: }
803: break;
804:
805: case WM_DESTROY:
806: // clean up any used help stuff.
807:
808: vHelpDone(hwnd);
809: return (TRUE);
810:
811: default:
812: return (FALSE); /* didn't process the message */
813: }
814: }
815:
816:
817: //--------------------------------------------------------------------------
818: // BOOL InitComboBoxes(hwnd, pdata)
819: // HWND hwnd; // handle to dialog window
820: // PRINTDATA *pdata;
821: //
822: // Parameters
823: //
824: // Returns:
825: // This routine returns TRUE for success, FALSE otherwise.
826: //
827: // History:
828: // 10-Apr-1991 -by- Kent Settle (kentse)
829: // Made it use PNTPD instead of PPRINTER.
830: // 21-Jan-1991 -by- Kent Settle (kentse)
831: // Brought in from Windows 3.1, modified for NT, and clean up.
832: //--------------------------------------------------------------------------
833:
834: BOOL InitComboBoxes(hwnd, pdata)
835: HWND hwnd; // handle to dialog window
836: PRINTDATA *pdata;
837: {
838: WCHAR SlotName[MAX_SLOT_NAME];
839: WCHAR SearchName[MAX_SLOT_NAME + 4];
840: WCHAR FormName[CCHFORMNAME];
841: WCHAR wcbuf[MAX_FONTNAME];
842: DWORD i, j, dwType, cbTrayForm;
843: DWORD cbNeeded, dwTmp, count;
844: int rc, DefaultForm, iForm;
845: PSFORM *pPSForm;
846: FORM_INFO_1 *pFormI1, *pFormI1Save;
847: FORM_INFO_1 *pdbForm, *pdbForms;
848: PWSTR pwstrName, pwstrSave;
849: PSINPUTSLOT *pslots;
850: PNTPD pntpd;
851: PLONG psetform;
852: PSTR pstr, pstrSave, pstrDefault;
853: BOOL bFound;
854:
855: // clear out the tray and form list boxes before we begin.
856:
857: SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX, CB_RESETCONTENT, 0, 0L);
858: SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_RESETCONTENT, 0, 0L);
859:
860: // limit the length of the strings allowed.
861:
862: SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX, CB_LIMITTEXT,
863: (WPARAM)CCHFORMNAME, (LPARAM)0);
864: SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_LIMITTEXT,
865: (WPARAM)MAX_SLOT_NAME, (LPARAM)0);
866:
867: // here is a brief overview of how we will fill in the forms list
868: // box: firstly, call AddForm for each form in the ppd file, if
869: // this has not been done yet. then enumerate the forms database.
870: // then for each form in the database, see if there is a form
871: // defined in the PPD file which is large enough to print on. if
872: // there is, this form gets added to the list box.
873:
874: // start out by setting up a FORM_INFO_1 structure for each form
875: // defined in the NTPD structure.
876:
877: // point to the start of the array of PSFORM structures within
878: // the NTPD structure.
879:
880: pntpd = pdata->pntpd;
881:
882: pPSForm = (PSFORM *)((CHAR *)pntpd + pntpd->loPSFORMArray);
883:
884: // allocate memory for all the FORM_INFO_1 structures.
885:
886: if (!(pFormI1 = (FORM_INFO_1 *)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT,
887: (pntpd->cPSForms *
888: sizeof(FORM_INFO_1)))))
889: {
890: RIP("PSCRPTUI!InitComboBoxes: GlobalAlloc for pFormI1 failed.\n");
891: return(FALSE);
892: }
893:
894: // keep a copy of the pointer to the first structure.
895:
896: pFormI1Save = pFormI1;
897:
898: // allocate memory for the form name buffers.
899:
900: if (!(pwstrName = (PWSTR)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT,
901: (pntpd->cPSForms * CCHFORMNAME * sizeof(WCHAR)))))
902: {
903: RIP("PSCRPTUI:InitComboBoxes: GlobalAlloc for pwstrName failed.\n");
904: GlobalFree((HGLOBAL)pFormI1);
905: return(FALSE);
906: }
907:
908: // keep a copy of the pointer to the first form name.
909:
910: pwstrSave = pwstrName;
911:
912: // add each form defined in the NTPD structure to the forms
913: // database. AddForm should simply do nothing if this form
914: // already exists in the database.
915:
916: for (i = 0; i < pntpd->cPSForms; i++)
917: {
918: // get the form name from the PSFORM structure and convert it
919: // to UNICODE. you might think "hey, you should store the
920: // name as UNICODE in the PSFORM structure!" however, the
921: // PSFORM structures get calculated on every EnablePDEV, which
922: // will probably happen much more often then this dialog gets
923: // displayed.
924:
925: // check to see if there is a translation string to worry about,
926: // for each form.
927:
928: pstrSave = (CHAR *)pntpd + pPSForm->loFormName;
929:
930: XLATESTRING(pstr);
931:
932: // pstr now points to the form name we want.
933:
934: strcpy2WChar(pwstrName, pstr);
935:
936: pFormI1->pName = pwstrName;
937:
938: // copy the form size and imageable area.
939: // the PSFORM structure stores the form size and the
940: // imageable area in postscript USER coordinate (1/72 inch).
941: // the forms database stores these values in .001mm.
942:
943: pFormI1->Size.cx = USERTO001MM(pPSForm->sizlPaper.cx);
944: pFormI1->Size.cy = USERTO001MM(pPSForm->sizlPaper.cy);
945:
946: pFormI1->ImageableArea.left = USERTO001MM(pPSForm->imagearea.left);
947: pFormI1->ImageableArea.top = USERTO001MM(pPSForm->sizlPaper.cy) -
948: USERTO001MM(pPSForm->imagearea.top);
949: pFormI1->ImageableArea.right = USERTO001MM(pPSForm->imagearea.right);
950: pFormI1->ImageableArea.bottom = USERTO001MM(pPSForm->sizlPaper.cy) -
951: USERTO001MM(pPSForm->imagearea.bottom);
952:
953: // point to the next PSFORM structure in the NTPD. point to the
954: // next FORM_INFO_1 structure we are filling in. point to the next
955: // form name buffer.
956:
957: pPSForm++;
958: pFormI1++;
959: pwstrName += CCHFORMNAME;
960: }
961:
962: LoadString(hModule, (IDS_FORMS + STRING_BASE), SearchName,
963: (sizeof(SearchName) / sizeof(SearchName[0])));
964:
965: rc = GetPrinterData(pdata->hPrinter, SearchName, &dwType, (PBYTE)&dwTmp,
966: sizeof(dwTmp), &cbNeeded);
967:
968: // if we have marked in the registry that we have already added all
969: // the forms for this printer to the forms database, then we do not
970: // need to do it again.
971:
972: if (rc != NO_ERROR)
973: {
974: // add each form defined in the NTPD structure to the forms
975: // database. AddForm should simply do nothing if this form
976: // already exists in the database.
977:
978: pFormI1 = pFormI1Save;
979:
980: for (i = 0; i < pntpd->cPSForms; i++)
981: AddForm(pdata->hPrinter, 1, (PBYTE)pFormI1++);
982:
983: // mark that we have added all the forms to the forms database
984: // for this printer.
985:
986: dwTmp = 1;
987: SetPrinterData(pdata->hPrinter, SearchName, REG_DWORD, (PBYTE)&dwTmp,
988: sizeof(dwTmp));
989: }
990:
991: // we now know that all of the forms in the NTPD structure have been
992: // added to the forms database. now enumerate the database.
993:
994: if (!(pdbForms = GetFormsDataBase(pdata->hPrinter, &count, pntpd)))
995: {
996: RIP("PSCRPTUI!InitComboBoxes: GetFormsDataBase failed.\n");
997:
998: GlobalFree((HGLOBAL)pwstrSave);
999: GlobalFree((HGLOBAL)pFormI1Save);
1000:
1001: return(FALSE);
1002: }
1003: else
1004: {
1005: // put the form in the list box if it is valid for this printer.
1006:
1007: pdbForm = pdbForms;
1008:
1009: for (i = 0; i < count; i++)
1010: {
1011: if (pdbForm->Flags & PSCRIPT_VALID_FORM)
1012: {
1013: // add the form to the list box.
1014:
1015: SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX, CB_INSERTSTRING,
1016: (WPARAM)-1, (LPARAM)pdbForm->pName);
1017: }
1018:
1019: pdbForm++;
1020: }
1021:
1022: SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX, CB_SETCURSEL, 0, 0L);
1023: }
1024:
1025: // free up resources.
1026:
1027: GlobalFree((HGLOBAL)pdbForms);
1028: GlobalFree((HGLOBAL)pwstrSave);
1029: GlobalFree((HGLOBAL)pFormI1Save);
1030:
1031: // if the only inputslot defined is the default inputslot, cInputSlots
1032: // will be zero. in this case, let's simply let the user know that
1033: // this is the only paper tray.
1034:
1035: // NOTE! CB_INSERTSTRING is used rather that CB_ADDSTRING. This will
1036: // keep the order of the paper trays the same as in the PPD file, and
1037: // the same as Win31. CB_ADDSTRING would sort the list.
1038:
1039: if (pntpd->cInputSlots == 0)
1040: {
1041: LoadString(hModule, (SLOTS_BASE + SLOT_ONLYONE),
1042: SlotName, (sizeof(SlotName) / sizeof(SlotName[0])));
1043:
1044: rc = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_INSERTSTRING,
1045: (WPARAM)-1, (LPARAM)SlotName);
1046: }
1047: else
1048: {
1049: // add each input slot defined in the NTPD to the list box.
1050:
1051: pslots = (PSINPUTSLOT *)((CHAR *)pntpd + pntpd->loPSInputSlots);
1052:
1053: for (i = 0; i < (DWORD)pntpd->cInputSlots; i++)
1054: {
1055: // check to see if there is a translation string to worry about,
1056: // for each form.
1057:
1058: pstrSave = (CHAR *)pntpd + pslots->loSlotName;
1059:
1060: XLATESTRING(pstr);
1061:
1062: // pstr now points to the form name we want.
1063:
1064: strcpy2WChar(SlotName, pstr);
1065:
1066: SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_INSERTSTRING,
1067: (WPARAM)-1, (LPARAM)SlotName);
1068:
1069: pslots++;
1070: }
1071: }
1072:
1073: // check to see if the current printer supports manual feed. to do
1074: // this, check to see if a string to turn on manual feed was found.
1075:
1076: if (pntpd->loszManualFeedTRUE != 0)
1077: {
1078: // this printer does support manual feed, so insert this as the
1079: // last choice in the list box.
1080:
1081: LoadString(hModule, (SLOT_MANUAL + SLOTS_BASE),
1082: SlotName, (sizeof(SlotName) / sizeof(SlotName[0])));
1083:
1084: rc = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_INSERTSTRING,
1085: (WPARAM)-1, (LPARAM)SlotName);
1086: }
1087:
1088: // all of the paper trays have been added to the list box. now
1089: // associate each paper tray with a form. this will be done in the
1090: // following manner: for each paper tray, see if an entry exists in
1091: // the registry (eg, "TrayUpper Letter"). if it does, use the form
1092: // specified there, and associate the tray with the index into the
1093: // form list box. if no entry exists in the registry for the tray,
1094: // associate it with the default form.
1095:
1096: // first, find the index to the default form.
1097:
1098: // now see if there is a translation string to worry about.
1099: // do this by checking each device form name, to see if there
1100: // is a match of the "non-translation string" portion of the
1101: // name. This code is confusing; as an example, if Letter is the
1102: // default form, the form name in the PPD file may have a
1103: // translation string such as Letter/US Letter. In this case, we
1104: // want US Letter, not Letter, to be chosen as the default in the
1105: // list box.
1106:
1107: pPSForm = (PSFORM *)((CHAR *)pntpd + pntpd->loPSFORMArray);
1108: bFound = FALSE;
1109: pstrDefault = (CHAR *)pntpd + pntpd->loDefaultForm;
1110:
1111: for (i = 0; i < pntpd->cPSForms; i++)
1112: {
1113: pstr = (CHAR *)pntpd + pPSForm->loFormName;
1114:
1115: dwTmp = strlen(pstr);
1116:
1117: for (j = 0; j < dwTmp; j++)
1118: {
1119: // if we found the translation string deliminator '/',
1120: // then we will substitute the translation string for
1121: // the default.
1122:
1123: if (*pstr == '/')
1124: {
1125: pstr++;
1126: pstrDefault = pstr;
1127: bFound = TRUE;
1128: break;
1129: }
1130:
1131: if (*pstr++ != *pstrDefault++)
1132: break;
1133: }
1134:
1135: // if we found a translation string, we are done.
1136:
1137: if (bFound)
1138: break;
1139: else
1140: pstrDefault = (CHAR *)pntpd + pntpd->loDefaultForm;
1141:
1142: // otherwise go on to the next form.
1143:
1144: pPSForm++;
1145: }
1146:
1147: strcpy2WChar(FormName, pstrDefault);
1148:
1149: DefaultForm = SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX, CB_FINDSTRING,
1150: (WPARAM)-1, (LPARAM)FormName);
1151:
1152: // if there was a problem finding the default form, use the first one
1153: // in the list box.
1154:
1155: if (DefaultForm == CB_ERR)
1156: DefaultForm = 0;
1157:
1158: // now see if a registry entry exists for each tray, and associate it
1159: // with the specified form if so.
1160:
1161: count = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_GETCOUNT,
1162: (WPARAM)0, (LPARAM)0);
1163:
1164: // initialize the list of forms selected by the user to be in each
1165: // paper tray. fill each form index with -1, then fill in the default
1166: // tray with the default form index.
1167:
1168: // allocate memory for all trays.
1169:
1170: if (!(pdata->psetforms = (PLONG)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT,
1171: (count * sizeof(LONG)))))
1172: {
1173: RIP("PSCRPTUI!InitComboBoxes: GlobalAlloc for psetforms failed.\n");
1174: return(FALSE);
1175: }
1176:
1177: // now initialize each entry to -1.
1178:
1179: psetform = pdata->psetforms;
1180:
1181: for (i = 0; i < count; i++)
1182: *psetform++ = UNINITIALIZED_FORM;
1183:
1184: // point back to first entry.
1185:
1186: psetform = pdata->psetforms;
1187:
1188: // first find out the size of the tray-form buffer and copy it from
1189: // the registry.
1190:
1191: // now get the table size from the registry.
1192:
1193: LoadString(hModule, (IDS_TRAY_FORM_SIZE + STRING_BASE),
1194: wcbuf, (sizeof(wcbuf) / sizeof(wcbuf[0])));
1195:
1196: GetPrinterData(pdata->hPrinter, wcbuf, &dwType, (LPBYTE)&cbTrayForm,
1197: sizeof(cbTrayForm), &cbNeeded);
1198:
1199: if (cbTrayForm)
1200: {
1201: // allocate a buffer.
1202:
1203: if (!(pwstrName = (WCHAR *)GlobalAlloc(GMEM_FIXED |
1204: GMEM_ZEROINIT,
1205: cbTrayForm)))
1206: {
1207: RIP("PSCRPTUI!InitComboBoxes: GlobalAlloc pwstrName failed.\n");
1208: return(FALSE);
1209: }
1210:
1211: pwstrSave = pwstrName;
1212:
1213: // now grab the table itself from the registry.
1214:
1215: LoadString(hModule, (IDS_TRAY_FORM_TABLE + STRING_BASE),
1216: wcbuf, (sizeof(wcbuf) / sizeof(wcbuf[0])));
1217:
1218: rc = GetPrinterData(pdata->hPrinter, wcbuf, &dwType, (LPBYTE)pwstrName,
1219: cbTrayForm, &cbNeeded);
1220:
1221: if (rc != ERROR_SUCCESS)
1222: {
1223: RIP("PSCRPTUI!InitComboBoxes: GetPrinterData pwstrName failed.\n");
1224: GlobalFree((HGLOBAL)pwstrSave);
1225: return(FALSE);
1226: }
1227:
1228: for (i = 0; i < count; i++)
1229: {
1230: // get the tray name.
1231:
1232: SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_GETLBTEXT,
1233: (WPARAM)i, (LPARAM)SlotName);
1234:
1235: pwstrName = pwstrSave;
1236:
1237: // search the tray-form table for a matching tray.
1238:
1239: bFound = FALSE;
1240:
1241: while (*pwstrName)
1242: {
1243: if (!(wcscmp(pwstrName, SlotName)))
1244: {
1245: // we found the inplut slot, now get the matching form.
1246:
1247: pwstrName += (wcslen(pwstrName) + 1);
1248: wcsncpy(FormName, pwstrName,
1249: (sizeof(FormName) / sizeof(FormName[0])));
1250: bFound = TRUE;
1251: break;
1252: }
1253: else
1254: {
1255: // this was not the form in question. skip over both form names.
1256:
1257: pwstrName += (wcslen(pwstrName) + 1);
1258: pwstrName += (wcslen(pwstrName) + 1);
1259: pwstrName += (wcslen(pwstrName) + 1);
1260: }
1261: }
1262:
1263: if (bFound)
1264: {
1265: // get the index of the specified form.
1266:
1267: rc = SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX, CB_FINDSTRING,
1268: (WPARAM)-1, (LPARAM)FormName);
1269:
1270: if (rc == CB_ERR)
1271: rc = DefaultForm;
1272: }
1273: else
1274: rc = DefaultForm;
1275:
1276: // save tray form association until we write out to registry.
1277:
1278: psetform[i] = rc;
1279:
1280: // we now have the index of a form to associate with the current tray.
1281:
1282: SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_SETITEMDATA,
1283: (WPARAM)i, (LPARAM)rc);
1284: }
1285:
1286: // free up the tray-form table buffer.
1287:
1288: GlobalFree((HGLOBAL)pwstrSave);
1289: }
1290:
1291: // highlight the default paper tray, and the corresponding form.
1292: // get the default paper tray from the NTPD structure.
1293:
1294: // now see if there is a translation string to worry about.
1295: // do this by checking each device input slot, to see if there
1296: // is a match of the "non-translation string" portion of the
1297: // name.
1298:
1299: pslots = (PSINPUTSLOT *)((CHAR *)pntpd + pntpd->loPSInputSlots);
1300: bFound = FALSE;
1301: pstrDefault = (CHAR *)pntpd + pntpd->loDefaultSlot;
1302:
1303: for (i = 0; i < pntpd->cInputSlots; i++)
1304: {
1305: pstr = (CHAR *)pntpd + pslots->loSlotName;
1306:
1307: dwTmp = strlen(pstr);
1308:
1309: for (j = 0; j < dwTmp; j++)
1310: {
1311: // if we found the translation string deliminator '/',
1312: // then we will substitute the translation string for
1313: // the default.
1314:
1315: if (*pstr == '/')
1316: {
1317: pstr++;
1318: pstrDefault = pstr;
1319: bFound = TRUE;
1320: break;
1321: }
1322:
1323: if (*pstr++ != *pstrDefault++)
1324: break;
1325: }
1326:
1327: // if we found a translation string, we are done.
1328:
1329: if (bFound)
1330: break;
1331: else
1332: pstrDefault = (CHAR *)pntpd + pntpd->loDefaultSlot;
1333:
1334: // otherwise go on to the next form.
1335:
1336: pslots++;
1337: }
1338:
1339: strcpy2WChar(FormName, pstrDefault);
1340: strcpy2WChar(SlotName, (CHAR *)pntpd + pntpd->loDefaultSlot);
1341:
1342: rc = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_FINDSTRING,
1343: (WPARAM)-1, (LPARAM)SlotName);
1344:
1345: // highlight the first tray if there was a problem getting the default
1346: // tray.
1347:
1348: if (rc == CB_ERR)
1349: rc = 0;
1350:
1351: SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_SETCURSEL,
1352: (WPARAM)rc, (LPARAM)0);
1353:
1354: // get the index of the corresponding form.
1355:
1356: iForm = SendDlgItemMessage(hwnd, IDD_TRAY_LIST_BOX, CB_GETITEMDATA,
1357: (WPARAM)rc, (LPARAM)0);
1358:
1359: if (iForm == CB_ERR)
1360: iForm = DefaultForm;
1361:
1362: SendDlgItemMessage(hwnd, IDD_PAPER_LIST_BOX, CB_SETCURSEL,
1363: (WPARAM)iForm, (LPARAM)0);
1364:
1365: return TRUE;
1366: }
1367:
1368:
1369: //--------------------------------------------------------------------------
1370: // BOOL bAbout(hwnd, pntpd)
1371: // HWND hwnd;
1372: // PNTPD pntpd;
1373: //
1374: // This routine invokes the common About dialog.
1375: //
1376: // Returns:
1377: // This routine returns TRUE for success, FALSE otherwise.
1378: //
1379: // History:
1380: // 22-Apr-1993 -by- Kent Settle (kentse)
1381: // Borrowed from Rasdd, and modified.
1382: //--------------------------------------------------------------------------
1383:
1384: BOOL bAbout(hwnd, pntpd)
1385: HWND hwnd;
1386: PNTPD pntpd;
1387: {
1388: HANDLE hCursor, hIcon;
1389: WCHAR wszTitle[RESOURCE_STRING_LENGTH];
1390: WCHAR wszModel[RESOURCE_STRING_LENGTH];
1391: WCHAR *pwstr;
1392:
1393: hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
1394:
1395: hIcon = LoadIcon(hModule, MAKEINTRESOURCE(ICO_PRINTER));
1396:
1397: pwstr = (PWSTR)((PSTR)pntpd + pntpd->lowszPrinterName);
1398:
1399: // fill in the device name string.
1400:
1401: LoadString(hModule, IDS_MODEL_STRING + STRING_BASE, wszModel,
1402: sizeof(wszModel) / sizeof(wszModel[0]));
1403:
1404: // fill in the model name itself.
1405:
1406: pwstr = wszModel + wcslen(wszModel);
1407:
1408: wcsncpy(pwstr, (LPWSTR)((PSTR)pntpd + pntpd->lowszPrinterName),
1409: RESOURCE_STRING_LENGTH - wcslen(wszModel));
1410:
1411: // get our name.
1412:
1413: LoadString(hModule, IDS_PSCRIPT_VERSION + STRING_BASE,
1414: wszTitle, sizeof(wszTitle) / sizeof(wszTitle[0]));
1415:
1416: // call off to the common about dialog.
1417:
1418: ShellAbout(hwnd, wszTitle, wszModel, hIcon);
1419:
1420: SetCursor(hCursor);
1421:
1422: return(TRUE);
1423: }
1424:
1425:
1426: //--------------------------------------------------------------------------
1427: // VOID GetPrinterForm(pntpd, pFormName, pPrinterForm);
1428: // PNTPD pntpd;
1429: // PWSTR pFormName;
1430: // PWSTR pPrinterForm;
1431: //
1432: // This routine invokes the common About dialog.
1433: //
1434: // Returns:
1435: // This routine returns TRUE for success, FALSE otherwise.
1436: //
1437: // History:
1438: // 22-Apr-1993 -by- Kent Settle (kentse)
1439: // Borrowed from Rasdd, and modified.
1440: //--------------------------------------------------------------------------
1441:
1442: VOID GetPrinterForm(pntpd, pForm, pPrinterForm)
1443: PNTPD pntpd;
1444: FORM_INFO_1 *pForm;
1445: PWSTR pPrinterForm;
1446: {
1447: PSFORM *pPSForm;
1448: DWORD i;
1449: BOOL bFound;
1450: SIZEL sizldelta, sizltmp;
1451: CHAR szForm[CCHFORMNAME];
1452:
1453: // find the printer's form metrics from the NTPD.
1454:
1455: pPSForm = (PSFORM *)((CHAR *)pntpd + pntpd->loPSFORMArray);
1456:
1457: // first try to match a form by name.
1458:
1459: // get ANSI version of form name.
1460:
1461: WideCharToMultiByte(CP_ACP, 0, (LPWSTR)pForm->pName,
1462: (INT)(wcslen(pForm->pName) + 1), szForm,
1463: sizeof(szForm), NULL, NULL);
1464:
1465: for (i = 0; i < pntpd->cPSForms; i++)
1466: {
1467: if (!(NameComp(szForm, (CHAR *)pntpd + pPSForm->loFormName)))
1468: {
1469: // in this case, the printer form name and the database form
1470: // name are the same.
1471:
1472: wcsncpy(pPrinterForm, pForm->pName, CCHFORMNAME);
1473: return;
1474: }
1475:
1476: // point to the next PSFORM.
1477:
1478: pPSForm++;
1479: }
1480:
1481: // if we did not find a name match, try to locate a form by size.
1482:
1483: // get pointer to first form in NTPD.
1484:
1485: pPSForm = (PSFORM *)((CHAR *)pntpd + pntpd->loPSFORMArray);
1486:
1487: // sizldelta is used to hold the difference between form sizes.
1488: // initialize to large value.
1489:
1490: sizldelta.cx = sizldelta.cy = INITIAL_FORM_DELTA;
1491:
1492: bFound = FALSE;
1493:
1494: for (i = 0; i < pntpd->cPSForms; i++)
1495: {
1496: sizltmp.cx = USERTO001MM(pPSForm->sizlPaper.cx) - pForm->Size.cx;
1497: sizltmp.cy = USERTO001MM(pPSForm->sizlPaper.cy) - pForm->Size.cy;
1498:
1499: // see if we have an exact match on size (within 1mm).
1500:
1501: if (((DWORD)abs(sizltmp.cx) <= 1000) &&
1502: ((DWORD)abs(sizltmp.cy) <= 1000))
1503: {
1504: // we have an exact match on size, so overwrite the form
1505: // name with the name the printer knows about.
1506:
1507: strcpy2WChar(pPrinterForm, (CHAR *)pntpd + pPSForm->loFormName);
1508: return;
1509: }
1510:
1511: // not an exact match, but see if we could fit on this form.
1512:
1513: if ((sizltmp.cx >= 0) && (sizltmp.cy >= 0))
1514: {
1515: // we can fit on this form. let's see if it is the smallest.
1516:
1517: if ((sizltmp.cx <= sizldelta.cx) &&
1518: (sizltmp.cy <= sizldelta.cy))
1519: {
1520: // this form is the smallest yet.
1521:
1522: sizldelta = sizltmp;
1523: strcpy2WChar(pPrinterForm, (CHAR *)pntpd + pPSForm->loFormName);
1524: bFound = TRUE;
1525: }
1526: }
1527:
1528: // point to the next PSFORM.
1529:
1530: pPSForm++;
1531: }
1532:
1533: // set to default if no form was found.
1534:
1535: strcpy2WChar(pPrinterForm, (CHAR *)pntpd + pntpd->loDefaultForm);
1536: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.