![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fontinst.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 fontinst.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscrptui |
1.1 root 1: //--------------------------------------------------------------------------
2: //
3: // Module Name: FONTINST.C
4: //
5: // Brief Description: This module contains the PostScript font installer
6: // for Windows NT, and supporting routines.
7: //
8: // Author: Kent Settle (kentse)
9: // Created: 09-Jan-1992
10: //
11: // Copyright (c) 1991-1992 Microsoft Corporation
12: //--------------------------------------------------------------------------
13:
14: #include <stddef.h>
15: #include <stdlib.h>
16: #include <string.h>
17: #include "pscript.h"
18: #include <winspool.h>
19: #include "dlgdefs.h"
20: #include "pscrptui.h"
21: #include "help.h"
22:
23: extern PVOID MapFile(PWSTR);
24: extern BOOL CreatePFMFromAFM(PWSTR, PWSTR);
25: extern LPWSTR GetDriverDirectory(HANDLE);
26:
27: // declarations of routines defined within this module.
28:
29: BOOL InsertInstalledFont(HWND, PWSTR);
30: BOOL InsertNewFont(HWND, PWSTR);
31: PSTR LocateKeyword(PSTR, PSTR);
32: BOOL ExtractFullName(PSTR, PSTR);
33: BOOL ExtractFontName(PSZ, PSZ);
34: BOOL PFBToPFA(PWSTR, PWSTR);
35: BOOL LocateFile(HWND, PWSTR, int, WIN32_FIND_DATA *, HANDLE *);
36:
37: // global Data
38:
39: WCHAR wstrFontInstDir[MAX_PATH];
40: DWORD cInstalledFonts, cNewFonts;
41:
42:
43: //--------------------------------------------------------------------------
44: // BOOL APIENTRY FontInstDlgProc (HWND hwnd, UINT message, DWORD wParam,
45: // LONG lParam)
46: //
47: // This function processes messages for the "About" dialog box.
48: //
49: // Returns:
50: // This function returns TRUE if successful, FALSE otherwise.
51: //
52: // History:
53: // 06-Dec-1991 -by- Kent Settle (kentse)
54: // Wrote it.
55: //--------------------------------------------------------------------------
56:
57: LONG APIENTRY FontInstDlgProc (HWND hwnd, UINT message, DWORD wParam,
58: LONG lParam)
59: {
60: WCHAR wcbuf[MAX_PATH], wcbuftmp[MAX_PATH];
61: WCHAR wstringbuf[512];
62: HANDLE hFile;
63: WIN32_FIND_DATA FileFindData;
64: PRINTDATA *pdata;
65: DWORD cwBuf, i;
66: PWSTR pwstrPath;
67: HCURSOR hCursor;
68: BOOL bFound;
69: DWORD cToAdd, cToDelete, cSave;
70: int *pEntries, *pSave;
71: int iSelect;
72: LONG index;
73: PWSTR pwstrPFAFile;
74: PWSTR pwstrPFBFile;
75: PWSTR pwstrAFMFile;
76: PWSTR pwstrPFMFile;
77: PWSTR pwstrSave;
78: BOOL bAllAFMs;
79: BYTE *pjbitarray;
80: LPWSTR pDriverDirectory;
81:
82:
83: UNREFERENCED_PARAMETER (lParam);
84:
85: switch (message)
86: {
87: case WM_INITDIALOG:
88: // fill in the default source for new softfonts.
89:
90: SendDlgItemMessage (hwnd, IDD_NEW_FONT_DIR_EDIT_BOX, EM_LIMITTEXT,
91: MAX_PATH, 0);
92: LoadString(hModule, (IDS_DEFAULT_FONT_DIR + STRING_BASE),
93: wstringbuf, (sizeof(wstringbuf) / 2));
94: SetDlgItemText(hwnd, IDD_NEW_FONT_DIR_EDIT_BOX, wstringbuf);
95:
96: // reset the content of the new soft fonts and the installed
97: // soft fonts list boxes.
98:
99: SendDlgItemMessage (hwnd, IDD_NEW_FONT_LIST_BOX, LB_RESETCONTENT,
100: 0, 0);
101: SendDlgItemMessage (hwnd, IDD_INSTALLED_LIST_BOX, LB_RESETCONTENT,
102: 0, 0);
103:
104: // call the spooler to get the fully qualified path to search
105: // for installed fonts.
106:
107: pdata = (PRINTDATA *)lParam;
108:
109: // save the PRINTDATA.
110:
111: SetWindowLong(hwnd, GWL_USERDATA, lParam);
112:
113: // copy the fully qualified path name of the data file into
114: // local buffer. extract the directory name, as this is the
115: // same directory font files will go into.
116:
117: if (!(pDriverDirectory = GetDriverDirectory(pdata->hPrinter)))
118: {
119: RIP("PSCRPTUI!FontInstDialogProc: GetDriverDirectory failed.\n");
120: return(FALSE);
121: }
122:
123: wcsncpy(wcbuf, pDriverDirectory, (sizeof(wcbuf) / sizeof(WCHAR)));
124:
125: LocalFree(pDriverDirectory);
126:
127: // add a backslash to the end of the subdirectory.
128:
129: pwstrPath = wcbuf;
130: pwstrPath += wcslen(wcbuf);
131:
132: *pwstrPath++ = '\\';
133: *pwstrPath = '\0';
134:
135: // save a copy of the data file subdirectory for later use.
136:
137: wcsncpy(wstrFontInstDir, wcbuf, (sizeof(wstrFontInstDir) /
138: sizeof(WCHAR)));
139:
140: // append *.PFM to qualified path.
141:
142: LoadString(hModule, (IDS_ALL_PFM_FILES + STRING_BASE),
143: wstringbuf, (sizeof(wstringbuf) / sizeof(WCHAR)));
144:
145: cwBuf = wcslen(wstrFontInstDir);
146:
147: wcsncat(wcbuf, wstringbuf, (sizeof(wcbuf) / sizeof(WCHAR)) - cwBuf);
148:
149: // see if there are any installed fonts.
150:
151: cInstalledFonts = 0;
152: cNewFonts = 0;
153:
154: hFile = FindFirstFile(wcbuf, &FileFindData);
155:
156: if (hFile != (HANDLE)-1)
157: {
158: // we have at least one installed font. search for all the
159: // font files, inserting them into the list box.
160: // this could take a while, so set the cursor to the hourglass.
161:
162: hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
163:
164: // we could be putting several entries into the list box,
165: // and it would look bad to redraw after each one, so turn
166: // off redrawing until we are done.
167:
168: SendMessage(hwnd, WM_SETREDRAW, FALSE, 0L);
169:
170: // insert each font name found into the installed fonts
171: // list box.
172:
173: bFound = TRUE;
174:
175: while(bFound)
176: {
177: // create the fully qualified path name of the .PFA file to open.
178:
179: wcsncpy(wcbuf, wstrFontInstDir, (sizeof(wcbuf) / 2));
180: wcsncat(wcbuf, (PWSTR)FileFindData.cFileName,
181: (sizeof(wcbuf) / 2) - cwBuf);
182:
183: // put exception handling around this in case the network
184: // goes down in the middle of this.
185:
186: try
187: {
188: InsertInstalledFont(hwnd, wcbuf);
189: }
190: except (EXCEPTION_EXECUTE_HANDLER)
191: {
192: LoadString(hModule,
193: (IDS_NETWORK_GONE + STRING_BASE),
194: wstringbuf, (sizeof(wstringbuf) / 2));
195:
196: MessageBox(hwnd, wstringbuf, NULL, MB_ICONSTOP | MB_OK);
197:
198: return (FALSE);
199: }
200:
201: cInstalledFonts++;
202:
203: bFound = FindNextFile(hFile, &FileFindData);
204: }
205:
206: // now that we are done, turn on redrawing.
207:
208: SendMessage (hwnd, WM_SETREDRAW, TRUE, 0L);
209: InvalidateRect (hwnd, NULL, TRUE);
210:
211: // reset the cursor shape to what is was.
212:
213: SetCursor(hCursor);
214: }
215:
216: if ((hFile == (HANDLE)-1) || (cInstalledFonts == 0))
217: {
218: // there are no installed soft fonts.
219:
220: LoadString(hModule, (IDS_NO_INSTALLED + STRING_BASE),
221: wstringbuf, (sizeof(wstringbuf) / 2));
222:
223: SendDlgItemMessage (hwnd, IDD_INSTALLED_LIST_BOX, LB_ADDSTRING,
224: 0, (LONG)wstringbuf);
225: }
226:
227: // disable the delete pushbutton.
228:
229: EnableWindow(GetDlgItem(hwnd, IDD_DELETE_BUTTON), FALSE);
230:
231: // free up file finding resources.
232:
233: FindClose(hFile);
234:
235: // disable the add pushbutton until someone actually has
236: // opened some font files.
237:
238: EnableWindow(GetDlgItem(hwnd, IDD_ADD_BUTTON), FALSE);
239:
240: // intialize the help stuff.
241:
242: vHelpInit();
243:
244: // disable some stuff if the user does not have
245: // permission to change anything.
246:
247: if (!pdata->bPermission)
248: {
249: EnableWindow(GetDlgItem(hwnd, IDD_OPEN_BUTTON), FALSE);
250: EnableWindow(GetDlgItem(hwnd, IDD_NEW_FONT_LIST_BOX), FALSE);
251: EnableWindow(GetDlgItem(hwnd, IDD_NEW_FONT_DIR_EDIT_BOX), FALSE);
252: }
253:
254: return (TRUE);
255:
256: case WM_COMMAND:
257: pdata = (PRINTDATA *)GetWindowLong(hwnd, GWL_USERDATA);
258:
259: switch (LOWORD(wParam))
260: {
261: case IDD_OPEN_BUTTON:
262: // this could take a while, so set the cursor to the hourglass.
263:
264: hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
265:
266: // get the supposed path to the new soft fonts provided
267: // by the user.
268:
269: cwBuf = GetDlgItemText(hwnd, IDD_NEW_FONT_DIR_EDIT_BOX,
270: wcbuf, (sizeof(wcbuf) / 2));
271:
272: // check to see if it has trailing backslash, and add
273: // it if not.
274:
275: pwstrPath = wcbuf + cwBuf - 1;
276:
277: if (*pwstrPath != '\\')
278: {
279: pwstrPath++;
280: *pwstrPath = '\\';
281: cwBuf++;
282: }
283:
284: pwstrPath++;
285: *pwstrPath = '\0';
286:
287: // save a copy of the path to the source for later use.
288:
289: wcsncpy(wcbuftmp, wcbuf, (sizeof(wcbuftmp) / 2));
290:
291: // now that we have the source directory, concat "*.PFB"
292: // to it.
293:
294: LoadString(hModule, (IDS_ALL_PFB_FILES + STRING_BASE),
295: wstringbuf, (sizeof(wstringbuf) / 2));
296:
297: wcsncat(wcbuf, wstringbuf, (sizeof(wcbuf) / 2) - cwBuf);
298:
299: // find the .PFB files.
300:
301: if (!LocateFile(hwnd, wcbuf, IDS_PFB_NOT_FOUND,
302: &FileFindData, &hFile))
303: {
304: SetCursor(hCursor);
305: return(FALSE);
306: }
307:
308: // we could be putting several entries into the list box,
309: // and it would look bad to redraw after each one, so turn
310: // off redrawing until we are done.
311:
312: SendMessage(hwnd, WM_SETREDRAW, FALSE, 0L);
313:
314: bFound = TRUE;
315:
316: cwBuf = wcslen(wcbuftmp);
317:
318: while(bFound)
319: {
320: // create the fully qualified path name of the .PFB file to open.
321:
322: wcsncpy(wcbuf, wcbuftmp, (sizeof(wcbuf) / 2));
323: wcsncat(wcbuf, (PWSTR)FileFindData.cFileName,
324: (sizeof(wcbuf) / 2) - cwBuf);
325:
326: InsertNewFont(hwnd, wcbuf);
327: cNewFonts++;
328:
329: bFound = FindNextFile(hFile, &FileFindData);
330: }
331:
332: // free up file finding resources.
333:
334: FindClose(hFile);
335:
336: // reset the cursor shape to what it was.
337:
338: SetCursor(hCursor);
339:
340: // now that we are done, turn on redrawing.
341:
342: SendMessage (hwnd, WM_SETREDRAW, TRUE, 0L);
343: InvalidateRect (hwnd, NULL, TRUE);
344:
345: return(TRUE);
346:
347: case IDD_ADD_BUTTON:
348: // first see how many entries have been selected in
349: // the new fonts list box.
350:
351: cToAdd = SendDlgItemMessage(hwnd, IDD_NEW_FONT_LIST_BOX,
352: LB_GETSELCOUNT, 0, 0);
353:
354: // nothing to do if no entries selected.
355:
356: if (cToAdd == 0)
357: return(TRUE); //!!! maybe a message box? - kentse.
358:
359: // first find the .PFB files.
360:
361: // get the supposed path to the new soft fonts provided
362: // by the user.
363:
364: cwBuf = GetDlgItemText(hwnd, IDD_NEW_FONT_DIR_EDIT_BOX,
365: wcbuf, (sizeof(wcbuf) / 2));
366:
367: // check to see if it has trailing backslash, and add
368: // it if not.
369:
370: pwstrPath = wcbuf + cwBuf - 1;
371:
372: if (*pwstrPath != '\\')
373: {
374: pwstrPath++;
375: *pwstrPath = '\\';
376: cwBuf++;
377: }
378:
379: pwstrPath++;
380: *pwstrPath = '\0';
381:
382: // save a copy of the path to the source for later use.
383:
384: wcsncpy(wcbuftmp, wcbuf, (sizeof(wcbuftmp) / 2));
385:
386: // now that we have the source directory, concat "*.AFM"
387: // to it.
388:
389: LoadString(hModule, (IDS_ALL_PFB_FILES + STRING_BASE),
390: wstringbuf, (sizeof(wstringbuf) / 2));
391:
392: wcsncat(wcbuf, wstringbuf, (sizeof(wcbuf) / 2) - cwBuf);
393:
394: if (!LocateFile(hwnd, wcbuf, IDS_PFB_NOT_FOUND,
395: &FileFindData, &hFile))
396: return(FALSE);
397:
398: // this could take a while, so set the cursor to the hourglass.
399:
400: hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
401:
402: // save the count of new fonts to add.
403:
404: cSave = cToAdd;
405:
406: // get the list of selected entries.
407:
408: if (!(pEntries = (int *)LocalAlloc(LPTR, cToAdd * sizeof(int))))
409: {
410: RIP("FontInstDlgProc: LocalAlloc for pEntries failed.\n");
411: return(FALSE);
412: }
413:
414: pSave = pEntries;
415:
416: SendDlgItemMessage(hwnd, IDD_NEW_FONT_LIST_BOX,
417: LB_GETSELITEMS, cToAdd, (DWORD)pEntries);
418:
419: // create a new .PFA file from each .PFB file.
420:
421: while(cToAdd--)
422: {
423: // get the index of the new font to add.
424:
425: index = *pEntries;
426:
427: // when each entry was added to the new fonts list
428: // box, memory was allocated to store a pointer
429: // to the corresponding .PFB filename.
430:
431: pwstrPFBFile = (PWSTR)SendDlgItemMessage(hwnd,
432: IDD_NEW_FONT_LIST_BOX,
433: LB_GETITEMDATA,
434: index, 0);
435:
436: if (pwstrPFBFile == (PWSTR)LB_ERR)
437: {
438: RIP("FontInstDlgProc: LB_GETITEMDATA failed.");
439: LocalFree((LOCALHANDLE)pSave);
440: return(FALSE);
441: }
442:
443: // build the fully qualified pathname for the .PFA
444: // file to create.
445:
446: ASSERTPS((wcslen(wstrFontInstDir) < MAX_PATH),
447: "PSCRPTUI: wstrFontInstDir about to overrun buffer.\n");
448: wcsncpy(wcbuf, wstrFontInstDir, (sizeof(wcbuf) / 2));
449:
450: // save a pointer to the fully qualified pathname of
451: // the .PFB file.
452:
453: pwstrSave = pwstrPFBFile;
454:
455: // extract the filename itself. first, find the end
456: // of the string, then backup until we find the
457: // first '\' character.
458:
459: while (*pwstrPFBFile)
460: pwstrPFBFile++;
461:
462: while (*pwstrPFBFile != (WCHAR)'\\')
463: pwstrPFBFile--;
464:
465: pwstrPFBFile++;
466:
467: // pwstrPFBFile now points to the filename itself, so
468: // concat it with the directory.
469:
470: cwBuf = wcslen(wcbuf);
471:
472: wcsncat(wcbuf, pwstrPFBFile, (sizeof(wcbuf) / 2) - cwBuf);
473: pwstrPFBFile = pwstrSave;
474:
475: // now change the .PFB to .PFA.
476:
477: pwstrPFAFile = wcbuf;
478:
479: while (*pwstrPFAFile)
480: pwstrPFAFile++;
481:
482: // back up to the 'B', and overwrite it with 'A'.
483:
484: pwstrPFAFile--;
485: *pwstrPFAFile = (WCHAR)'A';
486:
487: // reset pointer back to start of fully qualified
488: // pathname.
489:
490: pwstrPFAFile = wcbuf;
491:
492: // create a .PFA file from the .PFB file.
493:
494: // put exception handling around this in case the
495: // networks goes down in the middle of this.
496:
497: try
498: {
499: if (!PFBToPFA(pwstrPFAFile, pwstrPFBFile))
500: return(FALSE);
501: }
502: except (EXCEPTION_EXECUTE_HANDLER)
503: {
504: LoadString(hModule,
505: (IDS_NETWORK_GONE + STRING_BASE),
506: wstringbuf, (sizeof(wstringbuf) / 2));
507:
508: MessageBox(hwnd, wstringbuf, NULL, MB_ICONSTOP | MB_OK);
509: return (FALSE);
510: }
511:
512: // get ready for next selected entry.
513:
514: pEntries++;
515: }
516:
517: // now that we have created the .PFA files from the .PFB
518: // files, it is time to create the .PFM file from the
519: // .AFM and .PFA files.
520:
521: // first find the .AFM files.
522:
523: // get the supposed path to the new soft fonts provided
524: // by the user.
525:
526: cwBuf = GetDlgItemText(hwnd, IDD_NEW_FONT_DIR_EDIT_BOX,
527: wcbuf, (sizeof(wcbuf) / 2));
528:
529: // check to see if it has trailing backslash, and add
530: // it if not.
531:
532: pwstrPath = wcbuf + cwBuf - 1;
533:
534: if (*pwstrPath != (WCHAR)'\\')
535: {
536: pwstrPath++;
537: *pwstrPath = (WCHAR)'\\';
538: cwBuf++;
539: }
540:
541: pwstrPath++;
542: *pwstrPath = (WCHAR)'\0';
543:
544: // save a copy of the path to the source for later use.
545:
546: wcsncpy(wcbuftmp, wcbuf, (sizeof(wcbuftmp) / 2));
547:
548: // now that we have the source directory, concat "*.AFM"
549: // to it.
550:
551: LoadString(hModule, (IDS_ALL_AFM_FILES + STRING_BASE),
552: wstringbuf, (sizeof(wstringbuf) / 2));
553:
554: wcsncat(wcbuf, wstringbuf, (sizeof(wcbuf) / 2) - cwBuf);
555:
556: if (!LocateFile(hwnd, wcbuf, IDS_AFM_NOT_FOUND,
557: &FileFindData, &hFile))
558: {
559: SetCursor(hCursor);
560: return(FALSE);
561: }
562:
563: // reset values to deal with .AFM files.
564:
565: cToAdd = cSave;
566: pEntries = pSave;
567:
568: // indicate we have not found all the .AFM files.
569:
570: bAllAFMs = FALSE;
571:
572: // allocate a bit array to keep track of which
573: // .AFM files have been found.
574:
575: pjbitarray = (BYTE *)LocalAlloc(LPTR, (cToAdd + 7) / 8);
576:
577: if (!pjbitarray)
578: {
579: RIP("PSCRPTUI!IDD_ADD_BUTTON: LocalAlloc for pjbitarray failed.\n");
580: SetCursor(hCursor);
581: return(FALSE);
582: }
583:
584: // initialize all bits to zero.
585:
586: memset((PVOID)pjbitarray, 0, (cToAdd + 7) / 8);
587:
588: // create a new .PFM file from each .AFM file and delete
589: // it's entry from the new fonts list box.
590:
591: while(!bAllAFMs)
592: {
593: // reset pointer.
594:
595: pEntries = pSave;
596:
597: for (i = 0; i < cToAdd; i++)
598: {
599: // check the bit in the bit array to see if
600: // this font is already installed.
601:
602: if ((BYTE)pjbitarray[i >> 3] & (BYTE)(1 << (i & 0x07)))
603: {
604: pEntries++;
605: continue;
606: }
607:
608: // get the index of the new font to add.
609:
610: index = *pEntries;
611:
612: // get the name of the new font to add.
613:
614: cwBuf = SendDlgItemMessage(hwnd, IDD_NEW_FONT_LIST_BOX,
615: LB_GETTEXT, index,
616: (DWORD)wcbuftmp);
617:
618: if (cwBuf == LB_ERR)
619: {
620: RIP("FontInstDlgProc: LB_GETTEXT failed.");
621: LocalFree((LOCALHANDLE)pSave);
622: return(FALSE);
623: }
624:
625: // when each entry was added to the new fonts list
626: // box, memory was allocated to store a pointer
627: // to the corresponding .PFB filename. get that
628: // pointer and create a pointer to .AFM filename.
629:
630: pwstrAFMFile = (PWSTR)SendDlgItemMessage(hwnd,
631: IDD_NEW_FONT_LIST_BOX,
632: LB_GETITEMDATA,
633: index, 0);
634:
635: if (pwstrAFMFile == (PWSTR)LB_ERR)
636: {
637: RIP("FontInstDlgProc: LB_GETITEMDATA failed.");
638: LocalFree((LOCALHANDLE)pSave);
639: return(FALSE);
640: }
641:
642: // save pointer to string.
643:
644: pwstrSave = pwstrAFMFile;
645:
646: // pwstrAFMFile is actually pointing to the .PFB
647: // filename. so overwrite the .PFB with .AFM.
648:
649: while (*pwstrAFMFile)
650: pwstrAFMFile++;
651:
652: // backup and overwrite PFB with AFM.
653:
654: pwstrAFMFile -= 3;
655: *pwstrAFMFile++ = (WCHAR)'A';
656: *pwstrAFMFile++ = (WCHAR)'F';
657: *pwstrAFMFile = (WCHAR)'M';
658:
659: // reset pointer to beginning of string.
660:
661: pwstrAFMFile = pwstrSave;
662:
663: // build the fully qualified pathname for the .PFM
664: // file to create.
665:
666: ASSERTPS((wcslen(wstrFontInstDir) < MAX_PATH),
667: "PSCRPTUI: wstrFontInstDir about to overrun buffer.\n");
668: wcsncpy(wcbuf, wstrFontInstDir, (sizeof(wcbuf) / 2));
669:
670: // save a pointer to the fully qualified pathname of
671: // the .AFM file.
672:
673: pwstrSave = pwstrAFMFile;
674:
675: // extract the filename itself. first, find the end
676: // of the string, then backup until we find the
677: // first '\' character.
678:
679: while (*pwstrAFMFile)
680: pwstrAFMFile++;
681:
682: while (*pwstrAFMFile != '\\')
683: pwstrAFMFile--;
684:
685: pwstrAFMFile++;
686:
687: // pwstrAFMFile now points to the filename itself, so
688: // concat it with the directory.
689:
690: cwBuf = wcslen(wcbuf);
691:
692: wcsncat(wcbuf, pwstrAFMFile, (sizeof(wcbuf) / 2) - cwBuf);
693: pwstrAFMFile = pwstrSave;
694:
695: // now change the .AFM to .PFM.
696:
697: pwstrPFMFile = wcbuf;
698:
699: while (*pwstrPFMFile)
700: pwstrPFMFile++;
701:
702: // back up to the 'A', and overwrite it with 'P'.
703:
704: pwstrPFMFile -= 3;
705: *pwstrPFMFile = (WCHAR)'P';
706:
707: // reset pointer back to start of fully qualified
708: // pathname.
709:
710: pwstrPFMFile = wcbuf;
711:
712: // create a .PFM file from the .AFM file. if
713: // this fails, it is most like due to the fact
714: // that this .AFM file is on another disk. so,
715: // just go to the next one for now.
716:
717: if (!CreatePFMFromAFM(pwstrAFMFile, pwstrPFMFile))
718: {
719: pEntries++;
720: continue;
721: }
722:
723: // we have now created both the and .PFM file
724: // for this font. we now know that there is at least
725: // one font installed, so check to see if this is
726: // this first one. if so, delete the no installed
727: // fonts entry from the list box.
728:
729: if (cInstalledFonts == 0)
730: SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX,
731: LB_RESETCONTENT, 0, 0);
732:
733: // associate the pointer to the .PFA file name with it.
734: // remember, we allocated memory for pwstrPFBFile when this
735: // font file was opened. free that memory now.
736:
737: LocalFree((LOCALHANDLE)pwstrAFMFile);
738:
739: // allocate memory to store away the .PFM filename.
740:
741: if (!(pwstrPFMFile = (PWSTR)LocalAlloc(LPTR, wcslen(wcbuf) + 1)))
742: {
743: RIP("PSCRPTUI!IDD_ADD_BUTTON: LocalAlloc failed.\n");
744: return(FALSE);
745: }
746:
747: // add the font name to the installed fonts dialog box.
748:
749: index = SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX,
750: LB_ADDSTRING, 0, (DWORD)wcbuftmp);
751:
752: // buf currently contains the fully qualified pathname
753: // of the PFM file.
754:
755: SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX,
756: LB_SETITEMDATA, index,
757: (DWORD)pwstrPFMFile);
758:
759: // adjust the counters.
760:
761: cNewFonts--;
762: cInstalledFonts++;
763:
764: // set the bit in the bit array for this
765: // installed font.
766:
767: (BYTE)pjbitarray[i >> 3] |= (BYTE)(1 << (i & 0x07));
768:
769: // get ready for next selected entry.
770:
771: pEntries++;
772: }
773:
774: // see if we have found all the .AFM files.
775:
776: bAllAFMs = TRUE;
777:
778: for (i = 0; i < cToAdd; i++)
779: {
780: if (!((BYTE)pjbitarray[i >> 3] & (BYTE)(1 << (i & 0x07))))
781: {
782: bAllAFMs = FALSE;
783: break;
784: }
785: }
786:
787: // pop up a message box if we have not yet found
788: // all the .AFM files.
789:
790: if (!bAllAFMs)
791: {
792: LoadString(hModule,
793: (IDS_MORE_AFMS_NEEDED + STRING_BASE),
794: wstringbuf, (sizeof(wstringbuf) / 2));
795:
796: iSelect = MessageBox(hwnd, wstringbuf, NULL,
797: MB_ICONSTOP | MB_OKCANCEL);
798:
799: if (iSelect == IDCANCEL)
800: bAllAFMs = TRUE;
801: }
802: }
803:
804: // go backwards through the list, removing each
805: // item from the new fonts list box.
806:
807: pEntries--;
808:
809: while (cSave--)
810: {
811: // get the index of the new font to delete.
812:
813: index = *pEntries;
814:
815: // delete the entry from the new font list box.
816:
817: SendDlgItemMessage(hwnd, IDD_NEW_FONT_LIST_BOX,
818: LB_DELETESTRING, index, 0);
819:
820: pEntries--;
821: }
822:
823: // we just added all the selected fonts, therefore,
824: // there are no fonts selected to add.
825:
826: EnableWindow(GetDlgItem(hwnd, IDD_ADD_BUTTON), FALSE);
827:
828: // reset the cursor shape to what it was.
829:
830: SetCursor(hCursor);
831:
832: // now that we are done, turn on redrawing.
833:
834: SendMessage (hwnd, WM_SETREDRAW, TRUE, 0L);
835: InvalidateRect (hwnd, NULL, TRUE);
836:
837: // free up memory.
838:
839: LocalFree((LOCALHANDLE)pSave);
840: LocalFree((LOCALHANDLE)pjbitarray);
841:
842: return(TRUE);
843:
844: case IDD_DELETE_BUTTON:
845: // first see how many entries have been selected in
846: // the installed fonts list box.
847:
848: cToDelete = SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX,
849: LB_GETSELCOUNT, 0, 0);
850:
851: // nothing to do if no entries selected.
852:
853: if (cToDelete == 0)
854: return(TRUE); //!!! maybe a message box? - kentse.
855:
856: // this could take a while, so set the cursor to the hourglass.
857:
858: hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
859:
860: // save the count.
861:
862: cSave = cToDelete;
863:
864: // get the list of selected entries.
865:
866: if (!(pEntries = (int *)LocalAlloc(LPTR, cToDelete * sizeof(int))))
867: {
868: RIP("PSCRPTUI!IDD_DELETE_BUTTON: LocalAlloc for pEntries failed.\n");
869: return(FALSE);
870: }
871:
872: pSave = pEntries;
873:
874: iSelect = SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX,
875: LB_GETSELITEMS, cToDelete,
876: (DWORD)pEntries);
877:
878: if ((iSelect != (int)cToDelete) || (iSelect == LB_ERR))
879: {
880: RIP("PSCRPTUI!IDD_DELETE_BUTTON: LB_GETSELITEMS failed.\n");
881: LocalFree((LOCALHANDLE)pEntries);
882: return(FALSE);
883: }
884:
885: while (cToDelete--)
886: {
887: // get the index of the new font to add.
888:
889: index = *pEntries;
890:
891: // when each entry was added to the installed list
892: // box, memory was allocated to store a pointer
893: // to the corresponding .PFM filename.
894:
895: pwstrPFMFile = (PWSTR)SendDlgItemMessage(hwnd,
896: IDD_INSTALLED_LIST_BOX,
897: LB_GETITEMDATA,
898: index, 0);
899:
900: if (pwstrPFMFile == (PWSTR)LB_ERR)
901: {
902: RIP("PSCRPTUI!IDD_DELETE_BUTTON: LB_GETITEMDATA failed.\n");
903: LocalFree((LOCALHANDLE)pSave);
904: return(FALSE);
905: }
906:
907: // delete the file associated with the font.
908:
909: DeleteFile(pwstrPFMFile);
910:
911: // free up memory allocated when this entry was
912: // added to the installed fonts list box.
913:
914: LocalFree((LOCALHANDLE)pwstrPFMFile);
915:
916: // update the count of installed fonts.
917:
918: cInstalledFonts--;
919:
920: // get ready for next selected entry.
921:
922: pEntries++;
923: }
924:
925: // go backwards through the list, removing each
926: // item from the new fonts list box.
927:
928: pEntries--;
929:
930: while (cSave--)
931: {
932: // get the index of the new font to delete.
933:
934: index = *pEntries;
935:
936: // delete the entry from the new font list box.
937:
938: SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX,
939: LB_DELETESTRING, index, 0);
940:
941: pEntries--;
942: }
943:
944: // we just deleted all the selected fonts, therefore,
945: // there are no fonts selected to delete.
946:
947: EnableWindow(GetDlgItem(hwnd, IDD_DELETE_BUTTON), FALSE);
948:
949: // free up memory.
950:
951: LocalFree((LOCALHANDLE)pSave);
952:
953: // reset the cursor shape to what it was.
954:
955: SetCursor(hCursor);
956:
957: break;
958:
959: case IDD_NEW_FONT_LIST_BOX:
960: if (HIWORD (wParam) != LBN_SELCHANGE)
961: return (FALSE);
962:
963: // if any of the items in the list box have been selected,
964: // enable the ADD button. if non of the items are
965: // selected, disable the ADD button.
966:
967: iSelect = SendDlgItemMessage(hwnd, IDD_NEW_FONT_LIST_BOX,
968: LB_GETSELCOUNT, 0, 0);
969:
970: if (iSelect == LB_ERR)
971: return(FALSE);
972:
973: if (iSelect > 0)
974: EnableWindow(GetDlgItem(hwnd, IDD_ADD_BUTTON), TRUE);
975: else
976: EnableWindow(GetDlgItem(hwnd, IDD_ADD_BUTTON), FALSE);
977:
978: break;
979:
980: case IDD_INSTALLED_LIST_BOX:
981: if (HIWORD (wParam) != LBN_SELCHANGE)
982: return (FALSE);
983:
984: // if any of the items in the list box have been selected,
985: // enable the DELETE button. if non of the items are
986: // selected, disable the DELETE button.
987:
988: iSelect = SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX,
989: LB_GETSELCOUNT, 0, 0);
990:
991: if (iSelect == LB_ERR)
992: return(FALSE);
993:
994:
995: if ((iSelect > 0) && (cInstalledFonts > 0) && pdata->bPermission)
996: EnableWindow(GetDlgItem(hwnd, IDD_DELETE_BUTTON), TRUE);
997: else
998: EnableWindow(GetDlgItem(hwnd, IDD_DELETE_BUTTON), FALSE);
999:
1000: break;
1001:
1002: case IDD_HELP_BUTTON:
1003: vShowHelp(hwnd, HELP_CONTEXT, HLP_SFONT_INSTALLER,
1004: pdata->hPrinter);
1005: return(TRUE);
1006:
1007: case IDOK:
1008: if (pdata->bPermission)
1009: {
1010: // see how many entries are left in the new fonts
1011: // list box. delete the memory allocated for each
1012: // entry.
1013:
1014: cToDelete = SendDlgItemMessage(hwnd, IDD_NEW_FONT_LIST_BOX,
1015: LB_GETCOUNT, 0, 0);
1016:
1017: for (i = 0; i < cToDelete; i++)
1018: {
1019: pwstrPFBFile = (PWSTR)SendDlgItemMessage(hwnd,
1020: IDD_NEW_FONT_LIST_BOX,
1021: LB_GETITEMDATA, i, 0);
1022:
1023: if (pwstrPFBFile == (PWSTR)LB_ERR)
1024: {
1025: RIP("PSCRPTUI!IDOK: LB_GETITEMDATA failed.");
1026: return(FALSE);
1027: }
1028:
1029: LocalFree((LOCALHANDLE)pwstrPFBFile);
1030: }
1031: }
1032:
1033: // do the same for the installed fonts list box. in this
1034: // case, the memory will have been allocated whether
1035: // the user has change permission or not.
1036:
1037: cToDelete = SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX,
1038: LB_GETCOUNT, 0, 0);
1039:
1040: for (i = 0; i < cToDelete; i++)
1041: {
1042: pwstrPFMFile = (PWSTR)SendDlgItemMessage(hwnd,
1043: IDD_INSTALLED_LIST_BOX,
1044: LB_GETITEMDATA, i, 0);
1045:
1046: if (pwstrPFMFile == (PWSTR)LB_ERR)
1047: {
1048: RIP("PSCRPTUI!IDOK: LB_GETITEMDATA failed.");
1049: return(FALSE);
1050: }
1051:
1052: LocalFree((LOCALHANDLE)pwstrPFMFile);
1053: }
1054:
1055: // let the world know we may have changed the fonts.
1056:
1057: if (pdata->bPermission)
1058: {
1059: SendMessage((HWND)-1, WM_FONTCHANGE, 0, 0);
1060: }
1061:
1062: // end the dialog.
1063:
1064: EndDialog (hwnd, TRUE);
1065: return(TRUE);
1066:
1067: case IDCANCEL:
1068: EndDialog (hwnd, IDCANCEL);
1069: return(TRUE);
1070:
1071: default:
1072: return(FALSE);
1073: }
1074: break;
1075:
1076: case WM_DESTROY:
1077: // clean up any used help stuff.
1078:
1079: vHelpDone(hwnd);
1080: return (TRUE);
1081:
1082: default:
1083: return (FALSE);
1084: }
1085: return (FALSE);
1086: }
1087:
1088:
1089: //--------------------------------------------------------------------------
1090: // BOOL InsertInstalledFont(hwnd, pwstrPFMFile)
1091: // HWND hwnd;
1092: // PWSTR pwstrPFMFile;
1093: //
1094: // This function takes a pointer to the filename for a given soft font,
1095: // extracts the font name from the file, and insert that into the
1096: // Installed Fonts list box.
1097: //
1098: // Returns:
1099: // This function returns no value.
1100: //
1101: // History:
1102: // 16-Dec-1991 -by- Kent Settle (kentse)
1103: // Wrote it.
1104: //--------------------------------------------------------------------------
1105:
1106: BOOL InsertInstalledFont(hwnd, pwstrPFMFile)
1107: HWND hwnd;
1108: PWSTR pwstrPFMFile;
1109: {
1110: CHAR cbuf[128];
1111: WCHAR wcbuf[128];
1112: CHAR *pBuffer;
1113: CHAR *pSoftFont;
1114: PWSTR pwstrFileName;
1115: DWORD index;
1116: PNTFM pntfm;
1117:
1118: // open the given .PFM file.
1119:
1120: if (!(pntfm = (PNTFM)MapFile(pwstrPFMFile)))
1121: {
1122: RIP("PSCRPTUI!InsertInstalledFont: MapFile failed.\n");
1123: return(FALSE);
1124: }
1125:
1126: // when we created the .PFA file, we stuck the following font information
1127: // at the beginning of each .PFA file: "%Full Name%Font Name%".
1128: // we want to extract the Full Name and insert that into the list
1129: // box.
1130:
1131: pSoftFont = (CHAR *)pntfm + pntfm->loSoftFont;
1132:
1133: // do nothing if this .PFM file does not contain a softfont.
1134:
1135: if (!pSoftFont)
1136: {
1137: UnmapViewOfFile((PVOID)pntfm);
1138: return(TRUE);
1139: }
1140:
1141: // skip over the first '%'.
1142:
1143: pSoftFont++;
1144:
1145: // copy the font name into a local buffer.
1146:
1147: pBuffer = cbuf;
1148:
1149: while (*pSoftFont != '%')
1150: *pBuffer++ = *pSoftFont++;
1151:
1152: // don't forget the NULL terminator.
1153:
1154: *pBuffer = '\0';
1155:
1156: // reset pointer to start of Full Name of font.
1157:
1158: pBuffer = cbuf;
1159:
1160: // insert font name into Installed Fonts list box.
1161:
1162: strcpy2WChar(wcbuf, pBuffer);
1163: index = SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX, LB_ADDSTRING, 0,
1164: (DWORD)wcbuf);
1165:
1166: if ((index == LB_ERR) || (index == LB_ERRSPACE))
1167: {
1168: RIP("InsertInstalledFont: LB_ADDSTRING failed.\n");
1169: UnmapViewOfFile((PVOID)pntfm);
1170: return(FALSE);
1171: }
1172:
1173: // associate a pointer to the file name with each entry in the listbox.
1174: // create local copy of file name, since the copy pwstrPFMFile will probably
1175: // no longer exist when we need to access it.
1176:
1177: if (!(pwstrFileName = (PWSTR)LocalAlloc(LPTR, (wcslen(pwstrPFMFile) + 1) * 2)))
1178: {
1179: RIP("InsertInstalledFont: LocalAlloc for pwstrFileName failed.\n");
1180: UnmapViewOfFile((PVOID)pntfm);
1181: return(FALSE);
1182: }
1183:
1184: wcsncpy(pwstrFileName, pwstrPFMFile, wcslen(pwstrPFMFile) + 1);
1185:
1186: SendDlgItemMessage(hwnd, IDD_INSTALLED_LIST_BOX, LB_SETITEMDATA, index,
1187: (DWORD)pwstrFileName);
1188:
1189: // unmap the .PFM file.
1190:
1191: UnmapViewOfFile((PVOID)pntfm);
1192:
1193: return(TRUE);
1194: }
1195:
1196:
1197: //--------------------------------------------------------------------------
1198: // BOOL InsertNewFont(hwnd, pwstrPFBFile)
1199: // HWND hwnd;
1200: // PWSTR pwstrPFBFile;
1201: //
1202: // This function takes a pointer to the filename for a given soft font,
1203: // extracts the font name from the file, and insert that into the
1204: // New Fonts list box.
1205: //
1206: // Returns:
1207: // This function returns no value.
1208: //
1209: // History:
1210: // 23-Dec-1991 -by- Kent Settle (kentse)
1211: // Wrote it.
1212: //--------------------------------------------------------------------------
1213:
1214: BOOL InsertNewFont(hwnd, pwstrPFBFile)
1215: HWND hwnd;
1216: PWSTR pwstrPFBFile;
1217: {
1218: CHAR *pBuffer;
1219: CHAR strFullName[MAX_FULLNAME];
1220: WCHAR wstrFullName[MAX_FULLNAME];
1221: PFBHEADER pfbheader;
1222: HANDLE hFile;
1223: DWORD cBytesRead, cb;
1224: BOOL bRet;
1225: DWORD dwRet;
1226: PWSTR pwstrFileName;
1227: DWORD index;
1228:
1229: // open the given .PFB file.
1230:
1231: hFile = CreateFile(pwstrPFBFile, GENERIC_READ, FILE_SHARE_READ,
1232: 0, OPEN_EXISTING, 0, 0 );
1233: if (hFile == (HANDLE)-1)
1234: {
1235: RIP("InsertNewFont: CreateFile failed.\n");
1236: return(FALSE);
1237: }
1238:
1239: // read in the PFBHEADER.
1240:
1241: if(!(bRet = ReadFile(hFile, &pfbheader, sizeof(PFBHEADER), &cBytesRead,
1242: NULL) || cBytesRead != sizeof(PFBHEADER)))
1243: {
1244: RIP("InsertNewFont: ReadFile Failed.\n");
1245: CloseHandle(hFile);
1246: return(FALSE);
1247: }
1248:
1249: // make sure we have the header.
1250:
1251: if ((pfbheader.jCheck != CHECK_BYTE) || (pfbheader.jType == EOF_TYPE))
1252: {
1253: RIP("InsertNewFont: PFB Header not found.\n");
1254: SetLastError(ERROR_INVALID_DATA);
1255: CloseHandle(hFile);
1256: return(FALSE);
1257: }
1258:
1259: // find the size of the .PFB file. allocate memory to copy into,
1260: // leaving room for terminating NULL.
1261:
1262: cb = ((DWORD)pfbheader.ushilength << 16) + pfbheader.uslolength;
1263:
1264: if (!(pBuffer = (CHAR *)LocalAlloc(LPTR, cb + 1)))
1265: {
1266: RIP("InsertNewFont: LocalAlloc failed.\n");
1267: CloseHandle(hFile);
1268: return(FALSE);
1269: }
1270:
1271: // reset the file pointer and read in the entire file.
1272:
1273: dwRet = SetFilePointer(hFile, 0, 0, FILE_BEGIN);
1274:
1275: if (dwRet == -1)
1276: {
1277: RIP("InsertNewFont: SetFilePointer failed.\n");
1278: CloseHandle(hFile);
1279: LocalFree((LOCALHANDLE)pBuffer);
1280: return(FALSE);
1281: }
1282:
1283: if(!(bRet = ReadFile(hFile, pBuffer, cb, &cBytesRead, NULL) ||
1284: cBytesRead != cb))
1285: {
1286: RIP("InsertNewFont: ReadFile Failed.\n");
1287: CloseHandle(hFile);
1288: LocalFree((LOCALHANDLE)pBuffer);
1289: return(FALSE);
1290: }
1291:
1292: // NULL terminate it for good measure.
1293:
1294: *(pBuffer + cb) = '\0';
1295:
1296: // extract the full font name from the .PFB file. it is designated
1297: // by the /FullName keyword.
1298:
1299: if (!ExtractFullName(pBuffer, strFullName))
1300: {
1301: CloseHandle(hFile);
1302: LocalFree((LOCALHANDLE)pBuffer);
1303: return(FALSE);
1304: }
1305:
1306: // insert font name into New Fonts list box.
1307:
1308: strcpy2WChar(wstrFullName, strFullName);
1309:
1310: index = SendDlgItemMessage(hwnd, IDD_NEW_FONT_LIST_BOX, LB_ADDSTRING, 0,
1311: (DWORD)wstrFullName);
1312:
1313: if ((index == LB_ERR) || (index == LB_ERRSPACE))
1314: {
1315: RIP("InsertNewFont: LB_ADDSTRING failed.\n");
1316: CloseHandle(hFile);
1317: return(FALSE);
1318: }
1319:
1320: // associate a pointer to the file name with each entry in the listbox.
1321: // create local copy of file name, since the copy pwstrPFBFile will probably
1322: // no longer exist when we need to access it.
1323:
1324: if (!(pwstrFileName = (PWSTR)LocalAlloc(LPTR, (wcslen(pwstrPFBFile) + 1) * 2)))
1325: {
1326: RIP("InsertNewFont: LocalAlloc for pwstrFileName failed.\n");
1327: CloseHandle(hFile);
1328: return(FALSE);
1329: }
1330:
1331: wcsncpy(pwstrFileName, pwstrPFBFile, wcslen(pwstrPFBFile) + 1);
1332:
1333: SendDlgItemMessage(hwnd, IDD_NEW_FONT_LIST_BOX, LB_SETITEMDATA, index,
1334: (DWORD)pwstrFileName);
1335:
1336: // free up memory.
1337:
1338: LocalFree((LOCALHANDLE)pBuffer);
1339:
1340: // close the .PFB file.
1341:
1342: CloseHandle(hFile);
1343:
1344: return(TRUE);
1345: }
1346:
1347:
1348: //--------------------------------------------------------------------------
1349: // PSTR LocateKeyword(pBuffer, pstrKeyword)
1350: // PSTR pBuffer;
1351: // PSTR pstrKeyword;
1352: //
1353: // This function takes a pointer to a buffer, and a pointer to a null
1354: // terminated string. It searches the buffer for the string and returns
1355: // a pointer to the string if it is found.
1356: //
1357: // Returns:
1358: // This function returns a pointer to the keyword if it is found,
1359: // otherwise it returns NULL.
1360: //
1361: // History:
1362: // 03-Jan-1992 -by- Kent Settle (kentse)
1363: // Wrote it.
1364: //--------------------------------------------------------------------------
1365:
1366: PSTR LocateKeyword(pBuffer, pstrKeyword)
1367: PSTR pBuffer;
1368: PSTR pstrKeyword;
1369: {
1370: while(*pBuffer != '\0')
1371: {
1372: // search through the buffer until we find the keyword designator '/'.
1373:
1374: while(*pBuffer != '/')
1375: pBuffer++;
1376:
1377: if (!(strncmp(pstrKeyword, pBuffer, strlen(pstrKeyword))))
1378: break; // we found it.
1379:
1380: // not this keyword, continue the search.
1381:
1382: pBuffer ++;
1383: }
1384:
1385: // we did not find the keyword.
1386:
1387: if (*pBuffer == '\0')
1388: pBuffer = NULL;
1389:
1390: // we did find it, return a pointer to the '/' character at the
1391: // beginning of the keyword.
1392:
1393: return(pBuffer);
1394: }
1395:
1396:
1397: //--------------------------------------------------------------------------
1398: // BOOL ExtractFullName(pBuffer, pszFullName)
1399: // PSZ pBuffer;
1400: // PSZ pszFullName;
1401: //
1402: // This function takes a pointer to a buffer, and a pointer to a place
1403: // to store the actual FullName of the font.
1404: //
1405: // Returns:
1406: // This function returns TRUE if the fullname is found,
1407: // otherwise it returns FALSE.
1408: //
1409: // History:
1410: // 03-Jan-1992 -by- Kent Settle (kentse)
1411: // Wrote it.
1412: //--------------------------------------------------------------------------
1413:
1414: BOOL ExtractFullName(pBuffer, pstrFullName)
1415: PSTR pBuffer;
1416: PSTR pstrFullName;
1417: {
1418: CHAR buf[32];
1419:
1420: // extract the full font name from the .PFB file. it is designated
1421: // by the /FullName keyword.
1422:
1423: //!!! I want an ASCII string here. Should I do a LoadStringA or hardcode it
1424: //!!! or what??? -kentse.
1425: LoadStringA(hModule, IDS_FULLNAME + STRING_BASE, buf, sizeof(buf));
1426:
1427: if (!(pBuffer = LocateKeyword(pBuffer, buf)))
1428: {
1429: RIP("ExtractFullName: /FullName not found.\n");
1430: SetLastError(ERROR_INVALID_DATA);
1431: return(FALSE);
1432: }
1433:
1434: // if we got to this point, pBuffer will be pointing to
1435: // "/FullName (The Full Font Name)".
1436:
1437: // advance to the opening paren.
1438:
1439: while (*pBuffer != '(')
1440: pBuffer++;
1441:
1442: pBuffer++;
1443:
1444: // skip any white space.
1445:
1446: while (*pBuffer == ' ')
1447: pBuffer++;
1448:
1449: // pBuffer is now pointing to the first letter of the actual full name.
1450: // copy the name into our local buffer.
1451:
1452: while (*pBuffer != ')')
1453: *pstrFullName++ = *pBuffer++;
1454:
1455: // null terminate it.
1456:
1457: *pstrFullName = '\0';
1458:
1459: return(TRUE);
1460: }
1461:
1462:
1463: //--------------------------------------------------------------------------
1464: // BOOL ExtractFontName(pBuffer, pszFontName)
1465: // PSZ pBuffer;
1466: // PSZ pszFontName;
1467: //
1468: // This function takes a pointer to a buffer, and a pointer to a place
1469: // to store the actual FontName.
1470: //
1471: // Returns:
1472: // This function returns TRUE if the fullname is found,
1473: // otherwise it returns FALSE.
1474: //
1475: // History:
1476: // 07-Jan-1992 -by- Kent Settle (kentse)
1477: // Wrote it.
1478: //--------------------------------------------------------------------------
1479:
1480: BOOL ExtractFontName(pBuffer, pszFontName)
1481: PSZ pBuffer;
1482: PSZ pszFontName;
1483: {
1484: CHAR buf[32];
1485:
1486: // extract the font name from the .PFB file. it is designated
1487: // by the /FontName keyword.
1488:
1489: //!!! I want an ASCII string here. Should I do a LoadStringA or hardcode it
1490: //!!! or what??? -kentse.
1491:
1492: LoadStringA(hModule, (IDS_FONTNAME + STRING_BASE), buf, sizeof(buf));
1493:
1494: if (!(pBuffer = LocateKeyword(pBuffer, buf)))
1495: {
1496: RIP("ExtractFontName: /FontName not found.\n");
1497: SetLastError(ERROR_INVALID_DATA);
1498: return(FALSE);
1499: }
1500:
1501: // if we got to this point, pBuffer will be pointing to
1502: // "/FontName /The Font Name".
1503:
1504: // advance to the next '/' character.
1505:
1506: pBuffer++;
1507:
1508: while (*pBuffer != '/')
1509: pBuffer++;
1510:
1511: pBuffer++;
1512:
1513: // skip any white space.
1514:
1515: while (*pBuffer == ' ')
1516: pBuffer++;
1517:
1518: // pBuffer is now pointing to the first letter of the actual font name.
1519: // copy the name into our local buffer.
1520:
1521: while (*pBuffer != ' ')
1522: *pszFontName++ = *pBuffer++;
1523:
1524: // null terminate it.
1525:
1526: *pszFontName = '\0';
1527:
1528: return(TRUE);
1529: }
1530:
1531:
1532: //--------------------------------------------------------------------------
1533: // BOOL PFBToPFA(pwstrPFAFile, pwstrPFBFile)
1534: // PWSTR pwstrPFAFile;
1535: // PWSTR pwstrPFBFile;
1536: //
1537: // This function takes a pointer to a destination .PFA file and a source
1538: // .PFB file, then creates the .PFA from the .PFB file.
1539: //
1540: // Returns:
1541: // This function returns TRUE if the .PFA is successfully created,
1542: // otherwise it returns FALSE.
1543: //
1544: // History:
1545: // 07-Jan-1992 -by- Kent Settle (kentse)
1546: // Wrote it.
1547: //--------------------------------------------------------------------------
1548:
1549: BOOL PFBToPFA(pwstrPFAFile, pwstrPFBFile)
1550: PWSTR pwstrPFAFile;
1551: PWSTR pwstrPFBFile;
1552: {
1553: CHAR *pPFB;
1554: CHAR *pPFBTemp;
1555: CHAR szFullName[MAX_FULLNAME];
1556: CHAR szFontName[MAX_FONTNAME];
1557: HANDLE hPFAFile;
1558: DWORD cbToWrite1, cbToWrite2, cbWritten, cbSegment;
1559: DWORD cbPFA;
1560: CHAR buf[MAX_FULLNAME + MAX_FONTNAME + 6];
1561: DWORD i, dwRet;
1562: PFBHEADER pfbheader;
1563: CHAR *pSrc;
1564: CHAR *pDest;
1565: CHAR *pSave;
1566:
1567: // get a pointer to .PFB file.
1568:
1569: if (!(pPFB = MapFile(pwstrPFBFile)))
1570: {
1571: RIP("PSCRPTUI!PFBToPFA: MapFile failed.\n");
1572: return(FALSE);
1573: }
1574:
1575: // extract the full font name from the .PFB file. it is designated
1576: // by the /FullName keyword.
1577:
1578: if (!ExtractFullName(pPFB, szFullName))
1579: {
1580: UnmapViewOfFile((PVOID)pPFB);
1581: return(FALSE);
1582: }
1583:
1584: // extract the full font name from the .PFB file. it is designated
1585: // by the /FontName keyword.
1586:
1587: if (!ExtractFontName(pPFB, szFontName))
1588: {
1589: UnmapViewOfFile((PVOID)pPFB);
1590: return(FALSE);
1591: }
1592:
1593: // create the .PFA file.
1594:
1595: hPFAFile = CreateFile(pwstrPFAFile, GENERIC_WRITE, FILE_SHARE_READ, NULL,
1596: CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1597:
1598: if (hPFAFile == INVALID_HANDLE_VALUE)
1599: {
1600: RIP("PSCRPTUI!PFBToPFA: CreateFile for .PFA file failed.\n");
1601: UnmapViewOfFile((PVOID)pPFB);
1602: return(FALSE);
1603: }
1604:
1605: // output a DWORD at the beginning of the file, containing the
1606: // length of the PFA file, NOT including this DWORD. for now,
1607: // we do not know the length of the file, so write out a place holder.
1608:
1609: cbPFA = 0;
1610: WriteFile(hPFAFile, (PVOID)&cbPFA, (DWORD)sizeof(cbPFA),
1611: (DWORD *)&cbWritten, (LPOVERLAPPED)NULL);
1612:
1613: if (cbWritten != sizeof(cbPFA))
1614: {
1615: RIP("PSCRPTUI!PFBToPFA: WriteFile to .PFA file failed.\n");
1616: CloseHandle(hPFAFile);
1617: UnmapViewOfFile((PVOID)pPFB);
1618: return(FALSE);
1619: }
1620:
1621: // we want to put the following string at the start of the .PFA file:
1622: // "%FullName%FontName%CRLF". build this string in a buffer.
1623:
1624: buf[0] = '%';
1625:
1626: strncpy(&buf[1], szFullName, strlen(szFullName));
1627:
1628: i = strlen(szFullName) + 1;
1629: buf [i++] = '%';
1630:
1631: strncpy(&buf[i], szFontName, strlen(szFontName));
1632:
1633: i += strlen(szFontName);
1634: buf[i++] = '%';
1635: buf[i++] = 0x0D; // ASCII carriage return.
1636: buf[i++] = 0x0A; // ASCII line feed.
1637: buf[i] = '\0'; // NULL terminator.
1638:
1639: // write the buffer to the .PFA file.
1640:
1641: cbToWrite1 = strlen(buf);
1642: cbPFA = cbToWrite1;
1643:
1644: WriteFile(hPFAFile, (PVOID)buf, (DWORD)cbToWrite1,
1645: (DWORD *)&cbWritten, (LPOVERLAPPED)NULL);
1646:
1647: if (cbWritten != cbToWrite1)
1648: {
1649: RIP("PSCRPTUI!PFBToPFA: WriteFile to .PFA file failed.\n");
1650: CloseHandle(hPFAFile);
1651: UnmapViewOfFile((PVOID)pPFB);
1652: return(FALSE);
1653: }
1654:
1655: // The PFB file format is a sequence of segments, each of which has a
1656: // header part and a data part. The header format, defined in the
1657: // struct PFBHEADER below, consists of a one byte sanity check number
1658: // (128) then a one byte segment type and finally a four byte length
1659: // field for the data following data. The length field is stored in
1660: // the file with the least significant byte first. read in each
1661: // PFBHEADER, then process the data following it until we are done.
1662:
1663: pPFBTemp = pPFB;
1664:
1665: while (TRUE)
1666: {
1667: // read in what should be a PFBHEADER.
1668:
1669: memcpy(&pfbheader, pPFBTemp, sizeof(PFBHEADER));
1670:
1671: // make sure we have the header.
1672:
1673: if (pfbheader.jCheck != CHECK_BYTE)
1674: {
1675: RIP("PSCRPTUI!PFBToPFA: PFB Header not found.\n");
1676: SetLastError(ERROR_INVALID_DATA);
1677: CloseHandle(hPFAFile);
1678: UnmapViewOfFile((PVOID)pPFB);
1679: return(FALSE);
1680: }
1681:
1682: // if we have hit the end of the .PFB file, then we are done.
1683:
1684: if (pfbheader.jType == EOF_TYPE)
1685: break;
1686:
1687: // get the length of the data in this segment.
1688:
1689: cbSegment = ((DWORD)pfbheader.ushilength << 16) + pfbheader.uslolength;
1690:
1691: // get a pointer to the data itself for this segment.
1692:
1693: pSrc = pPFBTemp + sizeof(PFBHEADER);
1694:
1695: // create a buffer to do the conversion into.
1696:
1697: if (!(pDest = (CHAR *)LocalAlloc(LPTR, cbSegment * 3)))
1698: {
1699: RIP("PSCRPTUI!PFBToPFA: LocalAlloc for pDest failed.\n");
1700: CloseHandle(hPFAFile);
1701: UnmapViewOfFile((PVOID)pPFB);
1702: return(FALSE);
1703: }
1704:
1705: // save the pointer for later use.
1706:
1707: pSave = pDest;
1708:
1709: if (pfbheader.jType == ASCII_TYPE)
1710: {
1711: // read in an ASCII block, convert CR's to CR/LF's and
1712: // write out to the .PFA file.
1713:
1714: cbToWrite2 = cbSegment; // total count of bytes written to buffer.
1715:
1716: for (i = 0; i < cbSegment; i++)
1717: {
1718: if (0x0D == (*pDest++ = *pSrc++))
1719: {
1720: *pDest++ = (BYTE)0x0A;
1721: cbToWrite2++;
1722: }
1723: }
1724: }
1725: else if (pfbheader.jType == BINARY_TYPE)
1726: {
1727: // read in a BINARY block, convert it to HEX and write
1728: // out to the .PFA file.
1729:
1730: cbToWrite2 = cbSegment * 2; // total count of bytes written to buffer.
1731:
1732: for (i = 0; i < cbSegment; i++)
1733: {
1734: *pDest++ = BinaryToHex((*pSrc >> 4) & 0x0F);
1735: *pDest++ = BinaryToHex(*pSrc & 0x0F);
1736: pSrc++;
1737:
1738: // output a CR/LF ever 64 bytes for readability.
1739:
1740: if ((i % 32) == 31)
1741: {
1742: *pDest++ = (BYTE)0x0D;
1743: *pDest++ = (BYTE)0x0A;
1744: cbToWrite2 += 2;
1745: }
1746: }
1747:
1748: // add a final CR/LF if non 64 byte boundary.
1749:
1750: if ((cbSegment % 32) != 31)
1751: {
1752: *pDest++ = (BYTE)0x0D;
1753: *pDest++ = (BYTE)0x0A;
1754: cbToWrite2 += 2;
1755: }
1756: }
1757: else
1758: {
1759: RIP("PSCRPTUI!PFBToPFA: PFB Header type invalid.\n");
1760: SetLastError(ERROR_INVALID_DATA);
1761: CloseHandle(hPFAFile);
1762: UnmapViewOfFile((PVOID)pPFB);
1763: LocalFree((LOCALHANDLE)pDest);
1764: return(FALSE);
1765: }
1766:
1767: // reset pointer to start of buffer.
1768:
1769: pDest = pSave;
1770:
1771: // write the buffer to the .PFA file.
1772:
1773: WriteFile(hPFAFile, (PVOID)pDest, (DWORD)cbToWrite2,
1774: (DWORD *)&cbWritten, (LPOVERLAPPED)NULL);
1775:
1776: if (cbWritten != cbToWrite2)
1777: {
1778: RIP("PSCRPTUI!PFBToPFA: WriteFile block to .PFA file failed.\n");
1779: CloseHandle(hPFAFile);
1780: UnmapViewOfFile((PVOID)pPFB);
1781: LocalFree((LOCALHANDLE)pDest);
1782: return(FALSE);
1783: }
1784:
1785: // update the counter of BYTES written out to the file.
1786:
1787: cbPFA += cbToWrite2;
1788:
1789: // point to the next PFBHEADER.
1790:
1791: pPFBTemp += cbSegment + sizeof(PFBHEADER);
1792:
1793: // free up memory.
1794:
1795: LocalFree((LOCALHANDLE)pDest);
1796: }
1797:
1798: // set file pointer back to the beginning of the file, and write out
1799: // the size of the file as the first DWORD of the file.
1800:
1801: dwRet = SetFilePointer(hPFAFile, 0, 0, FILE_BEGIN);
1802:
1803: if (dwRet == -1)
1804: {
1805: RIP("PSCRPTUIPFBToPFA: SetFilePointer failed.\n");
1806: CloseHandle(hPFAFile);
1807: UnmapViewOfFile((PVOID)pPFB);
1808: LocalFree((LOCALHANDLE)pDest);
1809: return(FALSE);
1810: }
1811:
1812: WriteFile(hPFAFile, (PVOID)&cbPFA, (DWORD)sizeof(cbPFA),
1813: (DWORD *)&cbWritten, (LPOVERLAPPED)NULL);
1814:
1815: if (cbWritten != sizeof(cbPFA))
1816: {
1817: RIP("PSCRPTUI!PFBToPFA: WriteFile to .PFA file failed.\n");
1818: CloseHandle(hPFAFile);
1819: UnmapViewOfFile((PVOID)pPFB);
1820: LocalFree((LOCALHANDLE)pDest);
1821: return(FALSE);
1822: }
1823:
1824: // close the .PFA file.
1825:
1826: CloseHandle(hPFAFile);
1827:
1828: if (!UnmapViewOfFile((PVOID)pPFB))
1829: RIP("PSCRPTUI!PFBToPFA: UnmapViewOfFile failed.\n");
1830:
1831: return(TRUE);
1832: }
1833:
1834:
1835: BOOL LocateFile(hwnd, pwstrSearchFile, idString, pFileFindData, phFile)
1836: HWND hwnd;
1837: PWSTR pwstrSearchFile;
1838: int idString;
1839: WIN32_FIND_DATA *pFileFindData;
1840: HANDLE *phFile;
1841: {
1842: WCHAR wstringbuf[256];
1843: DWORD Value;
1844: DWORD Error;
1845:
1846: // see if there are any specified files in the specified directory.
1847:
1848: while (TRUE)
1849: {
1850: *phFile = FindFirstFile(pwstrSearchFile, pFileFindData);
1851:
1852: // if FindFirstFile failed, try to figure out why.
1853:
1854: if (*phFile == (HANDLE)-1)
1855: {
1856: Error = GetLastError();
1857:
1858: if ((Error == ERROR_NOT_READY) ||
1859: (Error == ERROR_NO_MEDIA_IN_DRIVE))
1860: return(FALSE);
1861:
1862: if (Error == ERROR_FILE_NOT_FOUND)
1863: {
1864: LoadString(hModule,
1865: (idString + STRING_BASE),
1866: wstringbuf, (sizeof(wstringbuf) / 2));
1867:
1868: Value = MessageBox(hwnd, wstringbuf, NULL,
1869: MB_ICONSTOP | MB_RETRYCANCEL);
1870:
1871: if (Value == IDCANCEL)
1872: return(FALSE);
1873: }
1874:
1875: if (Error == ERROR_PATH_NOT_FOUND)
1876: {
1877: LoadString(hModule,
1878: (IDS_PATH_NOT_FOUND + STRING_BASE),
1879: wstringbuf, (sizeof(wstringbuf) / 2));
1880:
1881: Value = MessageBox(hwnd, wstringbuf, NULL,
1882: MB_ICONSTOP | MB_RETRYCANCEL);
1883:
1884: if (Value == IDCANCEL)
1885: return(FALSE);
1886: }
1887:
1888:
1889: //!!! isn't this how to highlight the text in the edit box??? - kentse
1890:
1891: // highlight the current text in the edit box.
1892:
1893: SendDlgItemMessage(hwnd, IDD_NEW_FONT_DIR_EDIT_BOX,
1894: EM_SETSEL, 0, 0x7FFF0000L);
1895: }
1896: else
1897: {
1898: // FindFirstFile must have worked, continue on.
1899:
1900: return(TRUE);
1901: }
1902: }
1903: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.