![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fonttree.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / print / pscript|
Return to fonttree.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 root 1: //--------------------------------------------------------------------------
2: //
3: // Module Name: FONTTREE
4: //
5: // Brief Description: Device font tree querying routines
6: //
7: // Author: Kent Settle (kentse)
8: // Created: 18-Apr-1991
9: //
10: // Copyright (C) 1991 - 1992 Microsoft Corporation.
11: //
12: // This module contains DrvQueryFontTree.
13: //
14: // History:
15: // 18-Apr-1991 -by- Kent Settle (kentse)
16: // Created.
17: //--------------------------------------------------------------------------
18:
19: #include "pscript.h"
20: #include "enable.h"
21: #include "mapping.h"
22: #include <string.h>
23:
24: #define MAX_MAPSUBTABLES 256
25: #define MAX_GLYPHTABLES 16
26: #define MAX_GLYPHS 16
27:
28: PVOID BuildGLYPHSET(PDEVDATA, ULONG);
29: PVOID BuildKernPairs(PDEVDATA, ULONG);
30:
31: //--------------------------------------------------------------------------
32: // PVOID DrvQueryFontTree (dhpdev,iFile,iFace,iMode)
33: // DHPDEV dhpdev;
34: // ULONG iFile;
35: // ULONG iFace;
36: // ULONG iMode;
37: // ULONG *pid;
38: //
39: // This function is used by GDI to obtain pointers to tree structures that
40: // define one of the following.
41: //
42: // 1 The mapping from Unicode to glyph handles, including glyph
43: // variants;
44: // 2 The mapping of ligatures and their variants to glyph handles;
45: // 3 The mapping of kerning pairs to kerning handles.
46: //
47: // Parameters:
48: // dhpdev
49: // This is a PDEV handle returned from an earlier call to DrvEnablePDEV.
50: // iFile
51: // This identifies the font file (if device supports loading font files
52: // using the DDI).
53: // iFace
54: // This is the index of the driver font. The index of the first font
55: // is one.
56: // iMode
57: // This defines the type of information to be returned. This may take
58: // one of the following values:
59: //
60: // QFT_UNICODE GDI requests a pointer to a TREE_UNICODE structure
61: // that defines the mappings from single Unicode characters
62: // to glyph handles. This includes all glyph variants.
63: //
64: // QFT_LIGATURES GDI requests a pointer to a TREE_LIGATURES
65: // structure that defines the mapping from strings
66: // of Unicode characters to glyph handles. This
67: // includes all ligature variants.
68: //
69: // QFT_KERNPAIRS GDI requests a pointer to a TREE_KERNPAIRS
70: // structure that define the mappings from pairs
71: // of Unicode characters to kerning pair handles.
72: // These kerning handles are later passed to
73: // DrvQueryFontData to obtain kerning corrections.
74: //
75: // Returns:
76: // The return value is a pointer to the requested structure. This
77: // structure is to remain unchanged during the lifetime of the
78: // associated PDEV.
79: //
80: // Note: The following explanation was "borrowed" from lindsayh and the
81: // Generic driver.
82: //
83: // COMMENTS ON THE UNICODE TREE STRUCTURES:
84: // The following is intended to help understand the strange operations
85: // being done in the following function. UNICODE is a sparse encoding,
86: // so a tree structure is used to store the data. The following function
87: // produces a tree, the leaves of which are the GLYPH HANDLES that the
88: // engine passes to us to identify perticular glyphs. These handles are
89: // 32 bits long, contents up to the driver. We need to allocate storage
90: // for these and fill it in. The first step is to determine how much
91: // storage is needed. This requires understanding how the tree is built.
92: // The tree has 3 levels. At the top level there is a MAPTABLE
93: // structure. This has as many as 256 sub trees. These correspond to
94: // the 8 MSBs of the unicode value. This structure is folllowed by up to
95: // 256 PTRDIFFs (each a long). The structure itself contains a 256 byte
96: // array: this is an index into the array of PTRDIFFs following. Hence,
97: // there only needs to be as many PTRDIFFs as there are subtrees (plus 1,
98: // for the "no entry" value). For example, if there is only subtree,
99: // there need be only 2 PTRDIFFs - the active one, and a 0 entry. The
100: // byte array will mostly contain the index to the 0 entry, but the
101: // active entry will point at the other PTRDIFF.
102: //
103: // Each of the above active PTRDIFFs points to a MAPSUBTABLE. Each of
104: // these can handle 16 sub trees. It uses the same method as the MAPTABLE
105: // to handle sparseness - i.e. there is a 16 byte array containing
106: // indices into the array of PTRDIFFs following. The 16 byte array
107: // is indexed by the next 4 bits in the UNICODE value (i.e. the high
108: // nibble of the low byte). These PTRDIFFs point to GLYPHTABLEs,
109: // the next lower level in the tree.
110: //
111: // The final layer is the GLYPHTABLE data. Each of these contains
112: // up to 16 GLYPH HANDLEs, and is indexed by the 4 LSBs of the UNICODE
113: // value. Like the MAPSUBTABLE, there is a byte array containing
114: // index values of the glyph handles following.
115: //
116: // HOW MUCH MEMORY IS NEEDED??
117: // The tricky part is now determining how much memory to allocate for
118: // these structures. The answer is: a DWORD for each GLYPH HANDLE,
119: // as many GLYPHTABLEs as there are groups defined by the high order
120: // 12 bits of the UNICODE value (i.e., up to 4096), as many MAPSUBTABLES
121: // as there are groups of 16 GLYPHTABLES (up to 256), plus a MAPTABLE
122: // to amalgamate the top level. As well, the MAPTABLE and MAPSUBTABLE
123: // require PTRDIFFs to the lower level - this is as many as there are
124: // lower level entities.
125: //
126: // Determining this is done as follows: allocate a 64k BIT array,
127: // considered as an array of 4096 WORDS (16 bits each). For every
128: // available glyph, set the corresponding bit in the array, and
129: // increment a counter. At the end of this stage, we have a count of
130: // the number of (non-zero) GLYPH HANDLES needed. Now, by scanning
131: // the bit array by WORD, count each non-zero word. This tells us
132: // how many GLYPHTABLEs are required. A second bit array is also
133: // updated at this time. This array consists of 256 bits, one for
134: // each of the possible entries in the MAPTABLE. Passing through the
135: // WORD array, we can also set bits in the 256 bit array corresponding
136: // to the number of MAPTABLES required. Finally, counting the number
137: // of set bits in the 256 bit array gives us the number of MAPTABLES
138: // required. Given this information, it is possible to determine
139: // the amount of storage required. Note that it is necessary to allow
140: // for a 0 entry in the PTRDIFF and HGLYPH arrays.
141: //
142: // If an error occurs, NULL should be returned and an error code should
143: // be logged.
144: //
145: // History:
146: // 18-Apr-1991 -by- Kent Settle (kentse)
147: // Wrote it.
148: //--------------------------------------------------------------------------
149:
150: PVOID DrvQueryFontTree (dhpdev,iFile,iFace,iMode,pid)
151: DHPDEV dhpdev;
152: ULONG iFile;
153: ULONG iFace;
154: ULONG iMode;
155: ULONG *pid;
156: {
157: PDEVDATA pdev;
158:
159: UNREFERENCED_PARAMETER(iFile);
160:
161: // This can be used by the driver to flag or id the data returned.
162: // May be useful for deletion of the data later by DrvFree().
163:
164: *pid = 0; // don't need to use for this driver
165:
166: // get a pointer to our PDEV.
167:
168: pdev = (PDEVDATA)dhpdev;
169:
170: if (bValidatePDEV(pdev) == FALSE)
171: {
172: RIP("PSCRIPT!DrvQueryFontTree: invalid PDEV.");
173: SetLastError(ERROR_INVALID_PARAMETER);
174: return((PVOID)NULL);
175: }
176:
177: // validate the iFace. we should only be called for device fonts,
178: // ie iFace >= 1.
179:
180: if ((iFace < 1) || (iFace > (pdev->cDeviceFonts + pdev->cSoftFonts)))
181: {
182: RIP("PSCRPT!BuildGLYPHSET: invalid iFace.\n");
183: SetLastError(ERROR_INVALID_PARAMETER);
184: return((PVOID)NULL);
185: }
186:
187: switch (iMode)
188: {
189: case QFT_GLYPHSET:
190: return(BuildGLYPHSET(pdev, iFace));
191: break;
192:
193: case QFT_KERNPAIRS:
194: return(BuildKernPairs(pdev, iFace));
195: break;
196:
197: default:
198: RIP("PSCRIPT!DrvQueryFontTree: invalid iMode.\n");
199: SetLastError(ERROR_INVALID_PARAMETER);
200: return((PVOID)NULL);
201: }
202: }
203:
204: //--------------------------------------------------------------------------
205: // PVOID BuildGLYPHSET(pdev, iFace)
206: // PDEVDATA pdev;
207: // ULONG iFace;
208: //
209: // If an error occurs, NULL should be returned and an error code should
210: // be logged.
211: //
212: // History:
213: // 10-Feb-1992 -by- Kent Settle (kentse)
214: // Borrowed some of if from RASDD, wrote the rest.
215: //--------------------------------------------------------------------------
216:
217: PVOID BuildGLYPHSET(pdev, iFace)
218: PDEVDATA pdev;
219: ULONG iFace;
220: {
221: PNTFM pntfm; // pointer to font metrics.
222: PUCMap pmap; // pointer to UNICODE<->PSCRIPT mapping table.
223: PUCMap pmapReset; // place to save pointer.
224: DWORD i; // loop counter.
225: PBYTE pCharCode; // pointer to character code.
226: PBYTE pCharReset; // place to save pointer.
227: WCHAR wchCurrent; // current UNICODE value.
228: WCHAR wchPrevious; // previous UNICODE value.
229: DWORD cGlyphs; // count of glyph handles.
230: DWORD cRuns; // count of runs within FD_GLYPHSET.
231: DWORD cbTotalMem; // count of bytes needed for FD_GLYPHSET.
232: HGLYPH *phg; // pointer to HGLYPH's.
233: FD_GLYPHSET *pGLYPHSET; // pointer to FD_GLYPHSET.
234: WCRUN *pWCRUN; // pointer to WCRUN.
235: PULONG pulUCTree; // pointer to UNICODE tree.
236:
237: // get the font information for the given font.
238:
239: pntfm = pdev->pfmtable[iFace - 1].pntfm;
240:
241: // point to the appropriate mapping table in mapping.h.
242:
243: if (!strcmp((char *)pntfm + pntfm->loszFontName, "Symbol"))
244: pmap = SymbolMap;
245:
246: else if (!strcmp((char *)pntfm + pntfm->loszFontName, "ZapfDingbats"))
247: pmap = DingbatsMap;
248: else
249: pmap = LatinMap;
250:
251: pmapReset = pmap;
252:
253: // for every character in the mapping table, do a lookup in the NTFM
254: // structure to find a matching PostScript character code. For each
255: // character found, we can extract the corresponding UNICODE value.
256: // remember that the character codes are sitting in a BYTE array
257: // which is sitting directly after a (USHORT) array of character
258: // widths.
259:
260: pCharCode = ((PBYTE)pntfm + pntfm->loCharMetrics +
261: DWORDALIGN(pntfm->cCharacters * sizeof(USHORT)));
262:
263: // save the original pointer.
264:
265: pCharReset = pCharCode;
266:
267: cRuns = 1; // there must be at least one run!
268: cGlyphs = 0;
269:
270: // set wchPrevious equal to first UNICODE character code.
271:
272: wchPrevious = (WCHAR)pmap->usUCValue;
273:
274: while (pmap->szChar)
275: {
276: for (i = 0; i < (DWORD)pntfm->cCharacters; i++)
277: {
278: // search through all the characters in the NTFM structure,
279: // looking for a matching PostScript character code. remember
280: // that the high bit is used to indicate the font needs
281: // to be remapped. so ignore the high bit while checking
282: // for a character match.
283:
284: if ((CHAR)*pCharCode == (CHAR)pmap->usPSValue)
285: {
286: // we have found the character, now get its UNICODE value
287: // and set its BIT in the BIT array. also, increment the
288: // glyph count, if this UNICODE value has not yet been used.
289: // since the mapping tables in mapping.h are sorted by
290: // UNICODE values, we can simply check this value against
291: // the one we found last time. if it is the same, ignore
292: // it, if it is different, use it.
293:
294: wchCurrent = (WCHAR)pmap->usUCValue;
295:
296: if (wchCurrent != wchPrevious)
297: {
298: cGlyphs++;
299:
300: // see if we are starting new run.
301:
302: if ((wchCurrent - wchPrevious) != 1)
303: cRuns++;
304: }
305:
306: wchPrevious = wchCurrent;
307: break;
308: }
309:
310: pCharCode++;
311: }
312:
313: // point back to start of character list in NTFM structure.
314:
315: pCharCode = pCharReset;
316:
317: // point to next character in mapping table.
318:
319: pmap++;
320: }
321:
322: // allocate memory to build the FD_GLYPHSET structure in. this
323: // include space for the FD_GLYPHSET structure itself, as well
324: // as space for all the glyph handles.
325:
326: cbTotalMem = (cGlyphs * sizeof(HGLYPH)) + (cRuns * sizeof(WCRUN)) +
327: sizeof(FD_GLYPHSET) - sizeof(WCRUN);
328:
329: // DWORD bound it.
330:
331: cbTotalMem = (cbTotalMem + 3) & ~3;
332:
333: // this memory is to be kept around until the pdev is destroyed, so
334: // we don't have to free this memory until the heap is destroyed.
335:
336: phg = pulUCTree = (PVOID)HeapAlloc(pdev->hheap, 0, cbTotalMem);
337:
338: if (phg == NULL)
339: {
340: RIP("PSCRIPT!BuildGLYPHSET: HeapAlloc for phg failed.\n");
341: return((PVOID)NULL);
342: }
343:
344: // fill in the FD_GLYPHSET structure.
345:
346: pGLYPHSET = (FD_GLYPHSET *)phg;
347:
348: pGLYPHSET->cjThis = sizeof(FD_GLYPHSET) + (cRuns - 1) * sizeof(WCRUN);
349: pGLYPHSET->flAccel = 0; // no accelerators for us.
350: pGLYPHSET->cGlyphsSupported = cGlyphs;
351: pGLYPHSET->cRuns = cRuns;
352:
353: // now set the phg pointer to the first WCRUN structure.
354:
355: (BYTE *)phg += sizeof(FD_GLYPHSET) - sizeof(WCRUN);
356:
357: // point to first WCRUN in array.
358:
359: pWCRUN = (WCRUN *)phg;
360:
361: // point to data area for glyph handles.
362:
363: (BYTE *)phg += sizeof(WCRUN) * cRuns;
364:
365: // for every character in the font, do a lookup in the mapping
366: // table in mapping.h to find the corresponding UNICODE value.
367: // first point to the character codes in the NTFM structure.
368: // remember that the character codes are sitting in a BYTE array
369: // which is sitting directly after a (USHORT) array of character
370: // widths.
371:
372: pCharCode = pCharReset;
373: pmap = pmapReset;
374:
375: // locate the first glyph, and initialize the first WCRUN.
376:
377: for (i = 0; i < (DWORD)pntfm->cCharacters; i++)
378: {
379: // search for the matching code in mapping.h. remember
380: // that the high bit is used to indicate the font needs
381: // to be remapped. so ignore the high bit while checking
382: // for a character match.
383:
384: if ((CHAR)*pCharCode == (CHAR)pmap->usPSValue)
385: {
386: // we have found the character, now get its UNICODE value
387: // and set its BIT in the BIT array. also, increment the
388: // glyph count, if this UNICODE value has not yet been used.
389: // since the mapping tables in mapping.h are sorted by
390: // UNICODE values, we can simply check this value against
391: // the one we found last time. if it is the same, ignore
392: // it, if it is different, use it.
393:
394: wchPrevious = (WCHAR)pmap->usUCValue;
395:
396: pWCRUN->wcLow = wchPrevious;
397: pWCRUN->cGlyphs = 1;
398: pWCRUN->phg = phg;
399:
400: // store the glyph handle, which we will store as the
401: // PostScript character code.
402:
403: *phg++ = (HGLYPH)*pCharCode;
404:
405: break;
406: }
407:
408: // point to the next character in the NTFM structure.
409:
410: pCharCode++;
411: }
412:
413: // move to the second character in the mapping table.
414:
415: pmap++;
416:
417: while (pmap->szChar)
418: {
419: // reset pointer to start of character list in NTFM structure.
420:
421: pCharCode = pCharReset;
422:
423: for (i = 0; i < ((DWORD)pntfm->cCharacters - 1); i++)
424: {
425: // search for the matching code in mapping.h. remember
426: // that the high bit is used to indicate the font needs
427: // to be remapped. so ignore the high bit while checking
428: // for a character match.
429:
430: if ((CHAR)*pCharCode == (CHAR)pmap->usPSValue)
431: {
432: // we have found the character, now get its UNICODE value
433: // and set its BIT in the BIT array. also, increment the
434: // glyph count, if this UNICODE value has not yet been used.
435: // since the mapping tables in mapping.h are sorted by
436: // UNICODE values, we can simply check this value against
437: // the one we found last time. if it is the same, ignore
438: // it, if it is different, use it.
439:
440: wchCurrent = (WCHAR)pmap->usUCValue;
441:
442: if (wchCurrent != wchPrevious)
443: {
444: // see if we are starting a new run.
445:
446: if ((wchCurrent - wchPrevious) != 1)
447: {
448: // start the new WCRUN.
449:
450: pWCRUN++;
451: pWCRUN->wcLow = wchCurrent;
452: pWCRUN->cGlyphs = 0;
453: pWCRUN->phg = phg;
454: }
455:
456: // fill in the glyph handle.
457:
458: pWCRUN->cGlyphs++;
459: *phg++ = (HGLYPH)*pCharCode;
460: }
461:
462: wchPrevious = wchCurrent;
463: break;
464: }
465:
466: pCharCode++;
467: }
468:
469: // point to next character in mapping table.
470:
471: pmap++;
472: }
473:
474: return(pulUCTree);
475: }
476:
477:
478: //--------------------------------------------------------------------------
479: // PVOID BuildKernPairs(pdev, iFace)
480: // PDEVDATA pdev;
481: // ULONG iFace;
482: //
483: // This routine returns a pointer to a zero terminated array of
484: // FD_KERNINGPAIR structures. They should be sorted in order such that
485: // the first character is the most significant, and the second character
486: // is the least.
487: //
488: // If an error occurs, NULL should be returned and an error code should
489: // be logged.
490: //
491: // History:
492: // 12-Mar-1992 -by- Kent Settle (kentse)
493: // Wrote it.
494: //--------------------------------------------------------------------------
495:
496: PVOID BuildKernPairs(pdev, iFace)
497: PDEVDATA pdev;
498: ULONG iFace;
499: {
500: PNTFM pntfm; // pointer to font metrics.
501: FD_KERNINGPAIR *pKernPairs; // pointer to FD_KERNINGPAIRs.
502: FD_KERNINGPAIR *pKernPairsSave; // pointer to FD_KERNINGPAIRs.
503: DWORD cjMem; // count of bytes.
504: DWORD cKernPairs; // cound of kernpairs.
505: FD_KERNINGPAIR *pkp; // pointer to kernpair in ntfm struct.
506:
507: // get the font information for the given font.
508:
509: pntfm = pdev->pfmtable[iFace - 1].pntfm;
510:
511: // allocate enough memory to hold all the FD_KERNINGPAIR strutures.
512: // remember to allocate room for the zero terminated structure.
513: // NOTE! the memory allocated here is never explicitly freed. this
514: // will happen when the pdev, and therefore the heap, is destroyed.
515: // this is done, since this memory is supposed to remain here for
516: // the engine until the pdev is destroyed.
517:
518: cKernPairs = (DWORD)pntfm->cKernPairs;
519: cjMem = ((cKernPairs + 1) * sizeof(FD_KERNINGPAIR));
520:
521: if (!(pKernPairs = (FD_KERNINGPAIR *)HeapAlloc(pdev->hheap, 0, cjMem)))
522: {
523: RIP("PSCRIPT!BuildKernPairs: HeapAlloc for pKernPairs failed.\n");
524: return((PVOID)NULL);
525: }
526:
527: // save a copy of the original pointer.
528:
529: pKernPairsSave = pKernPairs;
530:
531: // fill in the FD_KERNINGPAIR structure for each kerning pair.
532:
533: pkp = (FD_KERNINGPAIR *)((BYTE *)pntfm + pntfm->loKernPairs);
534:
535: while (cKernPairs--)
536: *pKernPairs++ = *pkp++;
537:
538: // fill in the zero terminating FD_KERNINGPAIR structure.
539:
540: pKernPairs->wcFirst = (WCHAR)'\0';
541: pKernPairs->wcSecond = (WCHAR)'\0';
542: pKernPairs->fwdKern = (FWORD)0;
543:
544: return(pKernPairsSave);
545: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.