![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fntmanag.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 fntmanag.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 ! root 1: //-------------------------------------------------------------------------- ! 2: // ! 3: // Module Name: FNTMANAG.C ! 4: // ! 5: // Brief Description: This module contains the PSCRIPT driver's ! 6: // DrvFontManagement function and related routines. ! 7: // ! 8: // Author: Kent Settle (kentse) ! 9: // Created: 07-May-1993 ! 10: // ! 11: // Copyright (c) 1993 Microsoft Corporation ! 12: //-------------------------------------------------------------------------- ! 13: ! 14: #include "stdlib.h" ! 15: #include <string.h> ! 16: #include "pscript.h" ! 17: #include "enable.h" ! 18: #include "winbase.h" ! 19: ! 20: // declarations of external routines. ! 21: ! 22: extern LONG iHipot(LONG, LONG); ! 23: extern DWORD PSFIXToBuffer(CHAR *, PS_FIX); ! 24: ! 25: // declarations of routines residing within this module. ! 26: ! 27: BOOL ForceLoadFont(PDEVDATA, FONTOBJ *, DWORD, HGLYPH *); ! 28: BOOL GrabFaceName(PDEVDATA, FONTOBJ *, CHAR *, DWORD); ! 29: PS_FIX GetPointSize(PDEVDATA, FONTOBJ *, XFORM *); ! 30: BOOL DownloadANSIBitmapFont(PDEVDATA, FONTOBJ *, HGLYPH *); ! 31: BOOL SendCharBitmap(PDEVDATA, FONTOBJ *, HGLYPH, DWORD, BOOL); ! 32: ! 33: //-------------------------------------------------------------------------- ! 34: // BOOL DrvFontManagement(pfo, iType, pvIn, cjIn, pvOut, cjOut) ! 35: // FONTOBJ *pfo; ! 36: // DWORD iType; ! 37: // PVOID pvIn; ! 38: // DWORD cjIn; ! 39: // PVOID pvOut; ! 40: // DWORD cjOut; ! 41: // ! 42: // This routine handles multiple font management related functions, ! 43: // depending on iType. ! 44: // ! 45: // Parameters: ! 46: // pdev ! 47: // Pointer to our DEVDATA structure. ! 48: // ! 49: // Returns: ! 50: // This routine returns no value. ! 51: // ! 52: // History: ! 53: // 26-Apr-1991 -by- Kent Settle (kentse) ! 54: // Wrote it. ! 55: //-------------------------------------------------------------------------- ! 56: ! 57: ULONG DrvFontManagement(pso, pfo, iType, cjIn, pvIn, cjOut, pvOut) ! 58: SURFOBJ *pso; ! 59: FONTOBJ *pfo; ! 60: DWORD iType; ! 61: DWORD cjIn; ! 62: PVOID pvIn; ! 63: DWORD cjOut; ! 64: PVOID pvOut; ! 65: { ! 66: PDEVDATA pdev; ! 67: ! 68: // pso may be NULL if QUERYESCSUPPORT. ! 69: ! 70: if (iType != QUERYESCSUPPORT) ! 71: { ! 72: // get the pointer to our DEVDATA structure and make sure it is ours. ! 73: ! 74: pdev = (PDEVDATA) pso->dhpdev; ! 75: ! 76: if (bValidatePDEV(pdev) == FALSE) ! 77: { ! 78: RIP("PSCRIPT!DrvFontManagement: invalid pdev.\n"); ! 79: SetLastError(ERROR_INVALID_PARAMETER); ! 80: return(FALSE); ! 81: } ! 82: } ! 83: ! 84: // handle the different cases. ! 85: ! 86: switch (iType) ! 87: { ! 88: case QUERYESCSUPPORT: ! 89: // when querying escape support, the function in question is ! 90: // passed in the ULONG passed in pvIn. ! 91: ! 92: switch (*(PULONG)pvIn) ! 93: { ! 94: case QUERYESCSUPPORT: ! 95: case DOWNLOADFACE: ! 96: case GETFACENAME: ! 97: return(1); ! 98: ! 99: default: ! 100: // return 0 if the escape in question is not supported. ! 101: ! 102: return(0); ! 103: } ! 104: ! 105: case DOWNLOADFACE: ! 106: // call ForceLoadFont to do the work. ! 107: ! 108: return(ForceLoadFont(pdev, pfo, cjIn, (PHGLYPH)pvIn)); ! 109: ! 110: case GETFACENAME: ! 111: // call GrabFaceName to do the work. ! 112: ! 113: return(GrabFaceName(pdev, pfo, (CHAR *)pvOut, cjOut)); ! 114: ! 115: default: ! 116: return(FALSE); ! 117: } ! 118: return(TRUE); ! 119: } ! 120: ! 121: ! 122: //-------------------------------------------------------------------- ! 123: // BOOL ForceLoadFont(pdev, pfo) ! 124: // PDEVDATA pdev; ! 125: // FONTOBJ *pfo; ! 126: // ! 127: // This routine downloads the specified font to the printer, no ! 128: // questions asked. ! 129: // ! 130: // History: ! 131: // 07-May-1993 -by- Kent Settle (kentse) ! 132: // Wrote it. ! 133: //-------------------------------------------------------------------- ! 134: ! 135: BOOL ForceLoadFont(pdev, pfo, cjIn, phglyphs) ! 136: PDEVDATA pdev; ! 137: FONTOBJ *pfo; ! 138: DWORD cjIn; ! 139: HGLYPH *phglyphs; ! 140: { ! 141: PNTFM pntfm; ! 142: BYTE *pSoftFont; ! 143: BOOL bDeviceFont; ! 144: XFORM fontxform; ! 145: PS_FIX psfxScaleFactor; ! 146: BOOL bProcSet; ! 147: ! 148: // make sure we have our hglyph => ANSI translation table. ! 149: // the table consists of 256 HGLYPHS, plus two WORDS at the ! 150: // beginning. The first WORD states whether to always download ! 151: // the font, or just if it has not yet been done. The second ! 152: // WORD is simply padding for alignment. ! 153: ! 154: if (cjIn < (sizeof(HGLYPH) * 257)) ! 155: { ! 156: RIP("PSCRIPT!ForceLoadFont: invalid cjIn.\n"); ! 157: SetLastError(ERROR_INVALID_PARAMETER); ! 158: return(FALSE); ! 159: } ! 160: // get the point size, and fill in the font xform. ! 161: ! 162: psfxScaleFactor = GetPointSize(pdev, pfo, &fontxform); ! 163: ! 164: // is this a device font? ! 165: ! 166: bDeviceFont = (pfo->flFontType & DEVICE_FONTTYPE); ! 167: ! 168: // select the proper font name for the new font. if this is a ! 169: // device font, get the name from the NTFM structure. if this ! 170: // is a GDI font that we are caching, we will create a name for ! 171: // it at the time we download it to the printer. ! 172: ! 173: if (bDeviceFont) ! 174: { ! 175: // get the font metrics for the specified font. ! 176: ! 177: pntfm = pdev->pfmtable[pfo->iFace - 1].pntfm; ! 178: ! 179: // !!! NOTE NOTE the following assumption is invalid. I need to look at the ! 180: // !!! first word of phglyph to decide whether to always download the font or ! 181: // !!! only download it if it has not yet been downloaded. ! 182: ! 183: //!!! I am writing this with the assumption, that the application will worry ! 184: //!!! about printer memory. In other words, I will just blindly download ! 185: //!!! a font when I am told to, and not worry about killing the printer. ! 186: //!!! Is this a valid assumption??? ! 187: ! 188: //!!! I am also assuming that I do not have to keep track of which fonts ! 189: //!!! have been downloaded. ! 190: ! 191: // if the font is a softfont, download it. ! 192: ! 193: if (pfo->iFace > pdev->cDeviceFonts) ! 194: { ! 195: pSoftFont = (BYTE *)pntfm + pntfm->loSoftFont; ! 196: ! 197: // we need to make sure that our header does not get downloaded ! 198: // by bPSWrite ! 199: ! 200: // note whether or not the procset has already been sent. ! 201: ! 202: if (pdev->dwFlags & PDEV_PROCSET) ! 203: bProcSet = TRUE; ! 204: else ! 205: { ! 206: pdev->dwFlags |= PDEV_PROCSET; ! 207: bProcSet = FALSE; ! 208: } ! 209: ! 210: ! 211: if (!bPSWrite(pdev, pSoftFont, pntfm->cjSoftFont)) ! 212: { ! 213: RIP("PSCRIPT!SelectFont: downloading of softfont failed.\n"); ! 214: return(FALSE); ! 215: } ! 216: ! 217: // if the procset was not sent, then clear the flag. ! 218: ! 219: if (!bProcSet) ! 220: pdev->dwFlags &= ~PDEV_PROCSET; ! 221: } ! 222: } ! 223: else // must be a GDI font we will be caching. ! 224: { ! 225: // we need to make sure that our header does not get downloaded ! 226: // by DownloadANSIBitmapFont. ! 227: ! 228: // note whether or not the procset has already been sent. ! 229: ! 230: if (pdev->dwFlags & PDEV_PROCSET) ! 231: bProcSet = TRUE; ! 232: else ! 233: { ! 234: pdev->dwFlags |= PDEV_PROCSET; ! 235: bProcSet = FALSE; ! 236: } ! 237: ! 238: //!!! the engine is not ready for outline fonts yet!!! -kentse. ! 239: #if 0 ! 240: // if this font has not yet been downloaded to the printer, ! 241: // do it now. ! 242: ! 243: if (pfo->flFontType & TRUETYPE_FONTTYPE) ! 244: { ! 245: // determine the point size. ! 246: ! 247: ulPointSize = (ETOL(fontxform.eM22 * 72000) / ! 248: pdev->psdm.dm.dmPrintQuality); ! 249: ! 250: if (ulPointSize < 10) ! 251: DownloadANSIBitmapFont(pdev, pfo, phglyphs); ! 252: else ! 253: DownloadOutlineFont(pdev, pfo); ! 254: } ! 255: else if (pfo->flFontType & RASTER_FONTTYPE) ! 256: DownloadANSIBitmapFont(pdev, pfo, phglyphs); ! 257: #endif ! 258: if ( (pfo->flFontType & TRUETYPE_FONTTYPE) || ! 259: (pfo->flFontType & RASTER_FONTTYPE) ) ! 260: DownloadANSIBitmapFont(pdev, pfo, phglyphs); ! 261: else ! 262: { ! 263: RIP("PSCRIPT!SelectFont: invalid pfo->flFontType.\n"); ! 264: return(FALSE); ! 265: } ! 266: ! 267: // if the procset was not sent, then clear the flag. ! 268: ! 269: if (!bProcSet) ! 270: pdev->dwFlags &= ~PDEV_PROCSET; ! 271: } ! 272: ! 273: return(TRUE); ! 274: } ! 275: ! 276: ! 277: //-------------------------------------------------------------------- ! 278: // BOOL GrabFaceName(pdev, pfo, pbuffer, cb) ! 279: // PDEVDATA pdev; ! 280: // FONTOBJ *pfo; ! 281: // CHAR *pbuffer; ! 282: // DWORD cb; ! 283: // ! 284: // This routine returns the driver's internal facename (ie the name ! 285: // which is sent to the printer) to the caller. pbuffer, is filled ! 286: // in with the face name, being sure to not write more than cb bytes ! 287: // to the buffer. ! 288: // ! 289: // History: ! 290: // 07-May-1993 -by- Kent Settle (kentse) ! 291: // Wrote it. ! 292: //-------------------------------------------------------------------- ! 293: ! 294: BOOL GrabFaceName(pdev, pfo, pbuffer, cb) ! 295: PDEVDATA pdev; ! 296: FONTOBJ *pfo; ! 297: CHAR *pbuffer; ! 298: DWORD cb; ! 299: { ! 300: PNTFM pntfm; ! 301: BOOL bDeviceFont; ! 302: PIFIMETRICS pifi; ! 303: XFORM fontxform; ! 304: PS_FIX psfxScaleFactor; ! 305: PWSTR pwstr; ! 306: DWORD cTmp; ! 307: CHAR szFaceName[MAX_STRING]; ! 308: PSZ pszFaceName; ! 309: ! 310: // get the point size, and fill in the font xform. ! 311: ! 312: psfxScaleFactor = GetPointSize(pdev, pfo, &fontxform); ! 313: ! 314: // is this a device font? ! 315: ! 316: bDeviceFont = (pfo->flFontType & DEVICE_FONTTYPE); ! 317: ! 318: // select the proper font name for the new font. if this is a ! 319: // device font, get the name from the NTFM structure. if this ! 320: // is a GDI font that we are caching, we will create a name for ! 321: // it at the time we download it to the printer. ! 322: ! 323: if (bDeviceFont) ! 324: { ! 325: // get the font metrics for the specified font. ! 326: ! 327: pntfm = pdev->pfmtable[pfo->iFace - 1].pntfm; ! 328: ! 329: // copy the font name to the buffer. ! 330: ! 331: strncpy(pbuffer, (char *)pntfm + pntfm->loszFontName, cb); ! 332: } ! 333: else // must be a GDI font we will be caching. ! 334: { ! 335: if ( (pfo->flFontType & TRUETYPE_FONTTYPE) || ! 336: (pfo->flFontType & RASTER_FONTTYPE) ) ! 337: { ! 338: // create the ASCII name for this font which will get used ! 339: // to select this font in the printer. ! 340: ! 341: if (!(pifi = FONTOBJ_pifi(pfo))) ! 342: { ! 343: RIP("PSCRIPT!SelectFont: pifi failed.\n"); ! 344: return(FALSE); ! 345: } ! 346: ! 347: pwstr = (PWSTR)((BYTE *)pifi + pifi->dpwszFaceName); ! 348: cTmp = wcslen(pwstr); ! 349: ! 350: // get the font name from the UNICODE font name. ! 351: ! 352: memset(szFaceName, 0, sizeof(szFaceName)); ! 353: pszFaceName = szFaceName; ! 354: ! 355: while (cTmp--) ! 356: { ! 357: *pszFaceName = (CHAR)*pwstr++; ! 358: ! 359: // replace any spaces in the font name with underscores. ! 360: ! 361: if (*pszFaceName == ' ') ! 362: *pszFaceName = '_'; ! 363: ! 364: // replace any parens in the font name with asterisks. ! 365: ! 366: if ((*pszFaceName == '(') || (*pszFaceName == ')')) ! 367: *pszFaceName = '*'; ! 368: ! 369: // point to the next character. ! 370: ! 371: *pszFaceName++; ! 372: } ! 373: ! 374: // add the point size to the font name, so we can distinguish ! 375: // different point sizes of the same font. ! 376: ! 377: cTmp = PSFIXToBuffer(pszFaceName, psfxScaleFactor); ! 378: ! 379: // update the buffer pointer. ! 380: ! 381: pszFaceName += cTmp; ! 382: ! 383: // output the NULL terminator. ! 384: ! 385: *pszFaceName = '\0'; ! 386: ! 387: // copy to the output buffer. ! 388: ! 389: strncpy(pbuffer, szFaceName, cb); ! 390: } ! 391: else ! 392: { ! 393: RIP("PSCRIPT!GrabFaceName: invalid pfo->flFontType.\n"); ! 394: return(FALSE); ! 395: } ! 396: } ! 397: } ! 398: ! 399: ! 400: //-------------------------------------------------------------------- ! 401: // PS_FIX GetPointSize(pdev, pfo, pxform) ! 402: // PDEVDATA pdev; ! 403: // FONTOBJ *pfo; ! 404: // XFORM *pxform; ! 405: // ! 406: // This routine returns the point size for the specified font. ! 407: // ! 408: // History: ! 409: // 11-May-1993 -by- Kent Settle (kentse) ! 410: // Broke out into a separate routine. ! 411: //-------------------------------------------------------------------- ! 412: ! 413: PS_FIX GetPointSize(pdev, pfo, pxform) ! 414: PDEVDATA pdev; ! 415: FONTOBJ *pfo; ! 416: XFORM *pxform; ! 417: { ! 418: XFORMOBJ *pxo; ! 419: ULONG ulComplex; ! 420: BOOL bDeviceFont; ! 421: POINTFIX ptfx; ! 422: POINTL ptl; ! 423: FIX fxVector; ! 424: IFIMETRICS *pifi; ! 425: PS_FIX psfxPointSize; ! 426: ! 427: // get the Notional to Device transform. this is needed to ! 428: // determine the point size. ! 429: ! 430: pxo = FONTOBJ_pxoGetXform(pfo); ! 431: ! 432: if (pxo == NULL) ! 433: { ! 434: RIP("PSCRIPT!GrabFaceName: pxo == NULL.\n"); ! 435: return((PS_FIX)-1); ! 436: } ! 437: ! 438: ulComplex = XFORMOBJ_iGetXform(pxo, pxform); ! 439: ! 440: bDeviceFont = (pfo->flFontType & DEVICE_FONTTYPE); ! 441: ! 442: // determine the notional space point size of the new font. ! 443: ! 444: if (bDeviceFont) ! 445: { ! 446: // PSCRIPT font's em height is hardcoded to be 1000 (see quryfont.c). ! 447: ! 448: pdev->cgs.fwdEmHeight = ADOBE_FONT_UNITS; ! 449: } ! 450: else ! 451: { ! 452: // If its not a device font, we'll have to call back and ask. ! 453: ! 454: if (!(pifi = FONTOBJ_pifi(pfo))) ! 455: { ! 456: RIP("PSCRIPT!SelectFont: pifi failed.\n"); ! 457: return((PS_FIX)-1); ! 458: } ! 459: ! 460: pdev->cgs.fwdEmHeight = pifi->fwdUnitsPerEm; ! 461: } ! 462: ! 463: // apply the notional to device transform. ! 464: ! 465: ptl.x = 0; ! 466: ptl.y = pdev->cgs.fwdEmHeight; ! 467: ! 468: XFORMOBJ_bApplyXform(pxo, XF_LTOFX, 1, &ptl, &ptfx); ! 469: ! 470: // now get the length of the vector. ! 471: ! 472: fxVector = iHipot(ptfx.x, ptfx.y); ! 473: ! 474: // make it a PS_FIX 24.8 number. ! 475: ! 476: fxVector <<= 4; ! 477: ! 478: psfxPointSize = (PS_FIX)(MulDiv(fxVector, PS_RESOLUTION, ! 479: pdev->psdm.dm.dmPrintQuality)); ! 480: ! 481: return(psfxPointSize); ! 482: } ! 483: ! 484: //-------------------------------------------------------------------- ! 485: // BOOL DownloadANSIBitmapFont(pdev, pfo, phglyphs) ! 486: // PDEVDATA pdev; ! 487: // FONTOBJ *pfo; ! 488: // HGLYPH *phglyphs; ! 489: // ! 490: // This routine downloads the font definition for the given bitmap font, ! 491: // if it has not already been done. The font is downloaded as an ! 492: // Adobe Type 3 font. ! 493: // ! 494: // This routine return TRUE if the font is successfully, or has already ! 495: // been, downloaded to the printer. It returns FALSE if it fails. ! 496: // ! 497: // History: ! 498: // 13-May-1993 -by- Kent Settle (kentse) ! 499: // Wrote it. ! 500: //-------------------------------------------------------------------- ! 501: ! 502: BOOL DownloadANSIBitmapFont(pdev, pfo, phglyphs) ! 503: PDEVDATA pdev; ! 504: FONTOBJ *pfo; ! 505: HGLYPH *phglyphs; ! 506: { ! 507: DLFONT *pDLFont; ! 508: DWORD i; ! 509: DWORD cDownloadedFonts; ! 510: DWORD cTmp; ! 511: HGLYPH *phg; ! 512: GLYPHDATA *pglyphdata; ! 513: POINTL ptlTL, ptlBR, ptl1; ! 514: PIFIMETRICS pifi; ! 515: CHAR szFaceName[MAX_STRING]; ! 516: PSZ pszFaceName; ! 517: PWSTR pwstr; ! 518: LONG EmHeight; ! 519: XFORMOBJ *pxo; ! 520: POINTFIX ptfx; ! 521: PS_FIX psfxPointSize; ! 522: XFORM fontxform; ! 523: HGLYPH hgDefault; ! 524: ! 525: // search through our list of downloaded GDI fonts to see if the ! 526: // current font has already been downloaded to the printer. ! 527: ! 528: pDLFont = pdev->cgs.pDLFonts; ! 529: ! 530: cDownloadedFonts = min(pdev->cgs.cDownloadedFonts, pdev->iDLFonts); ! 531: ! 532: for (i = 0; i < cDownloadedFonts; i++) ! 533: { ! 534: // is this entry the one we are looking for? simply return if so. ! 535: ! 536: if (pDLFont->iUniq == pfo->iUniq) ! 537: { ! 538: // update the fontname and size in our current graphics state. ! 539: ! 540: strcpy(pdev->cgs.szFont, pDLFont->strFont); ! 541: pdev->cgs.lidFont = pDLFont->iUniq; ! 542: ! 543: return(TRUE); ! 544: } ! 545: ! 546: pDLFont++; ! 547: } ! 548: ! 549: // we did not find that this font has been downloaded yet, so we must ! 550: // do it now. ! 551: ! 552: // if we have reached our downloaded font threshold, then ! 553: // we will surround ever textout call with a save/restore. ! 554: ! 555: if (cDownloadedFonts >= pdev->iDLFonts) ! 556: { ! 557: ps_save(pdev, FALSE); ! 558: pdev->cgs.dwFlags |= CGS_DLFONTTHRESHOLD; ! 559: cDownloadedFonts = pdev->iDLFonts; ! 560: } ! 561: ! 562: pDLFont = pdev->cgs.pDLFonts; ! 563: pDLFont += cDownloadedFonts; ! 564: ! 565: memset(pDLFont, 0, sizeof(DLFONT)); ! 566: ! 567: pDLFont->iFace = pfo->iFace; ! 568: pDLFont->iUniq = pfo->iUniq; ! 569: ! 570: // if we have made it this far, we should simply be able to ! 571: // download the font now. ! 572: ! 573: // we will be downloading an Adobe TYPE 3 font. ! 574: ! 575: // allocate a dictionary for the font. ! 576: ! 577: PrintString(pdev, "9 dict dup begin\n"); ! 578: ! 579: // set FontType to 3 indicating user defined font. ! 580: ! 581: PrintString(pdev, "/FontType 3 def\n"); ! 582: ! 583: // get a pointer to our array of HGLYPHS. remember to skip over the ! 584: // first two WORDS. ! 585: ! 586: phg = phglyphs + 1; ! 587: ! 588: //!!! for now - assuming first hglyph is the default one. ! 589: ! 590: hgDefault = *phg; ! 591: ! 592: // run through the array, looking at the bounding box for each ! 593: // glyph, in order to create the bounding box for the entire ! 594: // font. ! 595: ! 596: ptlTL.x = ADOBE_FONT_UNITS; ! 597: ptlTL.y = ADOBE_FONT_UNITS; ! 598: ptlBR.x = 0; ! 599: ptlBR.y = 0; ! 600: ! 601: for (i = 0; i < 256; i++) ! 602: { ! 603: // get the GLYPHDATA structure for each glyph. ! 604: ! 605: if (!(cTmp = FONTOBJ_cGetGlyphs(pfo, FO_GLYPHBITS, 1, phg, (PVOID *)&pglyphdata))) ! 606: { ! 607: RIP("PSCRIPT!DownloadANSIBitmapFont: cGetGlyphs failed.\n"); ! 608: return(FALSE); ! 609: } ! 610: ! 611: ptlTL.x = min(ptlTL.x, pglyphdata->rclInk.left); ! 612: ptlTL.y = min(ptlTL.y, pglyphdata->rclInk.top); ! 613: ptlBR.x = max(ptlBR.x, pglyphdata->rclInk.right); ! 614: ptlBR.y = max(ptlBR.y, pglyphdata->rclInk.bottom); ! 615: ! 616: // point to the next glyph handle. ! 617: ! 618: phg++; ! 619: } ! 620: ! 621: // get the IFIMETRICS for the font. ! 622: ! 623: if (!(pifi = FONTOBJ_pifi(pfo))) ! 624: { ! 625: RIP("PSCRIPT!DownloadANSIBitmapFont: pifi failed.\n"); ! 626: return(FALSE); ! 627: } ! 628: ! 629: // get the Notional to Device transform. this is needed to ! 630: // determine the point size. ! 631: ! 632: pxo = FONTOBJ_pxoGetXform(pfo); ! 633: ! 634: if (pxo == NULL) ! 635: { ! 636: RIP("PSCRIPT!DownloadANSIBitmapFont: pxo == NULL.\n"); ! 637: return(FALSE); ! 638: } ! 639: ! 640: // apply the notional to device transform. ! 641: ! 642: ptl1.x = 0; ! 643: ptl1.y = pifi->fwdUnitsPerEm; ! 644: ! 645: XFORMOBJ_bApplyXform(pxo, XF_LTOFX, 1, &ptl1, &ptfx); ! 646: ! 647: // now get the length of the vector. ! 648: ! 649: EmHeight = FXTOL(iHipot(ptfx.x, ptfx.y)); ! 650: ! 651: // we have filled in the GLYPHPOS for each glyph in the font. ! 652: // reset the pointer to the first glyph. ! 653: ! 654: PrintString(pdev, "/FontMatrix [1 "); ! 655: PrintDecimal(pdev, 1, EmHeight); ! 656: PrintString(pdev, " div 0 0 1 "); ! 657: PrintDecimal(pdev, 1, EmHeight); ! 658: PrintString(pdev, " div 0 0] def\n"); ! 659: ! 660: // define the bounding box for the font, defined in 1 unit ! 661: // character space (since FontMatrix = identity). ! 662: ! 663: PrintString(pdev, "/FontBBox ["); ! 664: PrintDecimal(pdev, 4, ptlTL.x, ptlTL.y, ptlBR.x, ptlBR.y); ! 665: PrintString(pdev, " ] def\n"); ! 666: ! 667: // allocate array for encoding vector, then initialize ! 668: // all characters in encoding vector with '.notdef'. ! 669: ! 670: PrintString(pdev, "/Encoding 256 array def\n"); ! 671: PrintString(pdev, "0 1 255 {Encoding exch /.notdef put} for\n"); ! 672: ! 673: // allocate space to store the HGLYPH<==>character code mapping. ! 674: ! 675: if (!(pDLFont->phgVector = (HGLYPH *)HeapAlloc(pdev->hheap, 0, ! 676: sizeof(HGLYPH) * 256))) ! 677: { ! 678: RIP("PSCRIPT!DownloadANSIBitmapFont: HeapAlloc for phgVector failed.\n"); ! 679: return(FALSE); ! 680: } ! 681: ! 682: // reset pointer to our array of HGLYPHS. remember to skip over the ! 683: // first two WORDS. ! 684: ! 685: phg = phglyphs + 1; ! 686: ! 687: // fill in the HGLYPH encoding vector, and output ! 688: // the encoding vector to the printer. leave the first position for ! 689: // the .notdef character. ! 690: ! 691: pDLFont->cGlyphs = 256; ! 692: memcpy(pDLFont->phgVector, phg, 256 * sizeof(HGLYPH)); ! 693: ! 694: PrintString(pdev, "Encoding\n"); ! 695: ! 696: for (i = 1; i < 256; i++) ! 697: { ! 698: PrintString(pdev, "dup "); ! 699: PrintDecimal(pdev, 1, i); ! 700: PrintString(pdev, " /c"); ! 701: PrintDecimal(pdev, 1, i); ! 702: PrintString(pdev, " put\n"); ! 703: } ! 704: ! 705: // under level 1 of PostScript, the 'BuildChar' procedure is called ! 706: // every time a character from the font is constructed. under ! 707: // level 2, 'BuildGlyph' is called instead. therefore, we will ! 708: // define a 'BuildChar' procedure, which basically calls ! 709: // 'BuildGlyph'. this will provide us support for both level 1 ! 710: // and level 2 of PostScript. ! 711: ! 712: // define the 'BuildGlyph' procedure. start by getting the ! 713: // character name and the font dictionary from the stack. ! 714: ! 715: PrintString(pdev, "/BuildGlyph {0 begin /cn exch def /fd exch def\n"); ! 716: ! 717: // retrieve the character information from the CharData (CD) ! 718: // dictionary. ! 719: ! 720: PrintString(pdev, "/CI fd /CD get cn get def\n"); ! 721: ! 722: // get the width and the bounding box from the CharData. ! 723: // remember to divide the width by 16. ! 724: ! 725: PrintString(pdev, "/wx CI 0 get def /cbb CI 1 4 getinterval def\n"); ! 726: ! 727: // enable each character to be cached. ! 728: ! 729: PrintString(pdev, "wx 0 cbb aload pop setcachedevice\n"); ! 730: ! 731: // get the width and height of the bitmap, set invert bool to true ! 732: // specifying reverse image. ! 733: ! 734: PrintString(pdev, "CI 5 get CI 6 get true\n"); ! 735: ! 736: // insert x and y translation components into general imagemask ! 737: // matrix. ! 738: ! 739: PrintString(pdev, "[1 0 0 -1 0 0] dup 4 CI 7 get put dup 5 CI 8 get put\n"); ! 740: ! 741: // get hex string bitmap, convert into procedure, then print ! 742: // the bitmap image. ! 743: ! 744: PrintString(pdev, "CI 9 1 getinterval cvx imagemask end } def\n"); ! 745: ! 746: // create local storage for 'BuildGlyph' procedure. ! 747: ! 748: PrintString(pdev, "/BuildGlyph load 0 5 dict put\n"); ! 749: ! 750: // the semantics of 'BuildChar' differ from 'BuildGlyph' in the ! 751: // following way: 'BuildChar' is called with the font dictionary ! 752: // and character code on the stack, 'BuildGlyph' is called with ! 753: // the font dictionary and character name on the stack. the ! 754: // following 'BuildChar' procedure calls 'BuildGlyph', and retains ! 755: // compatiblity with level 1 PostScript. ! 756: ! 757: PrintString(pdev, "/BuildChar {1 index /Encoding get exch get\n"); ! 758: PrintString(pdev, "1 index /BuildGlyph get exec} bind def\n"); ! 759: ! 760: // now create a dictionary containing information on each character. ! 761: ! 762: PrintString(pdev, "/CD 256 dict def CD begin\n"); ! 763: ! 764: // send out the definition of the default (.notdef) character. ! 765: ! 766: if (!SendCharBitmap(pdev, pfo, *phg++, 0, TRUE)) ! 767: { ! 768: RIP("PSCRIPT!DownloadANSIBitmapFont: SendCharBitmap failed.\n"); ! 769: HeapFree(pdev->hheap, 0, (PVOID)pDLFont->phgVector); ! 770: return(FALSE); ! 771: } ! 772: ! 773: for (i = 1; i < 256; i++) ! 774: { ! 775: // don't send out duplicates of the .notdef definition. ! 776: ! 777: if (*phg != hgDefault) ! 778: { ! 779: if (!SendCharBitmap(pdev, pfo, *phg, i, FALSE)) ! 780: { ! 781: RIP("PSCRIPT!DownloadANSIBitmapFont: SendCharBitmap failed.\n"); ! 782: HeapFree(pdev->hheap, 0, (PVOID)pDLFont->phgVector); ! 783: return(FALSE); ! 784: } ! 785: } ! 786: ! 787: // point to the next HGLYPH. ! 788: ! 789: phg++; ! 790: } ! 791: ! 792: // close the definition of the font. ! 793: ! 794: PrintString(pdev, "end\n"); ! 795: ! 796: // create a unique ID for the font, then name it. ! 797: ! 798: pwstr = (PWSTR)((BYTE *)pifi + pifi->dpwszFaceName); ! 799: cTmp = wcslen(pwstr); ! 800: ! 801: // get the font name from the UNICODE font name. ! 802: ! 803: memset(szFaceName, 0, sizeof(szFaceName)); ! 804: pszFaceName = szFaceName; ! 805: ! 806: while (cTmp--) ! 807: { ! 808: *pszFaceName = (CHAR)*pwstr++; ! 809: ! 810: // replace any spaces in the font name with underscores. ! 811: ! 812: if (*pszFaceName == ' ') ! 813: *pszFaceName = '_'; ! 814: ! 815: // replace any parens in the font name with asterisks. ! 816: ! 817: if ((*pszFaceName == '(') || (*pszFaceName == ')')) ! 818: *pszFaceName = '*'; ! 819: ! 820: // point to the next character. ! 821: ! 822: *pszFaceName++; ! 823: } ! 824: ! 825: // add the point size to the font name, so we can distinguish ! 826: // different point sizes of the same font. ! 827: ! 828: // NOTE Grab a new point size here, rather than reading if from ! 829: // the CGS. This is necessary to support DrvDownloadFace. ! 830: ! 831: psfxPointSize = GetPointSize(pdev, pfo, &fontxform); ! 832: ! 833: cTmp = PSFIXToBuffer(pszFaceName, psfxPointSize); ! 834: ! 835: // update the buffer pointer. ! 836: ! 837: pszFaceName += cTmp; ! 838: ! 839: // output the NULL terminator. ! 840: ! 841: *pszFaceName = '\0'; ! 842: ! 843: // output the unique id, which, in a postscript printer, can ! 844: // be in the range from 0 to 16777215. ! 845: ! 846: PrintString(pdev, "/UniqueID "); ! 847: PrintDecimal(pdev, 1, (pfo->iUniq & 0xFFFFF)); ! 848: ! 849: PrintString(pdev, " def end pop /"); ! 850: PrintString(pdev, szFaceName); ! 851: PrintString(pdev, " exch definefont pop\n"); ! 852: ! 853: // update the fontname in our current graphics state. ! 854: ! 855: strcpy(pdev->cgs.szFont, szFaceName); ! 856: ! 857: // update information for this downloaded font. ! 858: ! 859: strcpy(pDLFont->strFont, szFaceName); ! 860: pDLFont->psfxScaleFactor = psfxPointSize; ! 861: ! 862: // update the downloaded font counter. ! 863: ! 864: pdev->cgs.cDownloadedFonts++; ! 865: } ! 866: ! 867: ! 868: //-------------------------------------------------------------------- ! 869: // BOOL SendCharBitmap(pdev, pfo, hglyph, index, bnotdef); ! 870: // PDEVDATA pdev; ! 871: // FONTOBJ *pfo; ! 872: // HGLYPH hglyph; ! 873: // DWORD index; ! 874: // BOOL bnotdef; ! 875: // ! 876: // This routine downloads the character bitmap definition to the printer. ! 877: // ! 878: // This routine return TRUE for success, FALSE otherwise. ! 879: // ! 880: // History: ! 881: // 13-May-1993 -by- Kent Settle (kentse) ! 882: // Broke out of DownloadANSIBitmapFont. ! 883: //-------------------------------------------------------------------- ! 884: ! 885: BOOL SendCharBitmap(pdev, pfo, hglyph, index, bnotdef) ! 886: PDEVDATA pdev; ! 887: FONTOBJ *pfo; ! 888: HGLYPH hglyph; ! 889: DWORD index; ! 890: BOOL bnotdef; ! 891: { ! 892: DWORD cTmp; ! 893: GLYPHDATA *pglyphdata; ! 894: PS_FIX psfxXtrans, psfxYtrans; ! 895: BYTE *pjBits; ! 896: DWORD j; ! 897: LONG cjWidth; ! 898: ! 899: // get the GLYPHDATA structure for each glyph. ! 900: ! 901: if (!(cTmp = FONTOBJ_cGetGlyphs(pfo, FO_GLYPHBITS, 1, &hglyph, ! 902: (PVOID *)&pglyphdata))) ! 903: { ! 904: RIP("PSCRIPT!SendCharBitmap: cGetGlyphs failed.\n"); ! 905: return(FALSE); ! 906: } ! 907: ! 908: // the first number in the character description is the width ! 909: // in 1 unit font space. the next four numbers are the bounding ! 910: // box in 1 unit font space. the next two numbers are the width ! 911: // and height of the bitmap. the next two numbers are the x and ! 912: // y translation values for the matrix given to imagemask. ! 913: // this is followed by the bitmap itself. ! 914: ! 915: // first, output the character name. ! 916: ! 917: if (bnotdef) ! 918: PrintString(pdev, "/.notdef"); ! 919: else ! 920: { ! 921: PrintString(pdev, "/c"); ! 922: PrintDecimal(pdev, 1, index); ! 923: } ! 924: ! 925: // output the character description array. the width and ! 926: // bounding box need to be normalized to 1 unit font space. ! 927: ! 928: // the width will be sent to the printer as the actual width ! 929: // multiplied by 16 so as not to lose any precision when ! 930: // normalizing. ! 931: ! 932: PrintString(pdev, " ["); ! 933: PrintPSFIX(pdev, 1, (pglyphdata->fxD << 4)); ! 934: PrintString(pdev, " "); ! 935: PrintDecimal(pdev, 4, pglyphdata->rclInk.left, ! 936: -pglyphdata->rclInk.top, pglyphdata->rclInk.right, ! 937: -pglyphdata->rclInk.bottom); ! 938: PrintString(pdev, " "); ! 939: ! 940: // output the width and height of the bitmap itself. ! 941: ! 942: PrintDecimal(pdev, 2, pglyphdata->gdf.pgb->sizlBitmap.cx, ! 943: pglyphdata->gdf.pgb->sizlBitmap.cy); ! 944: PrintString(pdev, " "); ! 945: ! 946: // output the translation values for the transform matrix. ! 947: // the x component is usually the equivalent of the left ! 948: // sidebearing in pixels. the y component is always the height ! 949: // of the bitmap minus any displacement factor (such as for characters ! 950: // with descenders. both components have .5 subtracted from the original ! 951: // values to avoid roundoff errors. ! 952: ! 953: psfxXtrans = ETOPSFX((FLOAT)FXTOLROUND(-pglyphdata->fxA) - 0.5); ! 954: psfxYtrans = ETOPSFX(-(FLOAT)pglyphdata->gdf.pgb->ptlOrigin.y - 0.5); ! 955: ! 956: PrintPSFIX(pdev, 2, psfxXtrans, psfxYtrans); ! 957: PrintString(pdev, "\n<"); ! 958: ! 959: // now output the bits. calculate how many bytes each source scanline ! 960: // contains. remember that the bitmap will be padded to 32bit bounds. ! 961: ! 962: // protect ourselves. ! 963: ! 964: if ((pglyphdata->gdf.pgb->sizlBitmap.cx < 1) || ! 965: (pglyphdata->gdf.pgb->sizlBitmap.cy < 1)) ! 966: { ! 967: RIP("PSCRIPT!SendCharBitmap: Invalid glyphdata!!!.\n"); ! 968: return(FALSE); ! 969: } ! 970: ! 971: pjBits = pglyphdata->gdf.pgb->aj; ! 972: ! 973: for (j = 0; j < (DWORD)pglyphdata->gdf.pgb->sizlBitmap.cy; j++) ! 974: { ! 975: cjWidth = (LONG)(pglyphdata->gdf.pgb->sizlBitmap.cx + 7) >> 3; ! 976: vHexOut(pdev, pjBits, cjWidth); ! 977: pjBits += cjWidth; ! 978: } ! 979: ! 980: PrintString(pdev, ">]def\n"); ! 981: ! 982: return(TRUE); ! 983: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.