![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to afmtopfm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / print / pslib|
Return to afmtopfm.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pslib |
1.1 root 1: //--------------------------------------------------------------------------
2: //
3: // Module Name: AFMTOPFM.C
4: //
5: // This module of the afm compiler parses the afm file and collects
6: // information in the PFM structure. It then passes control to the
7: // pfm module which outputs the pfm file.
8: //
9: // USAGE: AFM <AFM filename> <MS database filename>
10: // output is filename.pfm.
11: //
12: // Author: Kent Settle (kentse)
13: // Created: 18-Mar-1991
14: //
15: // Copyright (c) 1988 - 1993 Microsoft Corporation
16: //--------------------------------------------------------------------------
17:
18: #include <string.h>
19: #include "pscript.h"
20: #include "mapping.h"
21: #include "tables.h"
22:
23: int _fltused; // HEY, it shut's up the linker. That's why it's here.
24:
25: #define U_SPACE 0x20
26: #define U_SYMBOL_BULLET 0x00B7
27: #define U_BULLET 0x2022
28:
29: // Alias Family Tables.
30:
31: static char *TimesAlias[] = {"Times", "Tms Rmn", "Times Roman", "TimesRoman",
32: "TmsRmn", "Varitimes", "Dutch",
33: "Times New Roman", "TimesNewRomanPS",
34: NULL };
35:
36: static char *HelveticaAlias[] = {"Helvetica", "Helv", "Arial", "Swiss", NULL};
37:
38: static char *CourierAlias[] = {"Courier", "Courier New", NULL};
39:
40: static char *HelveticaNarrowAlias[] = {"Helvetica-Narrow", "Helvetica Narrow",
41: "Arial-Narrow", "Arial Narrow", NULL};
42:
43: static char *PalatinoAlias[] = {"Palatino", "Zapf Calligraphic",
44: "Bookman Antiqua", "Book Antiqua",
45: "ZapfCalligraphic", NULL};
46:
47: static char *BookmanAlias[] = {"ITC Bookman", "Bookman Old Style", "Bookman",
48: NULL};
49:
50: static char *NewCenturySBAlias[] = {"NewCenturySchlbk", "New Century Schoolbook",
51: "Century Schoolbook", "NewCenturySchoolBook",
52: "New Century SchoolBook", "CenturySchoolBook",
53: NULL};
54:
55: static char *AvantGardeAlias[] = {"AvantGarde", "ITC Avant Garde Gothic",
56: "Century Gothic", "ITC Avant Garde", NULL};
57:
58: static char *ZapfChanceryAlias[] = {"ZapfChancery", "ITC Zapf Chancery",
59: "Monotype Corsiva", NULL};
60:
61: static char *ZapfDingbatsAlias[] = {"ZapfDingbats", "ITC Zapf Dingbats",
62: "Monotype Sorts", "Zapf Dingbats", NULL};
63:
64: static USHORT ausIFIMetrics2WinWeight[12] =
65: {
66: FW_DONTCARE,
67: FW_DONTCARE,
68: FW_LIGHT,
69: FW_LIGHT,
70: FW_NORMAL,
71: FW_NORMAL,
72: FW_NORMAL,
73: FW_BOLD,
74: FW_BOLD,
75: FW_BOLD,
76: FW_BOLD,
77: FW_BOLD
78: };
79:
80: //#define ALL_METRICS
81:
82: // declarations of routines defined within this module.
83:
84: VOID PrintLine(char *);
85: VOID ParseKernPairs(PPARSEDATA);
86: VOID ParseKernData(PPARSEDATA);
87: VOID ParseFontName(PPARSEDATA);
88: VOID ParseFullName(PPARSEDATA);
89: VOID ParseFamilyName(PPARSEDATA);
90: VOID ParseWeight(PPARSEDATA);
91: BOOL ParseCharMetrics(PPARSEDATA);
92: int ParseCharName(PPARSEDATA);
93: int ParseCharWidth(PPARSEDATA);
94: VOID ParseBoundingBox(PPARSEDATA);
95: VOID InitPfm(PPARSEDATA);
96: VOID SetWidths(PPARSEDATA);
97: BOOL WritePFM(PWSTR, PPARSEDATA);
98: VOID ParseAfm(PPARSEDATA);
99: int ParseCharCode(PPARSEDATA);
100: int GetCharCode(char *, PPARSEDATA);
101: BOOL GetFirstLastChar(PPARSEDATA);
102: VOID BuildNTFM(PPARSEDATA, PSTR);
103: VOID InitIFIMETRICS(PPARSEDATA);
104: VOID CompleteIFIMETRICS(PPARSEDATA);
105: VOID ParseMSFamilyName(PPARSEDATA);
106: VOID ParsePitch(PPARSEDATA);
107: VOID GetFamilyAliases(IFIMETRICS *, PSTR);
108:
109: // external declarations.
110:
111: extern BOOL GetLine(PPARSEDATA);
112: extern int GetFloat(int, PPARSEDATA);
113: extern int GetNumber(PPARSEDATA);
114: extern VOID UnGetLine(PPARSEDATA);
115: extern VOID EatWhite(PPARSEDATA);
116: extern VOID GetWord(char *, int, PPARSEDATA);
117: extern int MapToken(char *, TABLE_ENTRY *);
118: extern int GetKeyword(TABLE_ENTRY *, PPARSEDATA);
119:
120: //--------------------------------------------------------------------------
121: //
122: // VOID InitPfm(pdata)
123: // PPARSEDATA pdata;
124: //
125: // Initialize the NTFM structure.
126: //
127: // Returns:
128: // This routine returns no value.
129: //
130: // History:
131: // 18-Mar-1991 -by- Kent Settle (kentse)
132: // Brought in from PM, and cleaned up.
133: //--------------------------------------------------------------------------
134:
135: VOID InitPfm(pdata)
136: PPARSEDATA pdata;
137: {
138: PNTFM pntfm;
139:
140: pntfm = pdata->pntfm;
141:
142: pntfm->cjThis = DWORDALIGN(sizeof(NTFM));
143: pntfm->ulVersion = (ULONG)PFM_VERSION;
144: pntfm->fwdLowerCaseAscent = 0;
145: pntfm->loszFullName = 0;
146: pntfm->loszFontName = 0;
147: pntfm->loszFamilyName = 0;
148: pntfm->cKernPairs = 0;
149: pntfm->cCharacters = 0;
150: pntfm->cjSoftFont = 0;
151: pntfm->loSoftFont = 0;
152: pntfm->loIFIMETRICS = 0;
153: }
154:
155:
156: //--------------------------------------------------------------------------
157: // VOID ParseAfm(pdata)
158: // PPARSEDATA pdata;
159: //
160: // Parses most of the AFM file to fill in the NTFM structure.
161: //
162: // Parameters:
163: // None.
164: //
165: // Returns:
166: // This routine returns no value.
167: //
168: // History:
169: // 19-Mar-1991 -by- Kent Settle (kentse)
170: // Ripped out of main.
171: //--------------------------------------------------------------------------
172:
173: VOID ParseAfm(pdata)
174: PPARSEDATA pdata;
175: {
176: int iToken;
177: BOOL fEndOfInput;
178: PNTFM pntfm;
179: PIFIMETRICS pTmpIFI;
180: FLOAT eCharSlope;
181:
182: // get local pointers.
183:
184: pntfm = pdata->pntfm;
185: pTmpIFI = pdata->pTmpIFI;
186:
187: // fill in some default values.
188:
189: InitIFIMETRICS(pdata);
190:
191: fEndOfInput = FALSE;
192: while (!fEndOfInput)
193: {
194: GetLine(pdata);
195: iToken = GetKeyword(AFMKeywordTable, pdata);
196:
197: switch(iToken)
198: {
199: case TK_STARTFONTMETRICS:
200: break;
201:
202: case TK_STARTKERNDATA:
203: ParseKernData(pdata);
204: break;
205:
206: case TK_FONTNAME:
207: ParseFontName(pdata);
208: break;
209:
210: case TK_FULLNAME:
211: ParseFullName(pdata);
212: break;
213:
214: case TK_FAMILYNAME:
215: ParseFamilyName(pdata);
216: break;
217:
218: case TK_WEIGHT:
219: ParseWeight(pdata);
220:
221: pTmpIFI->usWinWeight = ausIFIMetrics2WinWeight[pTmpIFI->panose.bWeight];
222:
223: if (pTmpIFI->usWinWeight > FW_NORMAL)
224: pTmpIFI->fsSelection |= FM_SEL_BOLD;
225:
226: break;
227:
228: case TK_ITALICANGLE:
229: eCharSlope = (FLOAT)(GetFloat(10, pdata) / 10);
230:
231: if ((LONG)(eCharSlope * 1000) == 0)
232: {
233: pTmpIFI->ptlCaret.x = 0;
234: pTmpIFI->ptlCaret.y = 1;
235: }
236: else
237: {
238: pTmpIFI->fsSelection |= FM_SEL_ITALIC;
239:
240: // lean 17.5 degrees away from the y-axis.
241:
242: pTmpIFI->ptlCaret.x = 3153;
243: pTmpIFI->ptlCaret.y = 10000;
244: }
245:
246: break;
247:
248: case TK_MSFAMILY:
249: ParseMSFamilyName(pdata);
250: break;
251:
252: case TK_ISFIXEDPITCH:
253: ParsePitch(pdata);
254:
255: break;
256:
257: case TK_ENCODINGSCHEME:
258: break;
259:
260: case TK_UNDERLINEPOSITION:
261: pTmpIFI->fwdUnderscorePosition = (FWORD) GetNumber(pdata);
262: #ifdef ALL_METRICS
263: DbgPrint("fwdUnderscorePosition = %d\n",
264: pTmpIFI->fwdUnderscorePosition);
265: #endif
266: break;
267:
268: case TK_UNDERLINETHICKNESS:
269: pTmpIFI->fwdUnderscoreSize = (FWORD)GetNumber(pdata);
270: pTmpIFI->fwdStrikeoutSize = pTmpIFI->fwdUnderscoreSize;
271: #ifdef ALL_METRICS
272: DbgPrint("fwdUnderscoreSize = %d\n",
273: pTmpIFI->fwdUnderscoreSize);
274: #endif
275: break;
276:
277: case TK_FONTBBOX:
278: ParseBoundingBox(pdata);
279: break;
280:
281: case TK_CAPHEIGHT:
282: break;
283:
284: case TK_XHEIGHT:
285: pTmpIFI->fwdXHeight = (FWORD)GetNumber(pdata);
286: #ifdef ALL_METRICS
287: DbgPrint("fwdXHeight = %d\n", pTmpIFI->fwdXHeight);
288: #endif
289: break;
290:
291: case TK_ASCENDER:
292: pntfm->fwdLowerCaseAscent = (FWORD)GetNumber(pdata);
293: #ifdef ALL_METRICS
294: DbgPrint("fwdLowerCaseAscent = %d\n",
295: pntfm->fwdLowerCaseAscent);
296: #endif
297: break;
298:
299: case TK_STARTCHARMETRICS:
300: ParseCharMetrics(pdata);
301: break;
302:
303: case TK_ENDFONTMETRICS:
304: fEndOfInput = TRUE;
305: break;
306:
307: }
308:
309: pdata->szLine = pdata->rgbLine;
310: }
311: }
312:
313:
314: //--------------------------------------------------------------------------
315: //
316: // VOID SetWidths();
317: //
318: // This routine computes the maximum and average character widths from the
319: // character metrics in the NTFM structure.
320: //
321: // Parameters:
322: // None.
323: //
324: // Returns:
325: // This routine returns no value.
326: //
327: // History:
328: // 01-Apr-1991 -by- Kent Settle (kentse)
329: // Wrote it.
330: //--------------------------------------------------------------------------
331:
332: VOID SetWidths(pdata)
333: PPARSEDATA pdata;
334: {
335: USHORT i;
336: int iAvg;
337: int iMax;
338:
339: iAvg = 0;
340: iMax = 0;
341:
342: // calculate maximum and average character widths.
343:
344: for (i = 0; i < pdata->pntfm->cCharacters; i++)
345: {
346: iAvg += (int)pdata->TmpCharWidths[i];
347: if (iMax < (int)pdata->TmpCharWidths[i])
348: iMax = (int)pdata->TmpCharWidths[i];
349: }
350:
351: pdata->pTmpIFI->fwdAveCharWidth = (FWORD)(iAvg / pdata->pntfm->cCharacters);
352:
353: pdata->pTmpIFI->fwdMaxCharInc = (FWORD)iMax;
354:
355: #ifdef ALL_METRICS
356: DbgPrint("fwdAveCharWidth = %d\n", pdata->pTmpIFI->fwdAveCharWidth);
357: DbgPrint("fwdMaxCharInc = %d\n", pdata->pTmpIFI->fwdMaxCharInc);
358: #endif
359: }
360:
361:
362: //--------------------------------------------------------------------------
363: //
364: // VOID ParseKernPairs();
365: //
366: // Parse the pairwise kerning data.
367: //
368: // Parameters:
369: // None.
370: //
371: // Returns:
372: // This routine returns no value.
373: //
374: // History:
375: // 13-Mar-1992 -by- Kent Settle (kentse)
376: // Modified to use FD_KERNINGPAIR struct instead of KP.
377: // 18-Mar-1991 -by- Kent Settle (kentse)
378: // Brought in from PM, and cleaned up.
379: //--------------------------------------------------------------------------
380:
381: VOID ParseKernPairs(pdata)
382: PPARSEDATA pdata;
383: {
384: int i;
385: int iCh1;
386: int iCh2;
387: int iKernAmount;
388: int iToken;
389: int cPairs;
390: char szWord[80];
391: WCHAR wc1, wc2;
392: UCMap *pmap;
393: UCMap *pmapReset;
394: BOOL bFound;
395: cPairs = GetNumber(pdata);
396:
397: pdata->pntfm->cKernPairs = (USHORT)cPairs;
398:
399: // point to the appropriate mapping table in mapping.h.
400:
401: if (!strcmp(pdata->szTmpFontName, "Symbol"))
402: pmap = SymbolMap;
403: else if (!strcmp(pdata->szTmpFontName, "ZapfDingbats"))
404: pmap = DingbatsMap;
405: else
406: pmap = LatinMap;
407:
408: pmapReset = pmap;
409:
410: for (i = 0; i < cPairs; ++i)
411: {
412: if (GetLine(pdata))
413: break;
414: if (GetKeyword(AFMKeywordTable, pdata) != TK_KPX)
415: {
416: UnGetLine(pdata);
417: break;
418: }
419:
420: GetWord(szWord, sizeof(szWord), pdata);
421: #ifdef ALL_METRICS
422: DbgPrint("Char1 = %s ", szWord);
423: #endif
424: iCh1 = GetCharCode(szWord, pdata);
425: GetWord(szWord, sizeof(szWord), pdata);
426: #ifdef ALL_METRICS
427: DbgPrint("Char2 = %s ", szWord);
428: #endif
429: iCh2 = GetCharCode(szWord, pdata);
430:
431: iKernAmount = GetNumber(pdata);
432:
433: #ifdef ALL_METRICS
434: DbgPrint("Amount = %d\n", iKernAmount);
435: #endif
436:
437: iCh1 = iCh1 & 0x0FF; // 0 <= CharacerCode <= 255.
438: iCh2 = iCh2 & 0x0FF;
439:
440: // we now have the postscript character code for each character
441: // of the kerning pair. we now need to convert them to UNICODE.
442:
443: pmap = pmapReset;
444:
445: bFound = FALSE;
446:
447: while (pmap->szChar)
448: {
449: if ((USHORT)(pmap->usPSValue & 0x7FFF) == (USHORT)iCh1)
450: {
451: wc1 = pmap->usUCValue;
452: bFound = TRUE;
453: break;
454: }
455: pmap++;
456: }
457:
458: if (!bFound)
459: DbgPrint("GetPairs: Error char code %d not found.\n", iCh1);
460:
461: pmap = pmapReset;
462:
463: bFound = FALSE;
464:
465: while (pmap->szChar)
466: {
467: if ((USHORT)(pmap->usPSValue & 0x7FFF) == (USHORT)iCh2)
468: {
469: wc2 = pmap->usUCValue;
470: bFound = TRUE;
471: break;
472: }
473: pmap++;
474: }
475:
476: #ifdef ALL_METRICS
477: if (!bFound)
478: DbgPrint("GetPairs: Error char code %d not found.\n", iCh2);
479: #endif
480: pdata->TmpKernPairs[i].wcFirst = wc1;
481: pdata->TmpKernPairs[i].wcSecond = wc2;
482: pdata->TmpKernPairs[i].fwdKern = (FWORD)iKernAmount;
483: }
484:
485: GetLine(pdata);
486: iToken = GetKeyword(AFMKeywordTable, pdata);
487:
488: #if DBG
489: if (pdata->fEOF)
490: RIP("GetPairs: Premature end of file encountered\n");
491: else if (iToken != TK_ENDKERNPAIRS)
492: {
493: DbgPrint("GetPairs: expected EndKernPairs\n");
494: DbgPrint("%s\n", pdata->rgbLine);
495: }
496: #endif
497:
498: return;
499: }
500:
501:
502: //--------------------------------------------------------------------------
503: // VOID ParseKernData(pdata)
504: // PPARSEDATA pdata;
505: //
506: // Start processing the pairwise kerning data.
507: //
508: // Parameters:
509: // None.
510: //
511: // Returns:
512: // This routine returns no value.
513: //
514: // History:
515: // 18-Mar-1991 -by- Kent Settle (kentse)
516: // Brought in from PM, and cleaned up.
517: //--------------------------------------------------------------------------
518:
519: VOID ParseKernData(pdata)
520: PPARSEDATA pdata;
521: {
522: if (!GetLine(pdata))
523: {
524: if (GetKeyword(AFMKeywordTable, pdata) == TK_STARTKERNPAIRS)
525: ParseKernPairs(pdata);
526: else
527: RIP("PSCRPTUI!ParseKernData: expected StartKernPairs\n");
528: }
529: else
530: RIP("PSCRPTUI!ParseKernData: unexpected end of file\n");
531: }
532:
533:
534: //--------------------------------------------------------------------------
535: // VOID ParseFontName(pdata)
536: // PPARSEDATA pdata;
537: //
538: // Move the font name from the input buffer into the pfm structure.
539: //
540: // Parameters:
541: // None.
542: //
543: // Returns:
544: // This routine returns no value.
545: //
546: // History:
547: // 18-Mar-1991 -by- Kent Settle (kentse)
548: // Brought in from PM, and cleaned up.
549: //--------------------------------------------------------------------------
550:
551: VOID ParseFontName(pdata)
552: PPARSEDATA pdata;
553: {
554: EatWhite(pdata);
555:
556: // get the length of the font name.
557:
558: pdata->cbFontName = strlen((char *)(pdata->szLine)) + 1;
559:
560: // now copy the facename to temporary storage.
561:
562: memcpy(pdata->szTmpFontName, pdata->szLine, pdata->cbFontName);
563:
564: #ifdef ALL_METRICS
565: DbgPrint("FontName = %s.\n", pdata->szLine);
566: #endif
567: }
568:
569:
570: //--------------------------------------------------------------------------
571: // VOID ParseFullName(pdata)
572: // PPARSEDATA pdata;
573: //
574: // Move the full name from the input buffer into the pfm structure.
575: //
576: // Parameters:
577: // None.
578: //
579: // Returns:
580: // This routine returns no value.
581: //
582: // History:
583: // 29-Mar-1991 -by- Kent Settle (kentse)
584: // Wrote it.
585: //--------------------------------------------------------------------------
586:
587: VOID ParseFullName(pdata)
588: PPARSEDATA pdata;
589: {
590: EatWhite(pdata);
591:
592: // get the length of the full name.
593:
594: pdata->cbFullName = strlen((char *)(pdata->szLine)) + 1;
595:
596: // now copy the Uniquename to temporary storage.
597:
598: memcpy(pdata->szTmpFullName, pdata->szLine, pdata->cbFullName);
599:
600: #ifdef ALL_METRICS
601: DbgPrint("FullName = %s.\n", pdata->szLine);
602: #endif
603: }
604:
605:
606: //--------------------------------------------------------------------------
607: //
608: // VOID ParseFamilyName();
609: //
610: // Move the family name from the input buffer into the pfm structure.
611: //
612: // Parameters:
613: // None.
614: //
615: // Returns:
616: // This routine returns no value.
617: //
618: // History:
619: // 29-Mar-1991 -by- Kent Settle (kentse)
620: // Wrote it.
621: //--------------------------------------------------------------------------
622:
623: VOID ParseFamilyName(pdata)
624: PPARSEDATA pdata;
625: {
626: EatWhite(pdata);
627:
628: // get the length of the family name.
629:
630: pdata->cbFamilyName = strlen((char *)(pdata->szLine)) + 1;
631:
632: // now copy the familyname to temporary storage.
633:
634: memcpy(pdata->szTmpFamilyName, pdata->szLine, pdata->cbFamilyName);
635:
636: #ifdef ALL_METRICS
637: DbgPrint("FamilyNameName = %s.\n", pdata->szLine);
638: #endif
639: }
640:
641:
642: //--------------------------------------------------------------------------
643: // VOID ParseMSFamilyName(pdata)
644: // PPARSEDATA pdata;
645: //
646: // gets the MSFamily name, and converts it to a value.
647: //
648: // Parameters:
649: // None.
650: //
651: // Returns:
652: // This routine returns no value.
653: //
654: // History:
655: // 18-Mar-1991 -by- Kent Settle (kentse)
656: // Brought in from PM, and cleaned up.
657: //--------------------------------------------------------------------------
658:
659: VOID ParseMSFamilyName(pdata)
660: PPARSEDATA pdata;
661: {
662: char szWord[80];
663: BOOL bFound = FALSE;
664: TABLE_ENTRY *pTable;
665:
666: // clear out the MSFamily flags.
667:
668: pdata->pTmpIFI->jWinPitchAndFamily &= ~(FF_DECORATIVE | FF_DONTCARE |
669: FF_MODERN | FF_ROMAN | FF_SCRIPT |
670: FF_SWISS);
671: GetWord(szWord, sizeof(szWord), pdata);
672:
673: #ifdef ALL_METRICS
674: DbgPrint("MSFamily = %s\n", szWord);
675: #endif
676:
677: pTable = MSFamilyTable;
678: while (pTable->szStr)
679: {
680: if (!strcmp(szWord, pTable->szStr))
681: {
682: pdata->pTmpIFI->jWinPitchAndFamily |= pTable->iValue;
683: bFound = TRUE;
684: break;
685: }
686:
687: ++pTable;
688: }
689:
690: // set flag, if not found.
691:
692: if (!bFound)
693: {
694: #if DBG
695: #ifdef ALL_METRICS
696: DbgPrint("ParseMSFamilyName: unknown MSFamily = \"%s\"\n", szWord);
697: #endif
698: #endif
699: pdata->pTmpIFI->jWinPitchAndFamily |= FF_DONTCARE;
700: }
701: }
702:
703:
704: //--------------------------------------------------------------------------
705: // VOID ParseMSFamilyName(pdata)
706: // PPARSEDATA pdata;
707: //
708: // gets the MSFamily name, and converts it to a value.
709: //
710: // Parameters:
711: // None.
712: //
713: // Returns:
714: // This routine returns no value.
715: //
716: // History:
717: // 18-Mar-1991 -by- Kent Settle (kentse)
718: // Brought in from PM, and cleaned up.
719: //--------------------------------------------------------------------------
720:
721: VOID ParsePitch(pdata)
722: PPARSEDATA pdata;
723: {
724: CHAR szWord[6];
725:
726: GetWord(szWord, sizeof(szWord), pdata);
727:
728: pdata->pTmpIFI->jWinPitchAndFamily &= ~(FIXED_PITCH | VARIABLE_PITCH);
729:
730: if ((!(strncmp(szWord, "True", 4))) ||
731: (!(strncmp(szWord, "true", 4))))
732: {
733: pdata->pTmpIFI->jWinPitchAndFamily |= FIXED_PITCH;
734: #ifdef ALL_METRICS
735: DbgPrint("Font is fixed pitch.\n");
736: #endif
737: }
738: else
739: {
740: pdata->pTmpIFI->jWinPitchAndFamily |= VARIABLE_PITCH;
741: #ifdef ALL_METRICS
742: DbgPrint("Font is variable pitch.\n");
743: #endif
744: }
745: }
746:
747: //--------------------------------------------------------------------------
748: // VOID ParseWeight(pdata)
749: // PPARSEDATA pdata;
750: //
751: // Parse the fonts weight and set the corresponding entry in the PFM
752: // structure.
753: //
754: // Parameters:
755: // None.
756: //
757: // Returns:
758: // This routine returns no value.
759: //
760: // History:
761: // 18-Mar-1991 -by- Kent Settle (kentse)
762: // Brought in from PM, and cleaned up.
763: //--------------------------------------------------------------------------
764:
765: VOID ParseWeight(pdata)
766: PPARSEDATA pdata;
767: {
768: char szWord[80];
769: BOOL bFound = FALSE;
770: TABLE_ENTRY *pTable;
771:
772: GetWord(szWord, sizeof(szWord), pdata);
773:
774: #ifdef ALL_METRICS
775: DbgPrint("Weight = %s\n", szWord);
776: #endif
777:
778: pTable = WeightTable;
779: while (pTable->szStr)
780: {
781: #ifdef ALL_METRICS
782: DbgPrint("\tweight = %s\n", pTable->szStr);
783: #endif
784: if (!strcmp(szWord, pTable->szStr))
785: {
786: pdata->pTmpIFI->panose.bWeight = pTable->iValue;
787: bFound = TRUE;
788: break;
789: }
790:
791: ++pTable;
792: }
793:
794: // check for and flag error conditions.
795:
796: if (!bFound)
797: {
798: #if DBG
799: #ifdef ALL_METRICS
800: DbgPrint("ParseWeight: unknown font weight = \"%s\"\n", szWord);
801: #endif
802: #endif
803: pdata->pTmpIFI->panose.bWeight = PAN_WEIGHT_MEDIUM;
804: }
805: }
806:
807:
808: //--------------------------------------------------------------------------
809: // BOOL ParseCharMetrics(pdata)
810: // PPARSEDATA pdata;
811: //
812: // Parse the character metrics entry in the input file and set the
813: // width and bounding box in the PFM structure.
814: //
815: // Parameters:
816: // None.
817: //
818: // Returns:
819: // This routine returns no value.
820: //
821: // History:
822: // 18-Mar-1991 -by- Kent Settle (kentse)
823: // Brought in from PM, and cleaned up.
824: //--------------------------------------------------------------------------
825:
826: BOOL ParseCharMetrics(pdata)
827: PPARSEDATA pdata;
828: {
829: int cChars;
830: USHORT usCount = 0;
831: int i;
832: int iWidth;
833: int iChar;
834:
835: cChars = GetNumber(pdata);
836: for (i = 0; i < cChars; ++i)
837: {
838: if (GetLine(pdata))
839: {
840: RIP("PSCRPTUI!ParseCharMetrics: unexpected end of file encountered\n");
841: return(FALSE);
842: }
843:
844: iChar = ParseCharCode(pdata);
845:
846: iWidth = ParseCharWidth(pdata);
847:
848: iChar = ParseCharName(pdata);
849:
850: if (iChar >= 0)
851: {
852: pdata->TmpCharWidths[usCount] = (USHORT)iWidth;
853: pdata->TmpCharCodes[usCount] = (BYTE)iChar;
854:
855: usCount++; // increment character counter.
856:
857: #ifdef ALL_METRICS
858: DbgPrint("iChar = %x, CharWidth = %d\n",
859: pdata->TmpCharCodes[usCount - 1],
860: pdata->TmpCharWidths[usCount - 1]);
861: #endif
862: }
863: }
864:
865: pdata->pntfm->cCharacters = usCount;
866: GetLine(pdata);
867: if (GetKeyword(AFMKeywordTable, pdata) != TK_ENDCHARMETRICS)
868: {
869: RIP("PSCRPTUI!ParseCharMetrics: expected EndCharMetrics\n");
870: SetLastError(ERROR_INVALID_DATA);
871: return(FALSE);
872: }
873:
874: return(TRUE);
875: }
876:
877:
878: //--------------------------------------------------------------------------
879: // int ParseCharName(pdata)
880: // PPARSEDATA pdata;
881: //
882: // Parse a character's name and return its numeric value.
883: //
884: // Parameters:
885: // None.
886: //
887: // Returns:
888: // This routine returns numeric value of given character.
889: //
890: // History:
891: // 18-Mar-1991 -by- Kent Settle (kentse)
892: // Brought in from PM, and cleaned up.
893: //--------------------------------------------------------------------------
894:
895: int ParseCharName(pdata)
896: PPARSEDATA pdata;
897: {
898: int iChar;
899: char szWord[18];
900:
901: EatWhite(pdata);
902: GetWord(szWord, sizeof(szWord), pdata);
903:
904: if (!strcmp("N", szWord))
905: {
906: GetWord(szWord, sizeof(szWord), pdata);
907: #ifdef ALL_METRICS
908: DbgPrint("Char = %s ", szWord);
909: #endif
910: iChar = GetCharCode(szWord, pdata);
911: }
912: else
913: {
914: RIP("PSCRPTUI!ParseCharName: expected name field\n");
915: SetLastError(ERROR_INVALID_DATA);
916: return(-1);
917: }
918:
919: return(iChar);
920: }
921:
922:
923: //--------------------------------------------------------------------------
924: // int ParseCharWidth(pdata)
925: // PPARSEDATA pdata;
926: //
927: // Parse a character's width and return its numeric value.
928: //
929: // Parameters:
930: // None.
931: //
932: // Returns:
933: // This routine returns numeric value of given character's width.
934: //
935: // History:
936: // 18-Mar-1991 -by- Kent Settle (kentse)
937: // Brought in from PM, and cleaned up.
938: //--------------------------------------------------------------------------
939:
940: int ParseCharWidth(pdata)
941: PPARSEDATA pdata;
942: {
943: int iWidth;
944: char szWord[16];
945:
946: GetWord(szWord, sizeof(szWord), pdata);
947: if (!strcmp("WX", szWord))
948: {
949: iWidth = GetNumber(pdata);
950: if (iWidth==0)
951: {
952: RIP("PSCRPTUI!ParseCharWidth: zero character width\n");
953: SetLastError(ERROR_INVALID_DATA);
954: return(-1);
955: }
956:
957: EatWhite(pdata);
958: if (*(pdata->szLine++) != ';')
959: {
960: RIP("PSCRPTUI!ParseCharWidth: missing semicolon\n");
961: SetLastError(ERROR_INVALID_DATA);
962: return(-1);
963: }
964: }
965: else
966: {
967: RIP("PSCRPTUI!ParseCharWidth: expected \"WX\"\n");
968: SetLastError(ERROR_INVALID_DATA);
969: return(-1);
970: }
971:
972: return(iWidth);
973: }
974:
975:
976: //--------------------------------------------------------------------------
977: // int ParseCharCode(pdata)
978: // PPARSEDATA pdata;
979: //
980: // Parse the ASCII form of a character's code point and return its
981: // numeric value.
982: //
983: // Parameters:
984: // None.
985: //
986: // Returns:
987: // This routine returns numeric value of given character's codepoint.
988: //
989: // History:
990: // 18-Mar-1991 -by- Kent Settle (kentse)
991: // Brought in from PM, and cleaned up.
992: //--------------------------------------------------------------------------
993:
994: int ParseCharCode(pdata)
995: PPARSEDATA pdata;
996: {
997: int iChar;
998: char szWord[16];
999:
1000: iChar = 0;
1001: GetWord(szWord, sizeof(szWord), pdata);
1002: if (!strcmp("C", szWord))
1003: {
1004: iChar = GetNumber(pdata);
1005: if (iChar==0)
1006: {
1007: RIP("PSCRPTUI!ParseCharCode: invalid character code\n");
1008: SetLastError(ERROR_INVALID_DATA);
1009: return(-1);
1010: }
1011:
1012: EatWhite(pdata);
1013: if (*(pdata->szLine++) != ';')
1014: {
1015: RIP("PSCRPTUI!ParseCharCode: missing semicolon\n");
1016: SetLastError(ERROR_INVALID_DATA);
1017: return(-1);
1018: }
1019: }
1020: return(iChar);
1021: }
1022:
1023:
1024: //--------------------------------------------------------------------------
1025: // VOID ParseBoundingBox(pdata)
1026: // PPARSEDATA pdata;
1027: //
1028: // Parses a characters's bounding box and stores its size in
1029: // the NTFM structure.
1030: //
1031: // Parameters:
1032: // None.
1033: //
1034: // Returns:
1035: // This routine returns no value.
1036: //
1037: // History:
1038: // 18-Mar-1991 -by- Kent Settle (kentse)
1039: // Brought in from PM, and cleaned up.
1040: //--------------------------------------------------------------------------
1041:
1042: VOID ParseBoundingBox(pdata)
1043: PPARSEDATA pdata;
1044: {
1045: pdata->pntfm->rcBBox.left = GetNumber(pdata);
1046: pdata->pntfm->rcBBox.bottom = GetNumber(pdata);
1047: pdata->pntfm->rcBBox.right = GetNumber(pdata);
1048: pdata->pntfm->rcBBox.top = GetNumber(pdata);
1049: }
1050:
1051:
1052:
1053: //--------------------------------------------------------------------------
1054: // BOOL WritePFM(pwstrPFMFile, pdata)
1055: // PWSTR pwstrPFMFile;
1056: // PPARSEDATA pdata;
1057: //
1058: // Flush the ouput buffer to the file. Note that this function is only
1059: // called after the entire pfm structure has been built in the output buffer.
1060: //
1061: // Parameters:
1062: // None.
1063: //
1064: // Returns:
1065: // This routine returns TRUE if success, FALSE otherwise.
1066: //
1067: // History:
1068: // 20-Mar-1991 -by- Kent Settle (kentse)
1069: // Wrote it.
1070: //--------------------------------------------------------------------------
1071:
1072: BOOL WritePFM(pwstrPFMFile, pdata)
1073: PWSTR pwstrPFMFile;
1074: PPARSEDATA pdata;
1075: {
1076: HANDLE hPFMFile;
1077: ULONG ulCount;
1078:
1079: // create the .PFM file.
1080:
1081: hPFMFile = CreateFile(pwstrPFMFile, GENERIC_WRITE, FILE_SHARE_READ, NULL,
1082: CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1083:
1084: if (hPFMFile == INVALID_HANDLE_VALUE)
1085: {
1086: RIP("PSCRPTUI!WritePFM: Can't open .PFM file.\n");
1087: return(FALSE);
1088: }
1089:
1090: // write to the .PFM file, then close it.
1091:
1092: if (!WriteFile(hPFMFile, (LPVOID)pdata->pntfm, (DWORD)pdata->pntfm->cjThis,
1093: (LPDWORD)&ulCount, (LPOVERLAPPED)NULL))
1094: {
1095: RIP("PSCRPTUI!WritePFM: WriteFile to .PFM file failed.\n");
1096: return(FALSE);
1097: }
1098:
1099: if (ulCount != pdata->pntfm->cjThis)
1100: {
1101: RIP("PSCRPTUI!WritePFM: WriteFile count to .PFM file failed.\n");
1102: return(FALSE);
1103: }
1104:
1105: if (!CloseHandle(hPFMFile))
1106: RIP("PSCRPTUI!WritePFM: CloseHandle of .PFM file failed.\n");
1107:
1108: return(TRUE);
1109: }
1110:
1111:
1112: //--------------------------------------------------------------------------
1113: //
1114: // int GetCharCode(szWord, pdata)
1115: // char *szWord;
1116: // PPARSEDATA pdata;
1117: //
1118: // This routine is given a pointer to the character string. It returns
1119: // the character code, as defined in mapping.h, corresponding to this
1120: // character.
1121: //
1122: // Parameters:
1123: // szWord
1124: // Pointer to character name string.
1125: //
1126: // Returns:
1127: // This routine returns -1 if character not found, otherwise it
1128: // returns the character code.
1129: //
1130: // History:
1131: // 27-Mar-1991 -by- Kent Settle (kentse)
1132: // Wrote it.
1133: //--------------------------------------------------------------------------
1134:
1135: int GetCharCode(szWord, pdata)
1136: char *szWord;
1137: PPARSEDATA pdata;
1138: {
1139: UCMap *pmap;
1140:
1141: //!!! maybe there is a better way to do this???
1142:
1143: // point to the appropriate mapping table in mapping.h.
1144:
1145: if (!strcmp(pdata->szTmpFontName, "Symbol"))
1146: pmap = SymbolMap;
1147: else if (!strcmp(pdata->szTmpFontName, "ZapfDingbats"))
1148: pmap = DingbatsMap;
1149: else
1150: pmap = LatinMap;
1151:
1152: while (pmap->szChar)
1153: {
1154: if (!strcmp(szWord, pmap->szChar))
1155: return((int)(pmap->usPSValue & 0x7FFF));
1156: pmap++;
1157: }
1158:
1159: #ifdef ALL_METRICS
1160: DbgPrint("GetCharCode: Undefined Character = %s.\n", szWord);
1161: #endif
1162: return(-1);
1163: }
1164:
1165:
1166: //--------------------------------------------------------------------------
1167: //
1168: // BOOL GetFirstLastChar()
1169: //
1170: // This routine searches through the encoding table in mapping.h to
1171: // determine the first and last characters in the font. The character
1172: // codes are stored into the NTFM structure in UNICODE value.
1173: //
1174: // Parameters:
1175: // None.
1176: //
1177: // Returns:
1178: // This routine returns TRUE for success, FALSE otherwise.
1179: //
1180: // History:
1181: // 18-Apr-1991 -by- Kent Settle (kentse)
1182: // Wrote it.
1183: //--------------------------------------------------------------------------
1184:
1185: BOOL GetFirstLastChar(pdata)
1186: PPARSEDATA pdata;
1187: {
1188: PUCMap pmap;
1189: PUCMap pmapReset;
1190: USHORT usFirst = MAX_UNICODE_VALUE;
1191: USHORT usLast = MIN_UNICODE_VALUE;
1192: USHORT i;
1193: USHORT usTmp;
1194:
1195: //!!! maybe there is a better way to do this???
1196:
1197: // point to the appropriate mapping table in mapping.h.
1198:
1199: if (!strcmp(pdata->szTmpFontName, "Symbol"))
1200: pmap = SymbolMap;
1201: else if (!strcmp(pdata->szTmpFontName, "ZapfDingbats"))
1202: pmap = DingbatsMap;
1203: else
1204: pmap = LatinMap;
1205:
1206: pmapReset = pmap;
1207:
1208: // for every character in the font, do a lookup in the mapping
1209: // table in mapping.h to find the corresponding UNICODE value.
1210:
1211: for (i = 0; i < pdata->pntfm->cCharacters; i++)
1212: {
1213: while (pmap->szChar)
1214: {
1215: if ((BYTE)pdata->TmpCharCodes[i] == (BYTE)(pmap->usPSValue & 0xFF))
1216: {
1217: usTmp = pmap->usUCValue;
1218: if (usFirst > usTmp)
1219: usFirst = usTmp;
1220: if (usLast < usTmp)
1221: usLast = usTmp;
1222: break;
1223: }
1224:
1225: pmap++;
1226: }
1227:
1228: // reset pointer.
1229:
1230: pmap = pmapReset;
1231: }
1232:
1233: // make sure we have valid numbers.
1234:
1235: if (usFirst > usLast)
1236: {
1237: RIP("PSCRPTUI!etFirstLastChar: first char > last.\n");
1238: SetLastError(ERROR_INVALID_DATA);
1239: return(FALSE);
1240: }
1241:
1242: // everything must be OK.
1243:
1244: pdata->pTmpIFI->wcFirstChar = (WCHAR)usFirst;
1245: pdata->pTmpIFI->wcLastChar = (WCHAR)usLast;
1246:
1247: #ifdef ALL_METRICS
1248: DbgPrint("FirstChar = %x, LastChar = %x.\n", usFirst, usLast);
1249: #endif
1250:
1251: return(TRUE);
1252: }
1253:
1254:
1255: //--------------------------------------------------------------------------
1256: //
1257: // VOID BuildNTFM(pdata, pPFA)
1258: // PPARSEDATA pdata;
1259: // CHAR *pPFA;
1260: //
1261: // This routine builds an NTFM structure from all the temporary values
1262: // which have been determined by now.
1263: //
1264: // Returns:
1265: // This routine returns no value.
1266: //
1267: // History:
1268: // 18-Apr-1991 -by- Kent Settle (kentse)
1269: // Wrote it.
1270: //--------------------------------------------------------------------------
1271:
1272: VOID BuildNTFM(pdata, pPFA)
1273: PPARSEDATA pdata;
1274: CHAR *pPFA;
1275: {
1276: PNTFM pntfm;
1277: int cbKernPairs, cbWidths;
1278: DWORD cbPFA;
1279: PSTR pstr;
1280:
1281: // get local pointer.
1282:
1283: pntfm = pdata->pntfm;
1284:
1285: // deal with the softfont if there is one.
1286:
1287: if (pPFA)
1288: {
1289: // the first DWORD of the .PFA file contains the length in BYTES of the
1290: // remainder of the .PFA file.
1291:
1292: cbPFA = *(DWORD *)pPFA;
1293: pntfm->cjSoftFont = DWORDALIGN(cbPFA);
1294: }
1295:
1296: // there are several bits of data which have now been put into temporary
1297: // storage, but need to be attached to the NTFM structure.
1298:
1299: cbKernPairs = (pntfm->cKernPairs * sizeof(FD_KERNINGPAIR));
1300: cbWidths = DWORDALIGN(pntfm->cCharacters * sizeof(USHORT));
1301: pntfm->cjThis += DWORDALIGN(pdata->cbFullName) + DWORDALIGN(pdata->cbFontName) +
1302: DWORDALIGN(pdata->cbFamilyName) + DWORDALIGN(cbKernPairs) +
1303: cbWidths + DWORDALIGN(pntfm->cCharacters) +
1304: DWORDALIGN(pntfm->cjSoftFont);
1305:
1306: if (pntfm->cjThis > INIT_PFM)
1307: {
1308: #if DBG
1309: DbgPrint("afm: PFM size greater than allocated.\n");
1310: #endif
1311: return;
1312: }
1313:
1314: pntfm->loszFullName = DWORDALIGN(sizeof(NTFM));
1315: pntfm->loszFontName = pntfm->loszFullName + DWORDALIGN(pdata->cbFullName);
1316: pntfm->loszFamilyName = pntfm->loszFontName + DWORDALIGN(pdata->cbFontName);
1317: pntfm->loKernPairs = pntfm->loszFamilyName +
1318: DWORDALIGN(pdata->cbFamilyName);
1319: pntfm->loCharMetrics = pntfm->loKernPairs + DWORDALIGN(cbKernPairs);
1320:
1321: if (pPFA)
1322: pntfm->loSoftFont = pntfm->loCharMetrics +
1323: DWORDALIGN(pntfm->cCharacters) + cbWidths;
1324:
1325: pntfm->loIFIMETRICS = pntfm->loCharMetrics +
1326: DWORDALIGN(pntfm->cCharacters) + cbWidths +
1327: DWORDALIGN(pntfm->cjSoftFont);
1328:
1329: pstr = (char *)pntfm + pntfm->loszFullName;
1330: memcpy(pstr, pdata->szTmpFullName, pdata->cbFullName);
1331: pstr += DWORDALIGN(pdata->cbFullName);
1332: memcpy(pstr, pdata->szTmpFontName, pdata->cbFontName);
1333: pstr += DWORDALIGN(pdata->cbFontName);
1334: memcpy(pstr, (char *)pdata->szTmpFamilyName, pdata->cbFamilyName);
1335: pstr += DWORDALIGN(pdata->cbFamilyName);
1336: memcpy(pstr, (char *)pdata->TmpKernPairs, cbKernPairs);
1337: pstr += DWORDALIGN(cbKernPairs);
1338: memcpy(pstr, (char *)pdata->TmpCharWidths, cbWidths);
1339: pstr += cbWidths;
1340: memcpy(pstr, (char *)pdata->TmpCharCodes, pntfm->cCharacters);
1341: pstr += DWORDALIGN(pntfm->cCharacters);
1342:
1343: #ifdef ALL_METRICS
1344: DbgPrint("FullName = %s\n", (char *)pntfm + pntfm->loszFullName);
1345: DbgPrint("FontName = %s\n", (char *)pntfm + pntfm->loszFontName);
1346: DbgPrint("FamilyName = %s\n", (char *)pntfm + pntfm->loszFamilyName);
1347: #endif
1348:
1349: // deal with the soft font, if there is one.
1350:
1351: if (pPFA)
1352: {
1353: // skip over the DWORD count.
1354:
1355: pPFA += sizeof(DWORD);
1356: memcpy(pstr, pPFA, cbPFA);
1357: pstr += DWORDALIGN(cbPFA);
1358: }
1359:
1360: // fill in the rest of the IFIMETRICS.
1361:
1362: CompleteIFIMETRICS(pdata);
1363:
1364: pntfm->cjThis += pdata->pTmpIFI->cjThis;
1365:
1366: // copy the IFIMETRICS stucture to the NTFM.
1367:
1368: memcpy(pstr, (CHAR *)pdata->pTmpIFI, pdata->pTmpIFI->cjThis);
1369: }
1370:
1371:
1372: //--------------------------------------------------------------------------
1373: //
1374: // VOID InitIFIMETRICS(pdata)
1375: // PPARSEDATA pdata;
1376: //
1377: // This routine initializes the IFIMETRICS structure with default values.
1378: //
1379: // Returns:
1380: // This routine returns no value.
1381: //
1382: // History:
1383: // 25-Mar-1993 -by- Kent Settle (kentse)
1384: // Wrote it.
1385: //--------------------------------------------------------------------------
1386:
1387: VOID InitIFIMETRICS(pdata)
1388: PPARSEDATA pdata;
1389: {
1390: PIFIMETRICS pTmpIFI;
1391:
1392: pTmpIFI = pdata->pTmpIFI;
1393:
1394: // initialize the size of the structure
1395: // we will have to add the size of added strings later
1396:
1397: pTmpIFI->cjThis = DWORDALIGN(sizeof(IFIMETRICS));
1398:
1399: pTmpIFI->ulVersion = FM_VERSION_NUMBER;
1400:
1401: pTmpIFI->jWinCharSet = ANSI_CHARSET; // !!! i guess
1402: pTmpIFI->jWinPitchAndFamily = FF_DONTCARE | VARIABLE_PITCH;// !!! i Guess
1403: pTmpIFI->flInfo = FM_INFO_ARB_XFORMS |
1404: FM_INFO_NOT_CONTIGUOUS |
1405: FM_INFO_TECH_OUTLINE_NOT_TRUETYPE |
1406: FM_INFO_1BBP |
1407: FM_INFO_RIGHT_HANDED;
1408: pTmpIFI->fsType = FM_NO_EMBEDDING;
1409: pTmpIFI->fwdUnitsPerEm = 1000; // for PostScript fonts.
1410: pTmpIFI->fwdLowestPPEm = 1; // !!!I guess [kirko]
1411:
1412: pTmpIFI->fwdCapHeight = 0; //!!![kirko] Kent-can you do better?
1413: pTmpIFI->fwdSubscriptXSize = 300; // !!! a guess
1414: pTmpIFI->fwdSubscriptYSize = 300; // !!! a guess
1415: pTmpIFI->fwdSubscriptXOffset = 600; // !!! a guess
1416: pTmpIFI->fwdSubscriptYOffset = -100; // !!! a guess
1417: pTmpIFI->fwdSuperscriptXSize = 300; // !!! a guess
1418: pTmpIFI->fwdSuperscriptYSize = 300; // !!! a guess
1419: pTmpIFI->fwdSuperscriptXOffset = 600; // !!! a guess
1420: pTmpIFI->fwdSuperscriptYOffset = 300; // !!! a guess
1421:
1422: pTmpIFI->wcBreakChar = U_SPACE;
1423: WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&pTmpIFI->wcBreakChar, 1,
1424: (LPSTR)&pTmpIFI->chBreakChar, 1, NULL, NULL);
1425:
1426: pTmpIFI->ptlBaseline.x = 1;
1427: pTmpIFI->ptlBaseline.y = 0;
1428: pTmpIFI->ptlAspect.x = 1;
1429: pTmpIFI->ptlAspect.y = 1;
1430: pTmpIFI->achVendId[0] = 'U';
1431: pTmpIFI->achVendId[1] = 'n';
1432: pTmpIFI->achVendId[2] = 'k';
1433: pTmpIFI->achVendId[3] = 'n';
1434: pTmpIFI->ulPanoseCulture = FM_PANOSE_CULTURE_LATIN;
1435: pTmpIFI->panose.bFamilyType = PAN_ANY;
1436: pTmpIFI->panose.bSerifStyle = PAN_ANY;
1437: pTmpIFI->panose.bProportion = PAN_ANY;
1438: pTmpIFI->panose.bContrast = PAN_ANY;
1439: pTmpIFI->panose.bStrokeVariation= PAN_ANY;
1440: pTmpIFI->panose.bArmStyle = PAN_ANY;
1441: pTmpIFI->panose.bLetterform = PAN_ANY;
1442: pTmpIFI->panose.bMidline = PAN_ANY;
1443: pTmpIFI->panose.bXHeight = PAN_ANY;
1444: }
1445:
1446:
1447:
1448: //--------------------------------------------------------------------------
1449: //
1450: // VOID CompleteIFIMETRICS(pdata)
1451: // PPARSEDATA pdata;
1452: //
1453: // This routine fill in IFIMETRICS values using NTFM values.
1454: //
1455: // Returns:
1456: // This routine returns no value.
1457: //
1458: // History:
1459: // 25-Mar-1993 -by- Kent Settle (kentse)
1460: // Wrote it.
1461: //--------------------------------------------------------------------------
1462:
1463: VOID CompleteIFIMETRICS(pdata)
1464: PPARSEDATA pdata;
1465: {
1466: PIFIMETRICS pTmpIFI;
1467: WINFONTPAIR *pTable;
1468: BOOL bFound;
1469: PSTR pstr;
1470: PNTFM pntfm;
1471: LONG InternalLeading;
1472:
1473: // get local pointers.
1474:
1475: pntfm = pdata->pntfm;
1476: pTmpIFI = pdata->pTmpIFI;
1477:
1478: // for Win31 compatability - if there is a match in WinFontTable for
1479: // the Adobe facename, use the Windows Face Name for the IFIMETRICS
1480: // family name, otherwise, use the Adobe family name.
1481:
1482: //!!! use nls conversion for this.
1483:
1484: pTable = (WINFONTPAIR *)WinFontTable;
1485: bFound = FALSE;
1486:
1487: while(pTable->pstrAdobeFace)
1488: {
1489: if (!(strncmp(pTable->pstrAdobeFace,
1490: (CHAR *)pntfm + pntfm->loszFontName, MAX_FONT_NAME)))
1491: {
1492: pstr = pTable->pstrWinFace;
1493: bFound = TRUE;
1494: break;
1495: }
1496:
1497: pTable++;
1498: }
1499:
1500: if (!bFound)
1501: pstr = (CHAR *)pntfm + pntfm->loszFamilyName;
1502:
1503: // WIN31 COMPATABILITY! Check to see if this face name has aliases.
1504: // if it does, then we need to set the FM_INFO_FAMILY_EQUIV bit of
1505: // pTmpIFI->flInfo, and fill in an array of family aliases.
1506:
1507: GetFamilyAliases(pTmpIFI, pstr);
1508:
1509: // make the style name the same as the family name.
1510:
1511: pTmpIFI->dpwszStyleName = pTmpIFI->dpwszFamilyName;
1512:
1513: // get the face name for the font.
1514:
1515: pTmpIFI->dpwszFaceName = pTmpIFI->cjThis;
1516:
1517: strcpy2WChar((PWSZ)((char *)pTmpIFI + pTmpIFI->dpwszFaceName),
1518: (PSZ)((char *)pntfm + pntfm->loszFontName));
1519:
1520: // while we have the face name, lets fill in the windows compatability
1521: // stuff.
1522:
1523: if (!strcmp((char *)pntfm + pntfm->loszFontName, "Symbol"))
1524: pTmpIFI->jWinCharSet = SYMBOL_CHARSET;
1525: else if (!strcmp((char *)pntfm + pntfm->loszFontName, "ZapfDingbats"))
1526: pTmpIFI->jWinCharSet = OEM_CHARSET;
1527: else
1528: pTmpIFI->jWinCharSet = ANSI_CHARSET;
1529:
1530: pTmpIFI->chFirstChar = (BYTE)0x20;
1531: pTmpIFI->chLastChar = (BYTE)0xFE;
1532:
1533: pTmpIFI->cjThis += ((wcslen((PWSZ)((char *)pTmpIFI +
1534: pTmpIFI->dpwszFaceName)) + 1) * sizeof(WCHAR));
1535:
1536: // get the unique name for the font.
1537:
1538: pTmpIFI->dpwszUniqueName = pTmpIFI->cjThis;
1539: strcpy2WChar((PWSZ)((char *)pTmpIFI + pTmpIFI->dpwszUniqueName),
1540: (PSZ)((char *)pntfm + pntfm->loszFullName));
1541: pTmpIFI->cjThis += ((wcslen((PWSZ)((char *)pTmpIFI +
1542: pTmpIFI->dpwszUniqueName)) + 1) * sizeof(WCHAR));
1543:
1544: pTmpIFI->dpFontSim = 0;
1545:
1546: pTmpIFI->fwdWinAscender = (FWORD) pntfm->rcBBox.top;
1547: pTmpIFI->fwdWinDescender = -(FWORD) pntfm->rcBBox.bottom;
1548: pTmpIFI->fwdMacAscender = pTmpIFI->fwdWinAscender;
1549: pTmpIFI->fwdMacDescender = -pTmpIFI->fwdWinDescender;
1550:
1551: // as windows does, set total leading to 19.6% of EmHeight.
1552: // therefore, ExternalLeading = 196 - InternalLeading.
1553:
1554: InternalLeading = (pntfm->rcBBox.top - pntfm->rcBBox.bottom) -
1555: ADOBE_FONT_UNITS;
1556:
1557: if (InternalLeading < 0)
1558: InternalLeading = 0;
1559:
1560: pTmpIFI->fwdMacLineGap = 196 - InternalLeading;
1561: if (pTmpIFI->fwdMacLineGap < 0)
1562: pTmpIFI->fwdMacLineGap = 0;
1563:
1564: pTmpIFI->fwdTypoLineGap = 0;
1565: pTmpIFI->fwdTypoAscender = pTmpIFI->fwdWinAscender;
1566: pTmpIFI->fwdTypoDescender = pTmpIFI->fwdWinDescender;
1567: pTmpIFI->fwdStrikeoutPosition = pTmpIFI->fwdWinAscender / 2;
1568:
1569: // hardcoded from mapping.h values.
1570:
1571: if (!(strcmp((char *) pntfm + pntfm->loszFontName, "ZapfDingbats")))
1572: {
1573: pTmpIFI->wcDefaultChar = U_SPACE;
1574: pTmpIFI->chDefaultChar = (BYTE)0x20;
1575: }
1576: else if (!(strcmp((char *) pntfm + pntfm->loszFontName, "Symbol")))
1577: {
1578: pTmpIFI->wcDefaultChar = U_SYMBOL_BULLET;
1579: pTmpIFI->chDefaultChar = (BYTE)0xB7;
1580: }
1581:
1582: else
1583: {
1584: pTmpIFI->wcDefaultChar = U_BULLET;
1585: pTmpIFI->chDefaultChar = (BYTE)0x8C;
1586: }
1587:
1588: WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&pTmpIFI->wcDefaultChar, 1,
1589: (LPSTR)&pTmpIFI->chDefaultChar, 1, NULL, NULL);
1590:
1591: pTmpIFI->cKerningPairs = pntfm->cKernPairs;
1592:
1593: // set the average and maximum character widths for the font.
1594:
1595: SetWidths(pdata);
1596:
1597: // find the first and last characters for the given font.
1598:
1599: GetFirstLastChar(pdata);
1600: }
1601:
1602:
1603: //--------------------------------------------------------------------------
1604: //
1605: // VOID GetFamilyAliases(pifi, pstr)
1606: // IFIMETRICS *pifi;
1607: // PSTR pstr;
1608: //
1609: // This routine fill in the family name of the IFIMETRICS structure.
1610: //
1611: // Returns:
1612: // This routine returns no value.
1613: //
1614: // History:
1615: // 25-Mar-1993 -by- Kent Settle (kentse)
1616: // Wrote it.
1617: //--------------------------------------------------------------------------
1618:
1619: VOID GetFamilyAliases(pifi, pstr)
1620: IFIMETRICS *pifi;
1621: PSTR pstr;
1622: {
1623: PSTR *pTable;
1624: PWSTR pwstr;
1625: DWORD cb;
1626:
1627: // assume no alias table found.
1628:
1629: pTable = (PSTR *)(NULL);
1630:
1631: // this is an ugly hardcoded Win31 Hack that we need to be compatible
1632: // with since some stupid apps have hardcoded font names.
1633:
1634: if (!(strcmp(pstr, "Times")))
1635: pTable = TimesAlias;
1636:
1637: else if (!(strcmp(pstr, "Helvetica")))
1638: pTable = HelveticaAlias;
1639:
1640: else if (!(strcmp(pstr, "Courier")))
1641: pTable = CourierAlias;
1642:
1643: else if (!(strcmp(pstr, "Helvetica-Narrow")))
1644: pTable = HelveticaNarrowAlias;
1645:
1646: else if (!(strcmp(pstr, "Palatino")))
1647: pTable = PalatinoAlias;
1648:
1649: else if (!(strcmp(pstr, "Bookman")))
1650: pTable = BookmanAlias;
1651:
1652: else if (!(strcmp(pstr, "NewCenturySchlbk")))
1653: pTable = NewCenturySBAlias;
1654:
1655: else if (!(strcmp(pstr, "AvantGarde")))
1656: pTable = AvantGardeAlias;
1657:
1658: else if (!(strcmp(pstr, "ZapfChancery")))
1659: pTable = ZapfChanceryAlias;
1660:
1661: else if (!(strcmp(pstr, "ZapfDingbats")))
1662: pTable = ZapfDingbatsAlias;
1663:
1664: // get offset to family name from start of IFIMETRICS structure.
1665:
1666: pifi->dpwszFamilyName = pifi->cjThis;
1667: pwstr = (PWSZ)((char *)pifi + pifi->dpwszFamilyName);
1668:
1669: if (pTable)
1670: {
1671: // set the pifi->flInfo flag.
1672:
1673: pifi->flInfo |= FM_INFO_FAMILY_EQUIV;
1674:
1675: // now fill in the array of alias family names.
1676:
1677: while (*pTable)
1678: {
1679: strcpy2WChar(pwstr, (PSTR)*pTable++);
1680: cb = ((wcslen(pwstr) + 1) * sizeof(WCHAR));
1681: pifi->cjThis += cb;
1682: pwstr += (cb >> 1);
1683: }
1684:
1685: // add the extra NULL terminator to the end of the array.
1686:
1687: *pwstr = (WCHAR)'\0';
1688: pifi->cjThis += sizeof(WCHAR);
1689: }
1690: else
1691: {
1692: // fill in the single family name.
1693:
1694: strcpy2WChar(pwstr, pstr);
1695: pifi->cjThis += ((wcslen(pwstr) + 1) * sizeof(WCHAR));
1696: }
1697: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.