![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to textout.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 textout.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 ! root 1: //-------------------------------------------------------------------------- ! 2: // ! 3: // Module Name: TEXTOUT.C ! 4: // ! 5: // Brief Description: This module contains the PSCRIPT driver's DrvTextOut ! 6: // function and related routines. ! 7: // ! 8: // Author: Kent Settle (kentse) ! 9: // Created: 12-Feb-1991 ! 10: // ! 11: // 26-Mar-1992 Thu 23:29:37 updated -by- Daniel Chou (danielc) ! 12: // Add another parameter to bDoClipObj() so it also return the bounding ! 13: // rectangle to the clip region for halftone purpose. ! 14: // ! 15: // Copyright (c) 1991 - 1992 Microsoft Corporation ! 16: //-------------------------------------------------------------------------- ! 17: ! 18: #include "stdlib.h" ! 19: #include <string.h> ! 20: #include "pscript.h" ! 21: #include "enable.h" ! 22: #include "mapping.h" ! 23: #include "resource.h" ! 24: ! 25: extern HMODULE ghmodDrv; // GLOBAL MODULE HANDLE. ! 26: ! 27: extern TT_FONT_MAPPING TTFamilyTable[]; // tables.h. ! 28: extern TT_FONT_MAPPING TTFontTable[]; // tables.h. ! 29: extern BOOL DrvCommonPath(PDEVDATA, PATHOBJ *); ! 30: extern VOID ps_show(PDEVDATA, STROBJ *, FLONG, TEXTDATA *); ! 31: extern DWORD PSFIXToBuffer(CHAR *, PS_FIX); ! 32: extern PS_FIX GetPointSize(PDEVDATA, FONTOBJ *, XFORM *); ! 33: ! 34: #ifdef INDEX_PAL ! 35: extern ULONG PSMonoPalette[]; ! 36: extern ULONG PSColorPalette[]; ! 37: #endif ! 38: ! 39: PSZ apszRemapCode[] = ! 40: { ! 41: "/reencode {findfont begin currentdict d length dict begin {", ! 42: "1 index /FID ne {def} {pop pop} ifelse} forall /FontName exch def", ! 43: "d length 0 ne {/Encoding Encoding 256 array copy def 0 exch {", ! 44: "d type /nametype eq {Encoding 2 index 2 index put pop 1 add", ! 45: "}{exch pop} ifelse} forall} if pop currentdict d end end", ! 46: "/FontName get exch definefont pop} bd", ! 47: NULL ! 48: } ; ! 49: ! 50: typedef struct ! 51: { ! 52: WCHAR wc; // UNICODE code point. ! 53: POINTL ptlpgp; // pointl as defined by GLYPHPOS structs. ! 54: POINTFIX ptfxorg; // pointfix as defined by original font. ! 55: } TEXTDELTA; ! 56: ! 57: #define MAX_LINE_LENGTH 70 ! 58: ! 59: // macro for scaling between TrueType and Adobe fonts. ! 60: ! 61: #define TTTOADOBE(x) (((x) * ADOBE_FONT_UNITS) / pifi->fwdUnitsPerEm) ! 62: ! 63: // declaration of routines residing in this module. ! 64: ! 65: BOOL bDoClipObj(PDEVDATA, CLIPOBJ *, RECTL *, RECTL *, BOOL *, BOOL *, DWORD); ! 66: BOOL DrawGlyphs(PDEVDATA, DWORD, GLYPHPOS *, FONTOBJ *, STROBJ *, TEXTDATA *, PWSZ); ! 67: BOOL RemapDeviceChar(PDEVDATA, PCHAR, STROBJ *, FLONG, BOOL, TEXTDATA *); ! 68: BOOL RemapUnicodeChar(PDEVDATA, PWCHAR, STROBJ *, FLONG, BOOL, TEXTDATA *); ! 69: BOOL RemapGDIChar(PDEVDATA, STROBJ *, GLYPHPOS *, DLFONT *, BOOL *, FLONG, TEXTDATA *); ! 70: BOOL SelectFont(PDEVDATA, FONTOBJ *, TEXTDATA *); ! 71: VOID RemapFont(PDEVDATA, STROBJ *, FLONG, BOOL, TEXTDATA *); ! 72: VOID CharBitmap(PDEVDATA, GLYPHPOS *); ! 73: BOOL DownloadBitmapFont(PDEVDATA, FONTOBJ *); ! 74: BOOL DownloadOutlineFont(PDEVDATA, FONTOBJ *); ! 75: BOOL SetFontRemap(PDEVDATA, DWORD); ! 76: BOOL QueryFontRemap(PDEVDATA, DWORD); ! 77: DWORD SubstituteIFace(PDEVDATA, FONTOBJ *); ! 78: LONG iHipot(LONG, LONG); ! 79: BOOL IsJustifiedText(PDEVDATA, FONTOBJ *, STROBJ *, POINTPSFX *, ! 80: POINTPSFX *, TEXTDATA *); ! 81: BOOL FillDeltaArray(PDEVDATA, FONTOBJ *, GLYPHPOS *, STROBJ *, TEXTDELTA *, ! 82: DWORD, PWSZ); ! 83: PWSTR GetUnicodeString(PDEVDATA, FONTOBJ *, STROBJ *); ! 84: VOID ConstructUCString(GLYPHPOS *, PUCMap, DWORD, PWSTR); ! 85: BOOL GetDeviceWidths(PDEVDATA, FONTOBJ *, GLYPHDATA *, HGLYPH); ! 86: ! 87: //-------------------------------------------------------------------------- ! 88: // BOOL DrvTextOut (pso, pstro, pfo, pco, prclExtra, prclOpaque, pboFore, ! 89: // pboOpaque, pptBrushOrg, mix) ! 90: // SURFOBJ *pso; ! 91: // STROBJ *pstro; ! 92: // FONTOBJ *pfo; ! 93: // CLIPOBJ *pco; ! 94: // RECTL *prclExtra; ! 95: // RECTL *prclOpaque; ! 96: // BRUSHOBJ *pboFore; ! 97: // BRUSHOBJ *pboOpaque; ! 98: // POINTL *pptlBrushOrg; ! 99: // MIX mix; ! 100: // ! 101: // The graphics engine will call this routine to render a set of glyphs at ! 102: // specified positions. In order to make things clear, we will make a short ! 103: // mathematical detour. The parameters of the function unambiguously divides ! 104: // the entire set of device space pixels into three proper subsets denoted ! 105: // foreground, background, and transparent. When the text is rendered to the ! 106: // surface, the foreground pixels are rendered with a foreground brush, the ! 107: // background pixels the background brush, and the transparent pixels are left ! 108: // untouched. The foreground pixels are defined by first forming the union of ! 109: // all the glyph pixels with the pixels of the extra rectangles, then ! 110: // intersecting the result with the pixels of the clipping region. The set ! 111: // of pixels comprising the extra rectangles are defined by (up to) three ! 112: // rectangles pointed to by prclExt. These rectangles are used to simulate ! 113: // effects like underlining and strike through glyphs. The background set of ! 114: // pixels is defined as the intersection of three sets: (1) the pixels of the ! 115: // background rectangle; (2) the complement of the foreground; (3) the ! 116: // clipping region. Any pixels that are not part of either the foreground or ! 117: // background sets are defined to be transparent. The input parameters to ! 118: // DrvTextOut define two sets of pixels foreground and opaque. The driver must ! 119: // render the surface so that the result is identical to a process where the ! 120: // opaque pixels are rendered first with the opaque brush, then the foreground ! 121: // pixels are rendered with the foreground brush. Each of these operations is ! 122: // limited by clipping. The foreground set of pixels is defined to be the ! 123: // union of the pixels of the glyphs and the pixels of the "extra" rectangles ! 124: // at prclExtra. These extra rectangles are used to simulate strike-through or ! 125: // underlines. The opaque pixels are defined by the opaque rectangle at ! 126: // prclOpaque. The foreground and opaque pixels are regarded as a screen ! 127: // through which color is brushed onto the surface. The glyphs of the font ! 128: // do not have color in themselves. The input parameters to DrvTextOut ! 129: // define the set of glyph pixels, the set of extra rectangles, the opaque ! 130: // rectangle, and the clipping region. It is the responsibility of the driver ! 131: // to calculate and then render the set of foreground and opaque pixels. ! 132: // ! 133: // Parameters: ! 134: // pso ! 135: // Pointer to a SURFOBJ. ! 136: // ! 137: // pstro ! 138: // Pointer to a STROBJ. This defines the glyphs to be rendered and the ! 139: // positions where they are to be placed. ! 140: // ! 141: // pfo ! 142: // Pointer to a FONTOBJ. This is used to retrieve information about the ! 143: // font and its glyphs. ! 144: // ! 145: // pco ! 146: // Pointer to a CLIPOBJ. This defines the clipping region through which ! 147: // all rendering must be done. No pixels can be affected outside the ! 148: // clipping region. ! 149: // ! 150: // prclExtra ! 151: // Pointer to a null terminated array of rectangles. These rectangles ! 152: // are bottom right exclusive. The pixels of the rectangles are to be ! 153: // combined with the pixels of the glyphs to produce the foreground ! 154: // pixels. The extra rectangles are used to simulate underlining or strike ! 155: // out. If prclExtra is NULL then there are no extra rectangles to be ! 156: // rendered. If the prclExtra is not NULL then the rectangles are read ! 157: // until a null rectangle is reached. A null rectangle has both coordinates ! 158: // of both points set to zero. ! 159: // ! 160: // prclOpaque ! 161: // Pointer to a single opaque rectangle. This rectangle is bottom ! 162: // right exclusive. Pixels within this rectangle (that are not foreground ! 163: // and not clipped) are to be rendered with the opaque brush. If this ! 164: // argument is NULL then no opaque pixels are to be rendered. ! 165: // ! 166: // pboFore ! 167: // Pointer to the brush object to be used for the foreground pixels. ! 168: // The fill pattern is defined by this brush. A GDI service, ! 169: // BRUSHOBJ_pvDevBrush, is provided to find the device's realization of ! 170: // the brush. ! 171: // ! 172: // pboOpaque ! 173: // Pointer to the brush object for the opaque pixels. Both the foreground ! 174: // and background mix modes for this brush are assumed to be overpaint. ! 175: // ! 176: // pptlBrushOrg ! 177: // Pointer to a POINTL defining the brush origin for both brushes. ! 178: // ! 179: // mix ! 180: // Foreground and background raster operations (mix modes) for pboFore. ! 181: // ! 182: // Returns: ! 183: // TRUE if successful. Otherwise FALSE, and an error code is logged. ! 184: // ! 185: // History: ! 186: // 12-Feb-1991 -by- Kent Settle (kentse) ! 187: // Wrote it. ! 188: //-------------------------------------------------------------------------- ! 189: ! 190: BOOL DrvTextOut( ! 191: SURFOBJ *pso, ! 192: STROBJ *pstro, ! 193: FONTOBJ *pfo, ! 194: CLIPOBJ *pco, ! 195: PRECTL prclExtra, ! 196: PRECTL prclOpaque, ! 197: BRUSHOBJ *pboFore, ! 198: BRUSHOBJ *pboOpaque, ! 199: PPOINTL pptlOrg, ! 200: MIX mix) ! 201: { ! 202: PDEVDATA pdev; ! 203: BOOL bMore; ! 204: DEVBRUSH *pBrush; ! 205: RECTL rclBounds; ! 206: FONTINFO fi; ! 207: DWORD cGlyphs; ! 208: GLYPHPOS *pgp; ! 209: BOOL bClipping; ! 210: TEXTDATA *pdata; ! 211: BOOL bFirstClipPass; ! 212: ULONG ulColor; ! 213: ULONG *pulColors; ! 214: ! 215: // make sure we have been given valid pointers. ! 216: ! 217: if ((pso == (SURFOBJ *)NULL) || (pstro == (STROBJ *)NULL) || ! 218: (pfo == (FONTOBJ *)NULL) || (pco == (CLIPOBJ *)NULL)) ! 219: { ! 220: RIP("PSCRIPT!DrvTextOut: NULL pointer passed in.\n"); ! 221: SetLastError(ERROR_INVALID_PARAMETER); ! 222: return(FALSE); ! 223: } ! 224: ! 225: // get the pointer to our DEVDATA structure and make sure it is ours. ! 226: ! 227: pdev = (PDEVDATA) pso->dhpdev; ! 228: ! 229: if (bValidatePDEV(pdev) == FALSE) ! 230: { ! 231: RIP("PSCRIPT!DrvTextOut: invalid PDEV."); ! 232: SetLastError(ERROR_INVALID_PARAMETER); ! 233: return(FALSE); ! 234: } ! 235: ! 236: // make sure we have been given a valid font. ! 237: ! 238: if ( (pfo->flFontType & DEVICE_FONTTYPE) && ! 239: (pfo->iFace > (pdev->cDeviceFonts + pdev->cSoftFonts)) ) ! 240: { ! 241: RIP("PSCRIPT!DrvTextOut: invalid iFace.\n"); ! 242: SetLastError(ERROR_INVALID_PARAMETER); ! 243: return(FALSE); ! 244: } ! 245: ! 246: // allocate and initialize a TEXTDATA structure. ! 247: ! 248: if (!(pdata = (TEXTDATA *)HeapAlloc(pdev->hheap, 0, sizeof(TEXTDATA)))) ! 249: { ! 250: RIP("PSCRIPT!DrvTextOut: HeapAlloc for TEXTDATA failed."); ! 251: return(FALSE); ! 252: } ! 253: ! 254: pdata->iFace = pfo->iFace; ! 255: pdata->bFontSubstitution = FALSE; ! 256: pdata->ptSpace.x = 0; ! 257: pdata->ptSpace.y = 0; ! 258: pdata->ptNonSpace.x = 0; ! 259: pdata->ptNonSpace.y = 0; ! 260: ! 261: if ((pfo->flFontType & TRUETYPE_FONTTYPE) && ! 262: (pdev->psdm.dwFlags & PSDEVMODE_FONTSUBST)) ! 263: { ! 264: if (pdata->iFace = SubstituteIFace(pdev, pfo)) ! 265: pdata->bFontSubstitution = TRUE; ! 266: else ! 267: pdata->iFace = pfo->iFace; ! 268: } ! 269: ! 270: pdata->bDeviceFont = (pdata->bFontSubstitution || ! 271: (pfo->flFontType & DEVICE_FONTTYPE) ); ! 272: ! 273: pdata->bJustification = IsJustifiedText(pdev, pfo, pstro, &pdata->ptSpace, ! 274: &pdata->ptNonSpace, pdata); ! 275: ! 276: // clear the font download threshold flag. ! 277: ! 278: pdev->cgs.dwFlags &= ~CGS_DLFONTTHRESHOLD; ! 279: ! 280: // select the current font in the printer from the given FONTOBJ. ! 281: ! 282: if (!SelectFont(pdev, pfo, pdata)) ! 283: { ! 284: #if DBG ! 285: DbgPrint("PSCRIPT!DrvTextOut: SelectFont failed.\n"); ! 286: #endif ! 287: HeapFree(pdev->hheap, 0, (PVOID)pdata); ! 288: return(FALSE); ! 289: } ! 290: ! 291: // handle the clip object passed in. ! 292: bFirstClipPass = TRUE; ! 293: ! 294: bClipping = bDoClipObj(pdev, pco, NULL, NULL, NULL, ! 295: &bFirstClipPass, MAX_CLIP_RECTS); ! 296: ! 297: if (bClipping) ! 298: ps_clip(pdev, TRUE); ! 299: ! 300: // output the Opaque rectangle if necessary. this is a background ! 301: // rectangle that goes behind the foreground text, therefore, send ! 302: // it to the printer before the text. ! 303: ! 304: if (prclOpaque) ! 305: { ! 306: // define the opaque rectangle in the printer. ! 307: ! 308: ps_newpath(pdev); ! 309: ps_box(pdev, prclOpaque); ! 310: ! 311: // call the driver's filling routine. this routine will do the ! 312: // right thing with the brush. ! 313: ! 314: if (!ps_patfill(pdev, pso, (FLONG)FP_WINDINGMODE, pboOpaque, pptlOrg, mix, ! 315: prclOpaque, FALSE, FALSE)) ! 316: { ! 317: HeapFree(pdev->hheap, 0, (PVOID)pdata); ! 318: return(FALSE); ! 319: } ! 320: } ! 321: ! 322: // output the text color to draw with. ! 323: ! 324: #ifdef INDEX_PAL ! 325: // just output solid color if there is one. ! 326: ! 327: if ((pdev->pntpd->flFlags & COLOR_DEVICE) && ! 328: (pdev->psdm.dm.dmColor == DMCOLOR_COLOR)) ! 329: pulColors = PSColorPalette; ! 330: else ! 331: pulColors = PSMonoPalette; ! 332: ! 333: if (pboFore->iSolidColor != NOT_SOLID_COLOR) ! 334: { ! 335: ps_setrgbcolor(pdev, (PALETTEENTRY *)pulColors + pboFore->iSolidColor); ! 336: } ! 337: else ! 338: { ! 339: // get the device brush to draw with. ! 340: ! 341: pBrush = (DEVBRUSH *)BRUSHOBJ_pvGetRbrush(pboFore); ! 342: ! 343: if (!pBrush) ! 344: { ! 345: #if DBG ! 346: DbgPrint("DrvTextOut: NULL pBrush.\n"); ! 347: #endif ! 348: // something is wrong! let's print some black text. ! 349: ! 350: ulColor = RGB_BLACK; ! 351: ps_setrgbcolor(pdev, (PALETTEENTRY *)&ulColor); ! 352: } ! 353: else ! 354: { ! 355: if (pBrush->iSolidColor == NOT_SOLID_COLOR) ! 356: { ! 357: // get the foreground color. ! 358: ! 359: ps_setrgbcolor(pdev, ((PALETTEENTRY *)pulColors + ! 360: *(ULONG *)((PBYTE)pBrush + pBrush->offsetXlate + ! 361: sizeof(ULONG)))); ! 362: } ! 363: else ! 364: { ! 365: ps_setrgbcolor(pdev, (PALETTEENTRY *)&pBrush->iSolidColor); ! 366: } ! 367: } ! 368: } ! 369: #else ! 370: if (pboFore->iSolidColor == NOT_SOLID_COLOR) ! 371: { ! 372: // this is not a solid brush, so get a pointer to the ! 373: // realized brush. ! 374: ! 375: #if DBG ! 376: DbgPrint("DrvTextOut: non-solid text brush, defaulting to black.\n"); ! 377: #endif ! 378: ulColor = RGB_BLACK; ! 379: ps_setrgbcolor(pdev, (BGR_PAL_ENTRY *)&ulColor); ! 380: } ! 381: else ! 382: { ! 383: // we have a solid brush, so simply output the line color. ! 384: ! 385: ps_setrgbcolor(pdev, (BGR_PAL_ENTRY *)&pboFore->iSolidColor); ! 386: } ! 387: #endif ! 388: ! 389: ! 390: // get some information about the font. ! 391: ! 392: FONTOBJ_vGetInfo(pfo, sizeof(FONTINFO), &fi); ! 393: ! 394: // get the GLYPHPOS's, directly or indirectly. ! 395: ! 396: if (pstro->pgp) ! 397: { ! 398: if (!DrawGlyphs(pdev, pstro->cGlyphs, pstro->pgp, pfo, pstro, pdata, pstro->pwszOrg)) ! 399: { ! 400: RIP("PSCRIPT!DrvTextOut: DrawGlyphs failed.\n"); ! 401: HeapFree(pdev->hheap, 0, (PVOID)pdata); ! 402: return(FALSE); ! 403: } ! 404: } ! 405: else ! 406: { ! 407: PWSZ pwszCur = pstro->pwszOrg; ! 408: ! 409: // prepare to enumerate the string properly. ! 410: ! 411: STROBJ_vEnumStart(pstro); ! 412: ! 413: // now draw the text. ! 414: ! 415: do ! 416: { ! 417: bMore = STROBJ_bEnum(pstro, &cGlyphs, &pgp); ! 418: ! 419: if (!DrawGlyphs(pdev, cGlyphs, pgp, pfo, pstro, pdata, pwszCur)) ! 420: { ! 421: RIP("PSCRIPT!DrvTextOut: DrawGlyphs failed.\n"); ! 422: HeapFree(pdev->hheap, 0, (PVOID)pdata); ! 423: return(FALSE); ! 424: } ! 425: ! 426: pwszCur += cGlyphs; ! 427: ! 428: } while (bMore); ! 429: } ! 430: // invalidate the current position so it will get updated next time. ! 431: ! 432: pdev->cgs.ptlCurPos.x = -1; ! 433: pdev->cgs.ptlCurPos.y = -1; ! 434: ! 435: // output the extra rectangles if necessary. These rectangles are ! 436: // bottom right exclusive. the pels of the rectangles are to be ! 437: // combined with the pixels of the glyphs to produce the foreground ! 438: // pels. the extra rectangles are used to simulate underlining or ! 439: // strikeout. ! 440: ! 441: if (prclExtra) ! 442: { ! 443: // output a newpath command to the printer. ! 444: ! 445: ps_newpath(pdev); ! 446: ! 447: // set up bounding rectangle. ! 448: ! 449: rclBounds = *prclExtra; ! 450: ! 451: // output each Extra rectangle until we find the terminating ! 452: // retangle with all NULL coordinates. ! 453: ! 454: while ((prclExtra->right != prclExtra->left) || ! 455: (prclExtra->top != prclExtra->bottom) || ! 456: (prclExtra->right != 0L) || ! 457: (prclExtra->top != 0L)) ! 458: { ! 459: ps_box(pdev, prclExtra); ! 460: ! 461: // update the bounding rectangle if necessary. ! 462: ! 463: if (prclExtra->left < rclBounds.left) ! 464: rclBounds.left = prclExtra->left; ! 465: if (prclExtra->right > rclBounds.right) ! 466: rclBounds.right = prclExtra->right; ! 467: if (prclExtra->top < rclBounds.top) ! 468: rclBounds.top = prclExtra->top; ! 469: if (prclExtra->bottom > rclBounds.bottom) ! 470: rclBounds.bottom = prclExtra->bottom; ! 471: ! 472: prclExtra++; ! 473: } ! 474: ! 475: // call the driver's filling routine. this routine will do the ! 476: // right thing with the brush. ! 477: ! 478: if (!ps_patfill(pdev, pso, (FLONG)FP_WINDINGMODE, pboFore, pptlOrg, mix, ! 479: &rclBounds, FALSE, FALSE)) ! 480: { ! 481: HeapFree(pdev->hheap, 0, (PVOID)pdata); ! 482: return(FALSE); ! 483: } ! 484: } ! 485: ! 486: if (bClipping) ! 487: ps_restore(pdev, TRUE); ! 488: ! 489: // if we have hit the downloaded font threshold, then we are doing ! 490: // a save/restore around every textout call. ! 491: ! 492: if (pdev->cgs.dwFlags & CGS_DLFONTTHRESHOLD) ! 493: ps_restore(pdev, FALSE); ! 494: ! 495: // free up memory. ! 496: ! 497: HeapFree(pdev->hheap, 0, (PVOID)pdata); ! 498: ! 499: return(TRUE); ! 500: } ! 501: ! 502: //-------------------------------------------------------------------------- ! 503: // BOOL bDoClipObj(pdev, pco, prclClipBound, pbMoreClipping, ! 504: // pbFirstPass, cRectLimit) ! 505: // PDEVDATA pdev; ! 506: // CLIPOBJ *pco; ! 507: // RECTL *prclClipBound; ! 508: // BOOL *pbMoreClipping; ! 509: // BOOL *pbFirstPass; ! 510: // DWORD cRectLimit; ! 511: // ! 512: // This routine will determine the clipping region as defined in pco, and ! 513: // send the appropriate commands to the printer to set the clip region ! 514: // in the printer. ! 515: // ! 516: // Parameters: ! 517: // pdev ! 518: // Pointer to our DEVDATA structure. ! 519: // ! 520: // pco ! 521: // Pointer to a CLIPOBJ. This defines the clipping region through which ! 522: // all rendering must be done. No pixels can be affected outside the ! 523: // clipping region. ! 524: // ! 525: // bBitblt ! 526: // True if called from bitblt function ! 527: // ! 528: // prclBound ! 529: // If not NULL then it return the bounding rectangle for the clipping ! 530: // region, the returning rclBound only valid if return value is TRUE. ! 531: // ! 532: // Returns: ! 533: // This routine returns TRUE if a clippath was sent to the printer, ! 534: // otherwise FALSE. ! 535: // ! 536: // History: ! 537: // 26-Mar-1992 Thu 23:33:58 updated -by- Daniel Chou (danielc) ! 538: // add prclBound to accumulate the bounding rectangle for the clipping ! 539: // region. ! 540: // ! 541: // 12-Feb-1991 -by- Kent Settle (kentse) ! 542: // Wrote it. ! 543: //-------------------------------------------------------------------------- ! 544: ! 545: BOOL bDoClipObj(pdev, pco, prclClipBound, prclTarget, pbMoreClipping, ! 546: pbFirstPass, cRectLimit) ! 547: PDEVDATA pdev; ! 548: CLIPOBJ *pco; ! 549: RECTL *prclClipBound; ! 550: RECTL *prclTarget; ! 551: BOOL *pbMoreClipping; ! 552: BOOL *pbFirstPass; ! 553: DWORD cRectLimit; ! 554: { ! 555: short iComplex; ! 556: ENUMRECTS buffer; ! 557: BOOL bMore; ! 558: ULONG cRects; ! 559: RECTL rclClipBound; ! 560: ! 561: // assume all clipping will be done within this one call. ! 562: ! 563: if (pbMoreClipping) ! 564: *pbMoreClipping = FALSE; ! 565: ! 566: if (pco == NULL) ! 567: return(FALSE); ! 568: ! 569: iComplex = (short)pco->iDComplexity; ! 570: ! 571: switch(iComplex) ! 572: { ! 573: case DC_TRIVIAL: ! 574: // in this case, there is no clipping. Therefore, we have ! 575: // no commands to send to the printer. ! 576: ! 577: return (FALSE); ! 578: ! 579: case DC_RECT: ! 580: // check to see if the target rectangle fits inside the clip ! 581: // rectangle. if it does, don't do clipping. ! 582: ! 583: if (prclTarget) ! 584: { ! 585: if ((pco->rclBounds.left <= prclTarget->left) && ! 586: (pco->rclBounds.top <= prclTarget->top) && ! 587: (pco->rclBounds.right >= prclTarget->right) && ! 588: (pco->rclBounds.bottom >= prclTarget->bottom)) ! 589: { ! 590: // I see no reason to clip this, do you? ! 591: ! 592: return(FALSE); ! 593: } ! 594: } ! 595: ! 596: // in this case, we are clipping to a single rectangle. ! 597: // get it from the CLIPOBJ, then send it to the printer. ! 598: ! 599: buffer.arcl[0] = pco->rclBounds; ! 600: ! 601: // send a newpath command, then the clip rectangle to ! 602: // the printer. TRUE means to do a gsave, not a save command. ! 603: ! 604: if (!ps_save(pdev, TRUE)) ! 605: return(FALSE); ! 606: ! 607: ps_newpath(pdev); ! 608: ps_box(pdev, &buffer.arcl[0]); ! 609: ! 610: if (prclClipBound) ! 611: *prclClipBound = buffer.arcl[0]; // this is the bound ! 612: ! 613: break; ! 614: ! 615: case DC_COMPLEX: ! 616: // in this case, we are clipping to a complex clip region. ! 617: // enumerate the clip region from the CLIPOBJ, and send the ! 618: // entire clip region to the printer. ! 619: ! 620: // ! 621: // 26-Mar-1992 Thu 23:49:59 updated -by- Daniel Chou (danielc) ! 622: // ! 623: // Initialize the empty bound then acculate it later, ! 624: // ! 625: // !!!! This may changed, we need to check with engine guys to ! 626: // see if you can just pick up the clip region bounding ! 627: // rectangle from pco->rclBounds, if so we need to deleted ! 628: // all accumulation codes. ! 629: // ! 630: ! 631: if (prclClipBound) ! 632: { ! 633: rclClipBound.top = ! 634: rclClipBound.left = 0x7fffffffL; ! 635: rclClipBound.right = ! 636: rclClipBound.bottom = 0; ! 637: } ! 638: ! 639: // send a newpath command to the printer. ! 640: ! 641: if (!ps_save(pdev, TRUE)) ! 642: return(FALSE); ! 643: ! 644: ps_newpath(pdev); ! 645: ! 646: // set up to enumerate the clip region, but just do this once. ! 647: ! 648: if (*pbFirstPass == TRUE) ! 649: { ! 650: cRects = CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0); ! 651: *pbFirstPass = FALSE; ! 652: } ! 653: ! 654: // now get each clipping rectangle from the engine, and ! 655: // send it down to the printer. ! 656: ! 657: bMore = TRUE; ! 658: ! 659: cRects = 0; ! 660: ! 661: while(bMore) ! 662: { ! 663: bMore = CLIPOBJ_bEnum(pco, sizeof(buffer), &buffer.c); ! 664: ! 665: if (buffer.c == 0) ! 666: { ! 667: bMore = FALSE; ! 668: break; ! 669: } ! 670: ! 671: ps_box(pdev, &buffer.arcl[0]); ! 672: ! 673: if (prclClipBound) ! 674: { ! 675: if (rclClipBound.top > buffer.arcl[0].top) ! 676: rclClipBound.top = buffer.arcl[0].top; ! 677: ! 678: if (rclClipBound.left > buffer.arcl[0].left) ! 679: rclClipBound.left = buffer.arcl[0].left; ! 680: ! 681: if (rclClipBound.right < buffer.arcl[0].right) ! 682: rclClipBound.right = buffer.arcl[0].right; ! 683: ! 684: if (rclClipBound.bottom < buffer.arcl[0].bottom) ! 685: rclClipBound.bottom = buffer.arcl[0].bottom; ! 686: } ! 687: ! 688: if (pbMoreClipping) ! 689: { ! 690: cRects++; ! 691: if (cRects >= cRectLimit) ! 692: { ! 693: *pbMoreClipping = TRUE; ! 694: break; ! 695: } ! 696: } ! 697: } ! 698: ! 699: // now intersect our new complex region with the existing ! 700: // clipping region. ! 701: ! 702: if (prclClipBound) ! 703: *prclClipBound = rclClipBound; ! 704: ! 705: break; ! 706: ! 707: default: ! 708: // if we get here, we have been passed an invalid pco->iDComplexity. ! 709: // in this case, we will RIP, then treat as trivial clipping case. ! 710: ! 711: RIP("vDoClipObj: invalid pco->iDComplexity.\n"); ! 712: } ! 713: ! 714: return(TRUE); ! 715: } ! 716: ! 717: ! 718: //-------------------------------------------------------------------------- ! 719: // BOOL DrawGlyphs(pdev, cGlyphs, pgp, pfo, pstro, pdata, pwsz) ! 720: // PDEVDATA pdev; ! 721: // DWORD cGlyphs; ! 722: // GLYPHPOS *pgp; ! 723: // FONTOBJ *pfo; ! 724: // STROBJ *pstro; ! 725: // TEXTDATA *pdata; ! 726: // PWSZ pwsz; ! 727: // ! 728: // This routine will output the given glyph at the given position. ! 729: // ! 730: // Parameters: ! 731: // pdev ! 732: // Pointer to our DEVDATA structure. ! 733: // ! 734: // Returns: ! 735: // This routine returns no value. ! 736: // ! 737: // History: ! 738: // 26-Apr-1991 -by- Kent Settle (kentse) ! 739: // Wrote it. ! 740: //-------------------------------------------------------------------------- ! 741: ! 742: BOOL DrawGlyphs(pdev, cGlyphs, pgp, pfo, pstro, pdata, pwsz) ! 743: PDEVDATA pdev; ! 744: DWORD cGlyphs; ! 745: GLYPHPOS *pgp; ! 746: FONTOBJ *pfo; ! 747: STROBJ *pstro; ! 748: TEXTDATA *pdata; ! 749: PWSZ pwsz; ! 750: { ! 751: DWORD cTmp; ! 752: PS_FIX psfxWidth, psfxHeight; ! 753: DLFONT *pDLFont; ! 754: BOOL bString; ! 755: DWORD i; ! 756: FLONG flAccel; ! 757: PWSTR pwstrString; ! 758: ! 759: // get a local copy of the accelerators to munge with. ! 760: ! 761: flAccel = pstro->flAccel; ! 762: ! 763: // if we have a TrueType font, and we are doing font substitution, ! 764: // ignore the SO_FLAG_DEFAULT_PLACEMENT flag. ie, let the engine tell ! 765: // us where to place each character. ! 766: ! 767: if (pdata->bFontSubstitution) ! 768: flAccel &= ~SO_FLAG_DEFAULT_PLACEMENT; ! 769: ! 770: if (cGlyphs != 0) ! 771: { ! 772: // position the first character of the string. ! 773: ! 774: ps_moveto(pdev, &pgp->ptl); ! 775: ! 776: // if we have non-standard spacing for the device font, ! 777: // output an array of character widths, and push the ! 778: // current point on the stack for use in the kshow command. ! 779: ! 780: if (!(flAccel & SO_FLAG_DEFAULT_PLACEMENT)) ! 781: { ! 782: cTmp = cGlyphs - 1; ! 783: ! 784: // we need to handle the different STROBJ accelerators ! 785: // here. these accelerators only affect us if the font ! 786: // is not using the default placement. ! 787: ! 788: if (flAccel & SO_HORIZONTAL) ! 789: { ! 790: if (pdata->bJustification && (cGlyphs > 1)) ! 791: { ! 792: // if we did the justification calculations and found ! 793: // that the justification widths were zero, do nothing ! 794: // here. ! 795: ! 796: if ((pdata->ptSpace.x != 0) || (pdata->ptNonSpace.x != 0)) ! 797: { ! 798: PrintPSFIX(pdev, 2, pdata->ptSpace.x, pdata->ptSpace.y); ! 799: PrintString(pdev, " 8#040 "); ! 800: PrintPSFIX(pdev, 2, pdata->ptNonSpace.x, pdata->ptNonSpace.y); ! 801: PrintString(pdev, "\n"); ! 802: } ! 803: } ! 804: else ! 805: { ! 806: // set up to output array of widths in reverse order, ! 807: // since we will get them off the stack. ! 808: ! 809: pgp += cGlyphs - 1; ! 810: ! 811: #if 0 ! 812: //!!! This is just plain wrong!!! -kentse. ! 813: // deal with fixed pitch fonts. ! 814: ! 815: if (pstro->ulCharInc) ! 816: { ! 817: // we have a fixed pitch font, and the fixed ! 818: // character increment can be found in pstro->ulCharInc. ! 819: ! 820: lCharInc = (LONG)pstro->ulCharInc; ! 821: ! 822: if (flAccel & SO_REVERSED) ! 823: lCharInc *= -1; ! 824: ! 825: // output the increment value. ! 826: ! 827: PrintDecimal(pdev, 1, lCharInc); ! 828: PrintString(pdev, " "); ! 829: } ! 830: else // must be a proportional font. ! 831: { ! 832: // output the character width for each glyph. ! 833: ! 834: i = 0; ! 835: while (cTmp--) ! 836: { ! 837: psfxWidth = X72DPI(pgp->ptl.x) - X72DPI((pgp - 1)->ptl.x); ! 838: pgp--; ! 839: PrintPSFIX(pdev, 1, psfxWidth); ! 840: PrintString(pdev, " "); ! 841: ! 842: // make it readable. ! 843: ! 844: if (i++ == 10) ! 845: { ! 846: PrintString(pdev, "\n"); ! 847: i = 0; ! 848: } ! 849: } ! 850: } ! 851: #endif ! 852: // output the character width for each glyph. ! 853: ! 854: i = 0; ! 855: while (cTmp--) ! 856: { ! 857: psfxWidth = X72DPI(pgp->ptl.x) - X72DPI((pgp - 1)->ptl.x); ! 858: pgp--; ! 859: PrintPSFIX(pdev, 1, psfxWidth); ! 860: PrintString(pdev, " "); ! 861: ! 862: // make it readable. ! 863: ! 864: if (i++ == 10) ! 865: { ! 866: PrintString(pdev, "\n"); ! 867: i = 0; ! 868: } ! 869: } ! 870: } ! 871: } ! 872: ! 873: else if (flAccel & SO_VERTICAL) ! 874: { ! 875: // set up to output array of widths in reverse order, ! 876: // since we will get them off the stack. ! 877: ! 878: pgp += cGlyphs - 1; ! 879: ! 880: #if 0 ! 881: //!!! this is just plain wrong!!! -kentse. ! 882: // deal with fixed pitch fonts. ! 883: ! 884: if (pstro->ulCharInc) ! 885: { ! 886: // we have a fixed pitch font, and the fixed ! 887: // character increment can be found in pstro->ulCharInc. ! 888: ! 889: lCharInc = (LONG)pstro->ulCharInc; ! 890: ! 891: if (flAccel & SO_REVERSED) ! 892: lCharInc *= -1; ! 893: ! 894: // output the increment value. ! 895: ! 896: PrintDecimal(pdev, 1, lCharInc); ! 897: PrintString(pdev, " "); ! 898: } ! 899: else // must be a proportional font. ! 900: { ! 901: // output the character width for each glyph. ! 902: ! 903: while (cTmp--) ! 904: { ! 905: psfxHeight = X72DPI(pgp->ptl.y) - X72DPI((pgp - 1)->ptl.y); ! 906: pgp--; ! 907: PrintPSFIX(pdev, 1, psfxHeight); ! 908: PrintString(pdev, " "); ! 909: } ! 910: } ! 911: #endif ! 912: // output the character width for each glyph. ! 913: ! 914: while (cTmp--) ! 915: { ! 916: psfxHeight = X72DPI(pgp->ptl.y) - X72DPI((pgp - 1)->ptl.y); ! 917: pgp--; ! 918: PrintPSFIX(pdev, 1, psfxHeight); ! 919: PrintString(pdev, " "); ! 920: } ! 921: } ! 922: else // the general case. ! 923: { ! 924: // in the general case, we are printing a string which ! 925: // does not use the default character spacing, and is ! 926: // not horizontal or vertical. in this case, we must ! 927: // do a moveto and a show command for every character. ! 928: ! 929: if (pdata->bDeviceFont) ! 930: { ! 931: // it should be noted that pwstrString is only used ! 932: // if substitution is on, so we do not have to worry ! 933: // about the fact that pstro->pwszOrg is not filled ! 934: // in for device fonts. we do not use the pstro->pwszOrg ! 935: // directly because the STROBJ_bEnum may be "chunking" ! 936: // the data. therefore we will use the current pos. ! 937: // string pointer passed in. it is the caller's ! 938: // responsibility to keep this current. ! 939: ! 940: pwstrString = pwsz; ! 941: ! 942: while (cGlyphs--) ! 943: { ! 944: ps_moveto(pdev, &pgp->ptl); ! 945: ! 946: // output a left paren to open the string. ! 947: ! 948: PrintString(pdev, "("); ! 949: ! 950: // output each character of the string to the printer. ! 951: // if we are doing font substitution then we are substituting ! 952: // a device font for a truetype font. it is assumed that ! 953: // the hglyphs for the truetype font are the unicode character ! 954: // codes. ! 955: ! 956: if (pdata->bFontSubstitution) ! 957: { ! 958: if (!(RemapUnicodeChar(pdev, pwstrString++, pstro, ! 959: flAccel, FALSE, pdata))) ! 960: { ! 961: RIP("PSCRIPT!DrawGlyphs: RemapUnicodeChar failed.\n"); ! 962: return(FALSE); ! 963: } ! 964: } ! 965: else ! 966: { ! 967: if (!(RemapDeviceChar(pdev, (CHAR *)&pgp->hg, pstro, ! 968: flAccel, FALSE, pdata))) ! 969: { ! 970: RIP("PSCRIPT!DrawGlyphs: RemapDeviceChar failed.\n"); ! 971: return(FALSE); ! 972: } ! 973: } ! 974: ! 975: // close the string and send out the show command, ! 976: // abreviated by 't'. ! 977: ! 978: PrintString(pdev, ")t\n"); ! 979: ! 980: // point to the next character. ! 981: ! 982: pgp++; ! 983: } ! 984: ! 985: } ! 986: else // must be a GDI font. ! 987: { ! 988: // get a pointer to our downloaded font structure for this ! 989: // font. ! 990: ! 991: pDLFont = pdev->cgs.pDLFonts; ! 992: ! 993: for (i = 0; i < pdev->iDLFonts; i++) ! 994: { ! 995: // is this entry the one we are looking for? ! 996: ! 997: if (pDLFont->iUniq == pfo->iUniq) ! 998: break; ! 999: ! 1000: pDLFont++; ! 1001: } ! 1002: ! 1003: while (cGlyphs--) ! 1004: { ! 1005: ps_moveto(pdev, &pgp->ptl); ! 1006: ! 1007: // output a left paren to open the string. ! 1008: ! 1009: PrintString(pdev, "("); ! 1010: ! 1011: // set a flag stating that we are now within a string. ! 1012: ! 1013: bString = TRUE; ! 1014: ! 1015: // output each character of the string to the printer. ! 1016: ! 1017: if (!(RemapGDIChar(pdev, pstro, pgp, pDLFont, &bString, ! 1018: flAccel, pdata))) ! 1019: { ! 1020: RIP("PSCRIPT!DrawGlyphs: RemapGDIChar failed.\n"); ! 1021: return(FALSE); ! 1022: } ! 1023: ! 1024: // close the string and send out the show command, ! 1025: // abreviated by 't'. ! 1026: ! 1027: PrintString(pdev, ")t\n"); ! 1028: ! 1029: // point to the next character. ! 1030: ! 1031: pgp++; ! 1032: } ! 1033: } ! 1034: } ! 1035: ! 1036: if ((pstro->cGlyphs != 1) && (!pdata->bJustification) && ! 1037: ((flAccel & SO_HORIZONTAL) || (flAccel & SO_VERTICAL))) ! 1038: { ! 1039: // pgp should now point back to where it did before ! 1040: // we entered this if statement. ! 1041: ! 1042: PrintString(pdev, "a\n"); // 'a' is abrev for currentpoint. ! 1043: } ! 1044: } // end of !SO_FLAG_DEFAULT_PLACEMENT. ! 1045: ! 1046: if ((flAccel & SO_FLAG_DEFAULT_PLACEMENT) || ! 1047: (flAccel & SO_HORIZONTAL) || ! 1048: (flAccel & SO_VERTICAL)) ! 1049: { ! 1050: // output a left paren to open the string. ! 1051: ! 1052: PrintString(pdev, "("); ! 1053: ! 1054: // set a flag stating that we are NOT within a string, until ! 1055: // the first character is actually output. this is necessary ! 1056: // to prevent problems in the HORIZONTAL and VERTICAL cases, ! 1057: // when remapping a font. ! 1058: ! 1059: bString = FALSE; ! 1060: ! 1061: if (pdata->bDeviceFont) ! 1062: { ! 1063: // output each character of the string to the printer. ! 1064: // if we are doing font substitution then we are substituting ! 1065: // a device font for a truetype font. it is assumed that ! 1066: // the hglyphs for the truetype font are the unicode character ! 1067: // codes. ! 1068: ! 1069: if (pdata->bFontSubstitution) ! 1070: { ! 1071: ! 1072: pwstrString = pwsz; ! 1073: ! 1074: // output the first character of the string, then ! 1075: // set the flag stating that we have actually ! 1076: // sent out a character. this prevents us from ! 1077: // setting the flag within the loop. ! 1078: ! 1079: if (!(RemapUnicodeChar(pdev, pwstrString++, pstro, ! 1080: flAccel, bString, pdata))) ! 1081: { ! 1082: RIP("PSCRIPT!DrawGlyphs: RemapUnicodeChar failed.\n"); ! 1083: return(FALSE); ! 1084: } ! 1085: ! 1086: // set the flag stating that we have actually printed ! 1087: // a character. ! 1088: ! 1089: bString = TRUE; ! 1090: cGlyphs--; ! 1091: ! 1092: while (cGlyphs--) ! 1093: { ! 1094: if (!(RemapUnicodeChar(pdev, pwstrString++, pstro, ! 1095: flAccel, bString, pdata))) ! 1096: { ! 1097: RIP("PSCRIPT!DrawGlyphs: RemapUnicodeChar failed.\n"); ! 1098: return(FALSE); ! 1099: } ! 1100: ! 1101: // point to the next character. ! 1102: ! 1103: pgp++; ! 1104: } ! 1105: } ! 1106: else ! 1107: { ! 1108: // output the first character of the string, then ! 1109: // set the flag stating that we have actually ! 1110: // sent out a character. this prevents us from ! 1111: // setting the flag within the loop. ! 1112: ! 1113: if (!(RemapDeviceChar(pdev, (CHAR *)&pgp->hg, pstro, flAccel, ! 1114: bString, pdata))) ! 1115: { ! 1116: RIP("PSCRIPT!DrawGlyphs: RemapDeviceChar failed.\n"); ! 1117: return(FALSE); ! 1118: } ! 1119: ! 1120: // set the flag stating that we have actually printed ! 1121: // a character. ! 1122: ! 1123: bString = TRUE; ! 1124: cGlyphs--; ! 1125: ! 1126: // point to the next character. ! 1127: ! 1128: pgp++; ! 1129: ! 1130: while (cGlyphs--) ! 1131: { ! 1132: if (!(RemapDeviceChar(pdev, (CHAR *)&pgp->hg, pstro, flAccel, ! 1133: bString, pdata))) ! 1134: { ! 1135: RIP("PSCRIPT!DrawGlyphs: RemapDeviceChar failed.\n"); ! 1136: return(FALSE); ! 1137: } ! 1138: ! 1139: // point to the next character. ! 1140: ! 1141: pgp++; ! 1142: } ! 1143: } ! 1144: } ! 1145: else // must be a GDI font. ! 1146: { ! 1147: // get a pointer to our downloaded font structure for this ! 1148: // font. ! 1149: ! 1150: pDLFont = pdev->cgs.pDLFonts; ! 1151: ! 1152: for (i = 0; i < pdev->iDLFonts; i++) ! 1153: { ! 1154: // is this entry the one we are looking for? ! 1155: ! 1156: ! 1157: if (pDLFont->iUniq == pfo->iUniq) ! 1158: break; ! 1159: ! 1160: pDLFont++; ! 1161: } ! 1162: ! 1163: // in the GDI font case, bString simply means we have ! 1164: // begun a string, not necessaryly output a character. ! 1165: ! 1166: bString = TRUE; ! 1167: ! 1168: while (cGlyphs--) ! 1169: { ! 1170: if (!(RemapGDIChar(pdev, pstro, pgp, pDLFont, &bString, ! 1171: flAccel, pdata))) ! 1172: { ! 1173: RIP("PSCRIPT!DrawGlyphs: RemapGDIChar failed.\n"); ! 1174: return(FALSE); ! 1175: } ! 1176: ! 1177: // point to the next character. ! 1178: ! 1179: pgp++; ! 1180: } ! 1181: } ! 1182: ! 1183: if (bString) ! 1184: ps_show(pdev, pstro, flAccel, pdata); ! 1185: } ! 1186: } ! 1187: ! 1188: return(TRUE); ! 1189: } ! 1190: ! 1191: ! 1192: //-------------------------------------------------------------------- ! 1193: // BOOL RemapDeviceChar(pdev, pChar, pstro, flAccel, bString, pdata) ! 1194: // PDEVDATA pdev; ! 1195: // PCHAR pChar; ! 1196: // STROBJ *pstro; ! 1197: // FLONG flAccel; ! 1198: // BOOL bString; ! 1199: // TEXTDATA *pdata; ! 1200: // ! 1201: // This routine is passed a pointer to a PostScript character code. ! 1202: // This routine will output the proper string to the printer, representing ! 1203: // the specified character code. '(', ')' and '\' are preceded by a ! 1204: // backslash. Characters which do not require a font remapping are ! 1205: // output directly. All other characters are output with there octal ! 1206: // representation of their character code. ! 1207: // ! 1208: // Return: ! 1209: // This routine returns TRUE for success, FALSE for failure. ! 1210: // ! 1211: // History: ! 1212: // 26-Apr-1991 -by- Kent Settle (kentse) ! 1213: // Wrote it. ! 1214: // 14-Nov-1991 -by- Kent Settle [kentse] ! 1215: // re-wrote it (got rid of text buffer). ! 1216: //-------------------------------------------------------------------- ! 1217: ! 1218: BOOL RemapDeviceChar(pdev, pChar, pstro, flAccel, bString, pdata) ! 1219: PDEVDATA pdev; ! 1220: PCHAR pChar; ! 1221: STROBJ *pstro; ! 1222: FLONG flAccel; ! 1223: BOOL bString; ! 1224: TEXTDATA *pdata; ! 1225: { ! 1226: PUCMap pmap; ! 1227: BYTE jChar; ! 1228: BOOL bFound; ! 1229: CHAR Buffer[4]; ! 1230: CHAR *pBuffer; ! 1231: ! 1232: // format each character for output to the printer. ! 1233: ! 1234: pBuffer = Buffer; ! 1235: ! 1236: switch(*pChar) ! 1237: { ! 1238: case '(': ! 1239: case ')': ! 1240: case '\\': ! 1241: // precede each of the following characters with a backslash, ! 1242: // then output to printer. ! 1243: ! 1244: *pBuffer++ = '\\'; ! 1245: *pBuffer = *pChar; ! 1246: if (!bPSWrite(pdev, Buffer, 2)) ! 1247: { ! 1248: RIP("PSCRIPT!RemapDeviceChar: bPSWrite failed.\n"); ! 1249: return(FALSE); ! 1250: } ! 1251: break; ! 1252: ! 1253: default: ! 1254: // at this point we should check to see if the high ! 1255: // bit of the usPSValue in mapping.h is set. if it ! 1256: // is, remap the font, then output character. otherwise, ! 1257: // just output character. ! 1258: ! 1259: // get local pointer to mapping table for current font. ! 1260: ! 1261: pmap = pdev->cgs.pmap; ! 1262: ! 1263: // assume character not found in font. ! 1264: ! 1265: bFound = FALSE; ! 1266: ! 1267: while (pmap->szChar) ! 1268: { ! 1269: // search for the matching code in mapping.h. remember ! 1270: // that the high bit is used to indicate the font needs ! 1271: // to be remapped. so ignore the high bit while checking ! 1272: // for a character match. ! 1273: ! 1274: if (*pChar == (CHAR)pmap->usPSValue) ! 1275: { ! 1276: bFound = TRUE; ! 1277: ! 1278: // now check the high bit of the character code in ! 1279: // mapping.h. if it is set, we need to remap the ! 1280: // font for this character. ! 1281: ! 1282: jChar = *pChar; ! 1283: ! 1284: if ((pmap->usPSValue & 0x8000) || (jChar > 0x7F)) ! 1285: { ! 1286: if (pmap->usPSValue & 0x8000) ! 1287: { ! 1288: // remap the font here. ! 1289: ! 1290: RemapFont(pdev, pstro, flAccel, bString, pdata); ! 1291: } ! 1292: ! 1293: // we have an extended character. convert the ! 1294: // non-printable ASCII to backslash octal, and ! 1295: // output to printer. ! 1296: ! 1297: *pBuffer++ = '\\'; ! 1298: *pBuffer++ = (BYTE)((jChar >> 6) + '0'); ! 1299: jChar &= 63; ! 1300: *pBuffer++ = (BYTE)((jChar >> 3) + '0'); ! 1301: *pBuffer = (BYTE)((jChar & 7) + '0'); ! 1302: ! 1303: if (!bPSWrite(pdev, Buffer, 4)) ! 1304: { ! 1305: RIP("PSCRIPT!RemapDeviceChar: bPSWrite failed.\n"); ! 1306: return(FALSE); ! 1307: } ! 1308: } ! 1309: else ! 1310: { ! 1311: // simply write out the character. ! 1312: ! 1313: *pBuffer = *pChar; ! 1314: ! 1315: if (!bPSWrite(pdev, Buffer, 1)) ! 1316: { ! 1317: RIP("PSCRIPT!RemapDeviceChar: bPSWrite failed.\n"); ! 1318: return(FALSE); ! 1319: } ! 1320: } ! 1321: ! 1322: break; ! 1323: } ! 1324: ! 1325: // point to the next character in mapping.h. ! 1326: ! 1327: pmap++; ! 1328: } // while. ! 1329: ! 1330: // if the character was not found in the font, output ! 1331: // a period. ! 1332: ! 1333: if (!bFound) ! 1334: { ! 1335: *pBuffer = '.'; ! 1336: ! 1337: if (!bPSWrite(pdev, Buffer, 1)) ! 1338: { ! 1339: RIP("PSCRIPT!RemapDeviceChar: bPSWrite failed.\n"); ! 1340: return(FALSE); ! 1341: } ! 1342: } ! 1343: ! 1344: break; ! 1345: } // switch. ! 1346: ! 1347: return(TRUE); ! 1348: } ! 1349: ! 1350: ! 1351: //-------------------------------------------------------------------- ! 1352: // BOOL RemapUnicodeChar(pdev, pWChar, pstro, flAccel, bString, pdata) ! 1353: // PDEVDATA pdev; ! 1354: // PWCHAR pWChar; ! 1355: // STROBJ *pstro; ! 1356: // FLONG flAccel; ! 1357: // BOOL bString; ! 1358: // TEXTDATA *pdata; ! 1359: // ! 1360: // This routine is passed a pointer to a UNICODE character code. ! 1361: // This routine will output the proper string to the printer, representing ! 1362: // the specified character code. '(', ')' and '\' are preceded by a ! 1363: // backslash. Characters which do not require a font remapping are ! 1364: // output directly. All other characters are output with there octal ! 1365: // representation of their character code. ! 1366: // ! 1367: // Return: ! 1368: // This routine returns TRUE for success, FALSE for failure. ! 1369: // ! 1370: // History: ! 1371: // 27-Sep-1992 -by- Kent Settle (kentse) ! 1372: // Wrote it. ! 1373: //-------------------------------------------------------------------- ! 1374: ! 1375: BOOL RemapUnicodeChar(pdev, pWChar, pstro, flAccel, bString, pdata) ! 1376: PDEVDATA pdev; ! 1377: PWCHAR pWChar; ! 1378: STROBJ *pstro; ! 1379: FLONG flAccel; ! 1380: BOOL bString; ! 1381: TEXTDATA *pdata; ! 1382: { ! 1383: PUCMap pmap; ! 1384: BYTE jChar; ! 1385: BOOL bFound; ! 1386: CHAR Buffer[4]; ! 1387: CHAR *pBuffer; ! 1388: CHAR *pChar; ! 1389: ! 1390: // begin by finding the UNICODE character code in our mapping table. ! 1391: ! 1392: pmap = pdev->cgs.pmap; ! 1393: ! 1394: // assume character is NOT found in the font. ! 1395: ! 1396: bFound = FALSE; ! 1397: ! 1398: while (pmap->szChar) ! 1399: { ! 1400: if (*pWChar == pmap->usUCValue) ! 1401: { ! 1402: bFound = TRUE; ! 1403: break; ! 1404: } ! 1405: ! 1406: // this was not the character we wanted, check the next one. ! 1407: ! 1408: pmap++; ! 1409: } ! 1410: ! 1411: // if the character was not found, output a period. ! 1412: ! 1413: pBuffer = Buffer; ! 1414: ! 1415: if (!bFound) ! 1416: { ! 1417: *pBuffer = '.'; ! 1418: ! 1419: if (!bPSWrite(pdev, Buffer, 1)) ! 1420: { ! 1421: RIP("PSCRIPT!RemapUnicodeChar: bPSWrite failed.\n"); ! 1422: return(FALSE); ! 1423: } ! 1424: ! 1425: return(TRUE); ! 1426: } ! 1427: ! 1428: // now that we have found the UNICODE character code, get the ! 1429: // corresponding PostScript character code. ! 1430: ! 1431: pChar = (CHAR *)&pmap->usPSValue; ! 1432: ! 1433: // output the character to the printer in its proper format. ! 1434: ! 1435: switch(*pChar) ! 1436: { ! 1437: case '(': ! 1438: case ')': ! 1439: case '\\': ! 1440: // precede each of the following characters with a backslash, ! 1441: // then output to printer. ! 1442: ! 1443: *pBuffer++ = '\\'; ! 1444: *pBuffer = *pChar; ! 1445: if (!bPSWrite(pdev, Buffer, 2)) ! 1446: { ! 1447: RIP("PSCRIPT!RemapUnicodeChar: bPSWrite failed.\n"); ! 1448: return(FALSE); ! 1449: } ! 1450: break; ! 1451: ! 1452: default: ! 1453: // at this point we should check to see if the high ! 1454: // bit of the usPSValue in mapping.h is set. if it ! 1455: // is, remap the font, then output character. otherwise, ! 1456: // just output character. ! 1457: ! 1458: jChar = *pChar; ! 1459: ! 1460: if ((pmap->usPSValue & 0x8000) || (jChar > 0x7F)) ! 1461: { ! 1462: if (pmap->usPSValue & 0x8000) ! 1463: { ! 1464: // remap the font here. ! 1465: ! 1466: RemapFont(pdev, pstro, flAccel, bString, pdata); ! 1467: } ! 1468: ! 1469: // we have an extended character. convert the ! 1470: // non-printable ASCII to backslash octal, and ! 1471: // output to printer. ! 1472: ! 1473: *pBuffer++ = '\\'; ! 1474: *pBuffer++ = (BYTE)((jChar >> 6) + '0'); ! 1475: jChar &= 63; ! 1476: *pBuffer++ = (BYTE)((jChar >> 3) + '0'); ! 1477: *pBuffer = (BYTE)((jChar & 7) + '0'); ! 1478: ! 1479: if (!bPSWrite(pdev, Buffer, 4)) ! 1480: { ! 1481: RIP("PSCRIPT!RemapUnicodeChar: bPSWrite failed.\n"); ! 1482: return(FALSE); ! 1483: } ! 1484: } ! 1485: else ! 1486: { ! 1487: // simply write out the character. ! 1488: ! 1489: *pBuffer = *pChar; ! 1490: ! 1491: if (!bPSWrite(pdev, Buffer, 1)) ! 1492: { ! 1493: RIP("PSCRIPT!RemapUnicodeChar: bPSWrite failed.\n"); ! 1494: return(FALSE); ! 1495: } ! 1496: } ! 1497: } // switch ! 1498: ! 1499: return(TRUE); ! 1500: } ! 1501: ! 1502: ! 1503: //-------------------------------------------------------------------- ! 1504: // BOOL RemapGDIChar(pdev, pstro, pgp, pDLFont, pbString, flAccel, pdata) ! 1505: // PDEVDATA pdev; ! 1506: // STROBJ *pstro; ! 1507: // GLYPHPOS *pgp; ! 1508: // DLFONT *pDLFont; ! 1509: // BOOL *pbString; ! 1510: // FLONG flAccel; ! 1511: // TEXTDATA *pdata; ! 1512: // ! 1513: // This routine is passed a pointer to a GLYPHPOS structure. ! 1514: // This routine will output the proper string to the printer, representing ! 1515: // the specified character code. '(', ')' and '\' are preceded by a ! 1516: // backslash. Characters which are located within the downloaded font are ! 1517: // output directly. Any other character will cause the current string ! 1518: // to be closed, and a show command to be issued. Then the current character ! 1519: // will be drawn, either by bitblt or a path. ! 1520: // ! 1521: // Return: ! 1522: // This routine returns TRUE for success, FALSE for failure. ! 1523: // ! 1524: // History: ! 1525: // 27-Mar-1992 -by- Kent Settle (kentse) ! 1526: // Wrote it. ! 1527: //-------------------------------------------------------------------- ! 1528: ! 1529: BOOL RemapGDIChar(pdev, pstro, pgp, pDLFont, pbString, flAccel, pdata) ! 1530: PDEVDATA pdev; ! 1531: STROBJ *pstro; ! 1532: GLYPHPOS *pgp; ! 1533: DLFONT *pDLFont; ! 1534: BOOL *pbString; ! 1535: FLONG flAccel; ! 1536: TEXTDATA *pdata; ! 1537: { ! 1538: BOOL bFound; ! 1539: CHAR Buffer[4]; ! 1540: CHAR *pBuffer; ! 1541: DWORD i; ! 1542: HGLYPH hglyph; ! 1543: HGLYPH *phg; ! 1544: BYTE jCurrent; ! 1545: ! 1546: // point to internal buffer to build character code into. ! 1547: ! 1548: pBuffer = Buffer; ! 1549: ! 1550: // get the handle for the current glyph. then find the corresponding ! 1551: // character code, as defined in the downloaded font. ! 1552: ! 1553: bFound = FALSE; ! 1554: hglyph = pgp->hg; ! 1555: ! 1556: #if DBG ! 1557: if (hglyph == HGLYPH_INVALID) ! 1558: { ! 1559: RIP("PSCRIPT!RemapGDIChar: hglyph is zero, we're hosed.\n"); ! 1560: return(FALSE); ! 1561: } ! 1562: #endif ! 1563: ! 1564: phg = pDLFont->phgVector; ! 1565: ! 1566: for (i = 0; i < pDLFont->cGlyphs; i++) ! 1567: { ! 1568: if (*phg == hglyph) ! 1569: { ! 1570: bFound = TRUE; ! 1571: break; ! 1572: } ! 1573: ! 1574: phg++; ! 1575: } ! 1576: ! 1577: // i contains the character code for the printer, assuming it was ! 1578: // found in the downloaded font. ! 1579: ! 1580: jCurrent = (BYTE)i; ! 1581: ! 1582: // if the character was found in the downloaded font, we will be ! 1583: // outputting it as part of a string. otherwise, we will be drawing ! 1584: // it via imagemask or as a path. ! 1585: ! 1586: if (bFound) ! 1587: { ! 1588: // the character is part of the downloaded font. so output the ! 1589: // character code as part of a string. we must, however, check ! 1590: // to see if a string already exists to add it to, or if we must ! 1591: // start a new one. ! 1592: ! 1593: if (*pbString == FALSE) ! 1594: { ! 1595: // we are not in the middle of a string, so we must begin ! 1596: // a new one. ! 1597: ! 1598: ps_moveto(pdev, &pgp->ptl); ! 1599: ! 1600: // output a left paren to open the string. ! 1601: ! 1602: PrintString(pdev, "("); ! 1603: } ! 1604: ! 1605: // we are now guaranteed to be in the middle of a string, so ! 1606: // simply output the character code. ! 1607: ! 1608: switch(jCurrent) ! 1609: { ! 1610: case '(': ! 1611: case ')': ! 1612: case '\\': ! 1613: // precede each of the following characters with a backslash, ! 1614: // then output to printer. ! 1615: ! 1616: *pBuffer++ = '\\'; ! 1617: *pBuffer = jCurrent; ! 1618: if (!bPSWrite(pdev, Buffer, 2)) ! 1619: { ! 1620: RIP("PSCRIPT!RemapGDIChar: bPSWrite failed.\n"); ! 1621: return(FALSE); ! 1622: } ! 1623: break; ! 1624: ! 1625: default: ! 1626: // if the character code is within the printable ASCII ! 1627: // range, simply write out the character. otherwise, ! 1628: // we need to output the three digit octal character code. ! 1629: ! 1630: if ((jCurrent >= 0x20) && (jCurrent <= 0x7F)) ! 1631: { ! 1632: if (!bPSWrite(pdev, &jCurrent, 1)) ! 1633: { ! 1634: RIP("PSCRIPT!RemapGDIChar: bPSWrite failed.\n"); ! 1635: return(FALSE); ! 1636: } ! 1637: } ! 1638: else ! 1639: { ! 1640: // convert the non-printable ASCII to backslash octal, ! 1641: // and output to the printer. ! 1642: ! 1643: *pBuffer++ = '\\'; ! 1644: *pBuffer++ = (BYTE)((jCurrent >> 6) + '0'); ! 1645: jCurrent &= 63; ! 1646: *pBuffer++ = (BYTE)((jCurrent >> 3) + '0'); ! 1647: *pBuffer = (BYTE)((jCurrent & 7) + '0'); ! 1648: ! 1649: if (!bPSWrite(pdev, Buffer, 4)) ! 1650: { ! 1651: RIP("PSCRIPT!RemapGDIChar: bPSWrite failed.\n"); ! 1652: return(FALSE); ! 1653: } ! 1654: } ! 1655: break; ! 1656: } // end of switch. ! 1657: ! 1658: // set the flag stating that we are now within a string. ! 1659: ! 1660: *pbString = TRUE; ! 1661: } ! 1662: else // character not found in downloaded font. ! 1663: { ! 1664: // the character is NOT part of the downloaded font. so we must ! 1665: // actually draw the character. we must, however, check to see ! 1666: // if an open string already exists in the printer, and close it ! 1667: // if it does. ! 1668: ! 1669: if (*pbString) ! 1670: { ! 1671: // we are in the middle of a string, so we must end it before ! 1672: // we can draw the current character. ! 1673: ! 1674: ps_show(pdev, pstro, flAccel, pdata); ! 1675: } ! 1676: ! 1677: // we are now ready to draw the character. ! 1678: ! 1679: //!!! for now only bitmap fonts are supported. we will support vector ! 1680: //!!! fonts whenever the engine does. -kentse. ! 1681: ! 1682: CharBitmap(pdev, pgp); ! 1683: ! 1684: // set the flag stating that we are now NOT within a string. ! 1685: ! 1686: *pbString = FALSE; ! 1687: } ! 1688: ! 1689: return(TRUE); ! 1690: } ! 1691: ! 1692: //-------------------------------------------------------------------- ! 1693: // BOOL SelectFont(pdev, pfo, pdata) ! 1694: // PDEVDATA pdev; ! 1695: // FONTOBJ *pfo; ! 1696: // TEXTDATA *pdata; ! 1697: // ! 1698: // This routine selects the font specified in the FONTOBJ, and selects ! 1699: // it as the current font in the printer. If the specified font is ! 1700: // already the current font in the printer, then this routine does ! 1701: // nothing. ! 1702: // ! 1703: // History: ! 1704: // 15-Jul-1992 -by- Kent Settle (kentse) ! 1705: // Added Font Substitution support. ! 1706: // 27-Feb-1992 -by- Kent Settle (kentse) ! 1707: // Added support for downloading, ie caching, GDI fonts. ! 1708: // 20-Feb-1992 -by- Kent Settle (kentse) ! 1709: // Added support for softfonts. ! 1710: // 26-Apr-1991 -by- Kent Settle (kentse) ! 1711: // Wrote it. ! 1712: //-------------------------------------------------------------------- ! 1713: ! 1714: BOOL SelectFont(pdev, pfo, pdata) ! 1715: PDEVDATA pdev; ! 1716: FONTOBJ *pfo; ! 1717: TEXTDATA *pdata; ! 1718: { ! 1719: PNTFM pntfm; ! 1720: BYTE *pSoftFont; ! 1721: DWORD cDownloadedFonts; ! 1722: DLFONT *pDLFont; ! 1723: PS_FIX psfxM11, psfxM12, psfxM21, psfxM22, psfxtmp; ! 1724: XFORM *pxform; ! 1725: ! 1726: // do not select the font in the printer if it is currently selected, ! 1727: // including the same point size. ! 1728: ! 1729: if (pfo->iUniq == pdev->cgs.lidFont) ! 1730: return(TRUE); ! 1731: ! 1732: // get the point size, and fill in the font xform. ! 1733: ! 1734: pdev->cgs.psfxScaleFactor = GetPointSize(pdev, pfo, &pdev->cgs.FontXform); ! 1735: ! 1736: #if DBG ! 1737: if (pdev->cgs.psfxScaleFactor == 0) ! 1738: RIP("PSCRIPT!SelectFont: Zero point size!\n"); ! 1739: #endif ! 1740: ! 1741: // do not select the font into the printer if it is a GDI font that ! 1742: // we will not be caching. according to the DDI spec, if pfo->iUniq ! 1743: // is zero, the GDI font should not be cached. ! 1744: ! 1745: if (!pdata->bDeviceFont && (pfo->iUniq == 0)) ! 1746: { ! 1747: #if DBG ! 1748: DbgPrint("A non-cached GDI font made it to SelectFont, should it have?\n"); ! 1749: #endif ! 1750: return(TRUE); ! 1751: } ! 1752: ! 1753: // select the proper font name for the new font. if this is a ! 1754: // device font, get the name from the NTFM structure. if this ! 1755: // is a GDI font that we are caching, we will create a name for ! 1756: // it at the time we download it to the printer. ! 1757: ! 1758: if (pdata->bDeviceFont) ! 1759: { ! 1760: // get the font metrics for the specified font. ! 1761: ! 1762: pntfm = pdev->pfmtable[pdata->iFace - 1].pntfm; ! 1763: ! 1764: // if the font is a softfont, and it has not yet been downloaded, ! 1765: // download it. ! 1766: ! 1767: if ((pdata->iFace > pdev->cDeviceFonts) && ! 1768: !((BYTE)pdev->cgs.pSFArray[pdata->iFace >> 3] & ! 1769: (BYTE)(1 << (pdata->iFace & 0x07)))) ! 1770: { ! 1771: pSoftFont = (BYTE *)pntfm + pntfm->loSoftFont; ! 1772: ! 1773: // if we have reached our downloaded font threshold, then ! 1774: // we will surround ever textout call with a save/restore. ! 1775: ! 1776: cDownloadedFonts = min(pdev->cgs.cDownloadedFonts, pdev->iDLFonts); ! 1777: ! 1778: if (cDownloadedFonts == pdev->iDLFonts) ! 1779: { ! 1780: ps_save(pdev, FALSE); ! 1781: pdev->cgs.dwFlags |= CGS_DLFONTTHRESHOLD; ! 1782: } ! 1783: ! 1784: if (!bPSWrite(pdev, pSoftFont, pntfm->cjSoftFont)) ! 1785: { ! 1786: RIP("PSCRIPT!SelectFont: downloading of softfont failed.\n"); ! 1787: return(FALSE); ! 1788: } ! 1789: ! 1790: // set the bit saying this font has been downloaded. ! 1791: ! 1792: (BYTE)pdev->cgs.pSFArray[pdata->iFace >> 3] |= ! 1793: (BYTE)(1 << (pdata->iFace & 0x07)); ! 1794: ! 1795: // if we have hit our limit of Fonts we can download, simply overwrite ! 1796: // the last one with the new one. this is to try to conserve on ! 1797: // memory consumption. ! 1798: ! 1799: pDLFont = pdev->cgs.pDLFonts; ! 1800: pDLFont += cDownloadedFonts; ! 1801: ! 1802: pDLFont->iFace = pdata->iFace; ! 1803: pDLFont->iUniq = pfo->iUniq; ! 1804: pDLFont->cGlyphs = 0; ! 1805: pDLFont->phgVector = NULL; ! 1806: ! 1807: pdev->cgs.cDownloadedFonts++; ! 1808: } ! 1809: ! 1810: // select the font in the printer. ! 1811: ! 1812: strcpy(pdev->cgs.szFont, (char *)pntfm + pntfm->loszFontName); ! 1813: } ! 1814: else // must be a GDI font we will be caching. ! 1815: { ! 1816: //!!! the engine is not ready for outline fonts yet!!! -kentse. ! 1817: #if 0 ! 1818: // if this font has not yet been downloaded to the printer, ! 1819: // do it now. ! 1820: ! 1821: if (pfo->flFontType & TRUETYPE_FONTTYPE) ! 1822: { ! 1823: // determine the point size. ! 1824: ! 1825: ulPointSize = (ETOL(pdev->cgs.FontXform.eM22 * 72000) / ! 1826: pdev->psdm.dm.dmPrintQuality); ! 1827: ! 1828: if (ulPointSize < 10) ! 1829: DownloadBitmapFont(pdev, pfo); ! 1830: else ! 1831: DownloadOutlineFont(pdev, pfo); ! 1832: } ! 1833: else if (pfo->flFontType & RASTER_FONTTYPE) ! 1834: DownloadBitmapFont(pdev, pfo); ! 1835: #endif ! 1836: if ( (pfo->flFontType & TRUETYPE_FONTTYPE) || ! 1837: (pfo->flFontType & RASTER_FONTTYPE) ) ! 1838: DownloadBitmapFont(pdev, pfo); ! 1839: else ! 1840: { ! 1841: RIP("PSCRIPT!SelectFont: invalid pfo->flFontType.\n"); ! 1842: return(FALSE); ! 1843: } ! 1844: } ! 1845: ! 1846: // select the proper font, depending on whether or not the ! 1847: // font in question has been reencoded. also, output a scalefont ! 1848: // command if only scaling is ocurring, otherwise output a ! 1849: // makefont command. ! 1850: ! 1851: #if 0 ! 1852: PrintPSFIX(pdev, 1, pdev->cgs.psfxScaleFactor); ! 1853: ! 1854: if (QueryFontRemap(pdev, pfo->iUniq)) ! 1855: PrintString(pdev, " /_"); ! 1856: else ! 1857: PrintString(pdev, " /"); ! 1858: ! 1859: PrintString(pdev, pdev->cgs.szFont); ! 1860: PrintString(pdev, " SF\n"); ! 1861: #endif ! 1862: ! 1863: pxform = &pdev->cgs.FontXform; ! 1864: ! 1865: if ! 1866: ( ! 1867: ((pxform->eM11 == pxform->eM22) && ! 1868: (pxform->eM12 == 0) && ! 1869: (pxform->eM21 == 0) && ! 1870: !((*((ULONG *)&pxform->eM11)) & 0x80000000)) // if positive ! 1871: || ! 1872: ((pfo->flFontType & TRUETYPE_FONTTYPE) && !pdata->bFontSubstitution) // all scaling done already by tt driver ! 1873: ) ! 1874: { ! 1875: PrintPSFIX(pdev, 1, pdev->cgs.psfxScaleFactor); ! 1876: ! 1877: if (QueryFontRemap(pdev, pfo->iUniq)) ! 1878: PrintString(pdev, " /_"); ! 1879: else ! 1880: PrintString(pdev, " /"); ! 1881: ! 1882: PrintString(pdev, pdev->cgs.szFont); ! 1883: PrintString(pdev, " SF\n"); ! 1884: } ! 1885: else ! 1886: { ! 1887: // normalize the font transform by the emheight; ! 1888: ! 1889: psfxtmp = pdev->cgs.fwdEmHeight * PS_FIX_RESOLUTION; ! 1890: ! 1891: psfxM11 = (LONG)((pdev->cgs.FontXform.eM11 * (FLOAT)psfxtmp) / ! 1892: pdev->psdm.dm.dmPrintQuality); ! 1893: psfxM12 = (LONG)((pdev->cgs.FontXform.eM12 * (FLOAT)psfxtmp) / ! 1894: pdev->psdm.dm.dmPrintQuality); ! 1895: psfxM21 = (LONG)((pdev->cgs.FontXform.eM21 * (FLOAT)psfxtmp) / ! 1896: pdev->psdm.dm.dmPrintQuality); ! 1897: psfxM22 = (LONG)((pdev->cgs.FontXform.eM22 * (FLOAT)psfxtmp) / ! 1898: pdev->psdm.dm.dmPrintQuality); ! 1899: ! 1900: PrintString(pdev, "["); ! 1901: PrintPSFIX(pdev, 6, psfxM11, -psfxM12, -psfxM21, psfxM22,0,0); ! 1902: ! 1903: if (QueryFontRemap(pdev, pfo->iUniq)) ! 1904: PrintString(pdev, "] /_"); ! 1905: else ! 1906: PrintString(pdev, "] /"); ! 1907: ! 1908: PrintString(pdev, pdev->cgs.szFont); ! 1909: PrintString(pdev, " MF\n"); ! 1910: } ! 1911: ! 1912: // update the font in our current graphics state. ! 1913: ! 1914: pdev->cgs.lidFont = pfo->iUniq; ! 1915: ! 1916: // if we have a device font, point to the appropriate mapping table ! 1917: // in mapping.h. ! 1918: ! 1919: if (pdata->bDeviceFont) ! 1920: { ! 1921: if (!strcmp((char *)pntfm + pntfm->loszFontName, "Symbol")) ! 1922: pdev->cgs.pmap = SymbolMap; ! 1923: else if (!strcmp((char *)pntfm + pntfm->loszFontName, "ZapfDingbats")) ! 1924: pdev->cgs.pmap = DingbatsMap; ! 1925: else ! 1926: pdev->cgs.pmap = LatinMap; ! 1927: } ! 1928: ! 1929: return(TRUE); ! 1930: } ! 1931: ! 1932: ! 1933: //-------------------------------------------------------------------- ! 1934: // VOID RemapFont(pdev, pstro, flAccel, bString, pdata) ! 1935: // PDEVDATA pdev; ! 1936: // STROBJ *pstro; ! 1937: // FLONG flAccel; ! 1938: // BOOL bString; ! 1939: // TEXTDATA *pdata; ! 1940: // ! 1941: // This routine is only called if we have a character which does not ! 1942: // have the standard PostScript character code. This is determined ! 1943: // by checking the high bit of the usPSValue in the proper table in ! 1944: // mapping.h. If necessary, this routine will download a new ! 1945: // encoding vector. It will then reencode the current font to the ! 1946: // new encoding vector. ! 1947: // ! 1948: // History: ! 1949: // 12-Sep-1991 -by- Kent Settle (kentse) ! 1950: // Wrote it. ! 1951: //-------------------------------------------------------------------- ! 1952: ! 1953: VOID RemapFont(pdev, pstro, flAccel, bString, pdata) ! 1954: PDEVDATA pdev; ! 1955: STROBJ *pstro; ! 1956: FLONG flAccel; ! 1957: BOOL bString; ! 1958: TEXTDATA *pdata; ! 1959: { ! 1960: int i; ! 1961: PSZ *pszEncode; ! 1962: PSZ pszVector; ! 1963: int cbLength; ! 1964: PUCMap pmap; ! 1965: BOOL bFound; ! 1966: FLONG flEncoding; ! 1967: BOOL bRemapDone = FALSE; ! 1968: XFORM *pxform; ! 1969: PS_FIX psfxM11, psfxM12, psfxM21, psfxM22, psfxtmp; ! 1970: ! 1971: //!!! All this font remapping stuff gets blown away by a gsave/grestore ! 1972: //!!! which is done from DrvTextout when clipping. Perhaps move flags from ! 1973: //!!! CGS to PDEV. ! 1974: ! 1975: // if the font remapping header has not been downloaded to the ! 1976: // printer, do it now. this header is sent at most once per job. ! 1977: ! 1978: if (!(pdev->dwFlags & PDEV_FONTREDEFINED)) ! 1979: { ! 1980: // we are in the middle of outputting a string. close ! 1981: // the current string and output a show command to the ! 1982: // printer, output the remapping, then begin a new string. ! 1983: ! 1984: ps_show(pdev, pstro, flAccel, pdata); ! 1985: bRemapDone = TRUE; ! 1986: ! 1987: pszEncode = apszRemapCode; ! 1988: while (*pszEncode) ! 1989: { ! 1990: PrintString(pdev, (PSZ)*pszEncode++); ! 1991: PrintString(pdev, "\n"); ! 1992: } ! 1993: ! 1994: pdev->dwFlags |= PDEV_FONTREDEFINED; ! 1995: } ! 1996: ! 1997: // select the proper encoding vector to download. ! 1998: ! 1999: if (pdev->cgs.pmap == SymbolMap) ! 2000: { ! 2001: pszVector = "SYMENC"; ! 2002: flEncoding = PDEV_SYMENCODED; ! 2003: } ! 2004: else if (pdev->cgs.pmap == DingbatsMap) ! 2005: { ! 2006: pszVector = "DINGENC"; ! 2007: flEncoding = PDEV_DINGENCODED; ! 2008: } ! 2009: else ! 2010: { ! 2011: pszVector = "LATENC"; ! 2012: flEncoding = PDEV_LATINENCODED; ! 2013: } ! 2014: ! 2015: // define the new font encoding if it has not already been done. ! 2016: ! 2017: if ((pdev->dwFlags & flEncoding) == 0) ! 2018: { ! 2019: if (!bRemapDone) ! 2020: { ! 2021: // we are in the middle of outputting a string. close ! 2022: // the current string and output a show command to the ! 2023: // printer, output the remapping, then begin a new string. ! 2024: ! 2025: ps_show(pdev, pstro, flAccel, pdata); ! 2026: bRemapDone = TRUE; ! 2027: } ! 2028: ! 2029: // download the new encoding vector. just to make things readable, ! 2030: // let's limit the line length. ! 2031: ! 2032: cbLength = 0; ! 2033: ! 2034: PrintString(pdev, "/"); ! 2035: PrintString(pdev, pszVector); ! 2036: PrintString(pdev, " [0\n"); ! 2037: ! 2038: // PostScript fonts containg 256 characters. for each character, ! 2039: // do a lookup in the appropriate mapping table in mapping.h to ! 2040: // get the ASCII name of the character to output in the encoding ! 2041: // vector. if the character is not found in the encoding vector, ! 2042: // output ".notdef" for that character. ! 2043: ! 2044: for (i = 0; i < 256; i++) ! 2045: { ! 2046: if (cbLength > MAX_LINE_LENGTH) ! 2047: { ! 2048: // skip to the next line. ! 2049: ! 2050: PrintString(pdev, "\n"); ! 2051: cbLength = 0; ! 2052: } ! 2053: ! 2054: // get local pointer to mapping table for current font. ! 2055: ! 2056: pmap = pdev->cgs.pmap; ! 2057: ! 2058: // assume character not found in font. ! 2059: ! 2060: bFound = FALSE; ! 2061: ! 2062: while (pmap->szChar) ! 2063: { ! 2064: // search for the matching code in mapping.h. remember ! 2065: // that the high bit is used to indicate the font needs ! 2066: // to be remapped. so ignore the high bit while checking ! 2067: // for a character match. ! 2068: ! 2069: if ((CHAR)i == (CHAR)pmap->usPSValue) ! 2070: { ! 2071: bFound = TRUE; ! 2072: ! 2073: PrintString(pdev, "/"); ! 2074: PrintString(pdev, pmap->szChar); ! 2075: ! 2076: cbLength += (strlen(pmap->szChar) + 1); ! 2077: break; ! 2078: } ! 2079: ! 2080: // point to the next character in mapping.h. ! 2081: ! 2082: pmap++; ! 2083: } // while. ! 2084: ! 2085: // if the character was not found in the font, output .notdef. ! 2086: ! 2087: if (!bFound) ! 2088: { ! 2089: PrintString(pdev, "/.notdef"); ! 2090: cbLength += 8; ! 2091: } ! 2092: } ! 2093: ! 2094: // we are done downloading the encoding vector. ! 2095: ! 2096: PrintString(pdev, "\n]def\n"); ! 2097: ! 2098: // mark that this encoding vector is now defined in the printer. ! 2099: ! 2100: pdev->dwFlags |= flEncoding; ! 2101: } ! 2102: ! 2103: // output the PostScript commands to reencode the current font ! 2104: // using the proper encoding vector, if the current font has ! 2105: // not already been reencoded. ! 2106: ! 2107: if (!QueryFontRemap(pdev, pdev->cgs.lidFont)) ! 2108: { ! 2109: if (!bRemapDone) ! 2110: { ! 2111: // we are in the middle of outputting a string. close ! 2112: // the current string and output a show command to the ! 2113: // printer, output the remapping, then begin a new string. ! 2114: ! 2115: ps_show(pdev, pstro, flAccel, pdata); ! 2116: bRemapDone = TRUE; ! 2117: } ! 2118: ! 2119: PrintString(pdev, pszVector); ! 2120: PrintString(pdev, " /_"); ! 2121: PrintString(pdev, pdev->cgs.szFont); ! 2122: PrintString(pdev, " /"); ! 2123: PrintString(pdev, pdev->cgs.szFont); ! 2124: PrintString(pdev, " reencode\n"); ! 2125: ! 2126: // select the newly reencoded font. ! 2127: ! 2128: pxform = &pdev->cgs.FontXform; ! 2129: ! 2130: if ! 2131: ( ! 2132: (pxform->eM11 == pxform->eM22) && ! 2133: (pxform->eM12 == 0) && ! 2134: (pxform->eM21 == 0) && ! 2135: !((*((ULONG *)&pxform->eM11)) & 0x80000000) // if positive ! 2136: ) ! 2137: { ! 2138: PrintPSFIX(pdev, 1, pdev->cgs.psfxScaleFactor); ! 2139: PrintString(pdev, " /_"); ! 2140: PrintString(pdev, pdev->cgs.szFont); ! 2141: PrintString(pdev, " SF\n"); ! 2142: } ! 2143: else ! 2144: { ! 2145: // normalize the font transform by the emheight; ! 2146: ! 2147: psfxtmp = pdev->cgs.fwdEmHeight * PS_FIX_RESOLUTION; ! 2148: ! 2149: psfxM11 = (LONG)((pdev->cgs.FontXform.eM11 * (FLOAT)psfxtmp) / ! 2150: pdev->psdm.dm.dmPrintQuality); ! 2151: psfxM12 = (LONG)((pdev->cgs.FontXform.eM12 * (FLOAT)psfxtmp) / ! 2152: pdev->psdm.dm.dmPrintQuality); ! 2153: psfxM21 = (LONG)((pdev->cgs.FontXform.eM21 * (FLOAT)psfxtmp) / ! 2154: pdev->psdm.dm.dmPrintQuality); ! 2155: psfxM22 = (LONG)((pdev->cgs.FontXform.eM22 * (FLOAT)psfxtmp) / ! 2156: pdev->psdm.dm.dmPrintQuality); ! 2157: ! 2158: PrintString(pdev, "["); ! 2159: PrintPSFIX(pdev, 6, psfxM11, -psfxM12, -psfxM21, psfxM22,0,0); ! 2160: ! 2161: PrintString(pdev, "] /_"); ! 2162: PrintString(pdev, pdev->cgs.szFont); ! 2163: PrintString(pdev, " MF\n"); ! 2164: } ! 2165: ! 2166: // set a flag saying that the current font has been reencoded. ! 2167: ! 2168: SetFontRemap(pdev, pdev->cgs.lidFont); ! 2169: } ! 2170: ! 2171: // if any remapping was done, start a new string. ! 2172: ! 2173: if (bRemapDone) ! 2174: { ! 2175: if ((flAccel == 0) || (flAccel & SO_FLAG_DEFAULT_PLACEMENT)) ! 2176: PrintString(pdev, "("); ! 2177: else if ((flAccel & SO_HORIZONTAL) || (flAccel & SO_VERTICAL)) ! 2178: { ! 2179: // if we have a vertical or horizontal, non default spacing, ! 2180: // case, and we have just remapped a font, and we have actuall ! 2181: // printed at least one character within the string, then we need ! 2182: // to get rid of the with between the last character printed, then ! 2183: // get the current position on the stack before we begin our ! 2184: // string. ! 2185: ! 2186: if (pdata->bJustification) ! 2187: { ! 2188: // if we did the justification calculations and found ! 2189: // that the justification widths were zero, do nothing ! 2190: // here. ! 2191: ! 2192: if ((pdata->ptSpace.x != 0) || (pdata->ptNonSpace.x != 0)) ! 2193: { ! 2194: PrintPSFIX(pdev, 2, pdata->ptSpace.x, pdata->ptSpace.y); ! 2195: PrintString(pdev, " 8#040 "); ! 2196: PrintPSFIX(pdev, 2, pdata->ptNonSpace.x, pdata->ptNonSpace.y); ! 2197: PrintString(pdev, "\n"); ! 2198: } ! 2199: ! 2200: PrintString(pdev, "("); ! 2201: } ! 2202: else if (bString) ! 2203: PrintString(pdev, "pop a ("); ! 2204: else ! 2205: { ! 2206: if(pstro->cGlyphs != 1) ! 2207: PrintString(pdev, "a ("); ! 2208: else ! 2209: PrintString(pdev, "("); ! 2210: } ! 2211: } ! 2212: } ! 2213: } ! 2214: ! 2215: ! 2216: //-------------------------------------------------------------------- ! 2217: // VOID CharBitmap(pdev, pgp) ! 2218: // PDEVDATA pdev; ! 2219: // GLYPHPOS *pgp; ! 2220: // ! 2221: // This routine downloads the bitmap for the given character to ! 2222: // the printer. ! 2223: // ! 2224: // History: ! 2225: // 26-Sep-1991 -by- Kent Settle (kentse) ! 2226: // Wrote it. ! 2227: //-------------------------------------------------------------------- ! 2228: ! 2229: VOID CharBitmap(pdev, pgp) ! 2230: PDEVDATA pdev; ! 2231: GLYPHPOS *pgp; ! 2232: { ! 2233: POINTPSFX ptpsfx; ! 2234: int cjWidth; ! 2235: int i; ! 2236: BYTE *pjBits; ! 2237: LONG cx, cy; ! 2238: ! 2239: // adjust the (x, y) coordinates to adjust for displacement of ! 2240: // character origin from bitmap origin. ! 2241: ! 2242: pgp->ptl.x += pgp->pgdf->pgb->ptlOrigin.x; ! 2243: pgp->ptl.y += pgp->pgdf->pgb->ptlOrigin.y; ! 2244: ! 2245: // position the image on the page, remembering to flip the image ! 2246: // from top to bottom. ! 2247: ! 2248: ptpsfx.x = X72DPI(pgp->ptl.x); ! 2249: ptpsfx.y = Y72DPI(pgp->ptl.y); ! 2250: ! 2251: // output PostScript user coordinates to the printer. ! 2252: ! 2253: PrintString(pdev, "save "); ! 2254: PrintPSFIX(pdev, 2, ptpsfx.x, ptpsfx.y); ! 2255: PrintString(pdev, " translate\n"); ! 2256: ! 2257: // scale the image. ! 2258: //!!! I do not know how this ever worked if it did. [Bodind] ! 2259: ! 2260: // cx = pgp->pgdf->pgb->aj[0]; ! 2261: ! 2262: // cy = pgp->pgdf->pgb->aj[1]; ! 2263: ! 2264: ! 2265: cx = pgp->pgdf->pgb->sizlBitmap.cx; ! 2266: cy = pgp->pgdf->pgb->sizlBitmap.cy; ! 2267: ! 2268: ptpsfx.x = (cx * PS_FIX_RESOLUTION) / pdev->psdm.dm.dmPrintQuality; ! 2269: ptpsfx.y = (cy * PS_FIX_RESOLUTION) / pdev->psdm.dm.dmPrintQuality; ! 2270: ! 2271: PrintPSFIX(pdev, 2, ptpsfx.x, ptpsfx.y); ! 2272: PrintString(pdev, " scale\n"); ! 2273: ! 2274: // output the image operator and the scan data. true means to ! 2275: // paint the '1' bits with the foreground color. ! 2276: ! 2277: PrintDecimal(pdev, 2, cx, cy); ! 2278: PrintString(pdev, " true ["); ! 2279: PrintDecimal(pdev, 1, cx); ! 2280: PrintString(pdev, " 0 0 "); ! 2281: PrintDecimal(pdev, 1, -cy); ! 2282: PrintString(pdev, " 0 0]\n{<"); ! 2283: ! 2284: // how wide is the destination in bytes? postscript bitmaps are padded ! 2285: // to 8bit boundaries. ! 2286: ! 2287: cjWidth = (cx + 7) >> 3; ! 2288: ! 2289: //!!! this seems to be wrong, do not know why it ever worked if it did ! 2290: //!!! [bodind] ! 2291: // pjBits = (BYTE *)&pgp->pgdf->pgb->aj[2]; ! 2292: ! 2293: ! 2294: pjBits = pgp->pgdf->pgb->aj; ! 2295: ! 2296: for (i = 0; i < cy; i++) ! 2297: { ! 2298: // output each scanline to the printer. ! 2299: ! 2300: vHexOut(pdev, pjBits, cjWidth); ! 2301: pjBits += cjWidth; ! 2302: } ! 2303: ! 2304: PrintString(pdev, ">} im restore\n"); ! 2305: } ! 2306: ! 2307: ! 2308: //-------------------------------------------------------------------- ! 2309: // BOOL DownloadBitmapFont(pdev, pfo) ! 2310: // PDEVDATA pdev; ! 2311: // FONTOBJ *pfo; ! 2312: // ! 2313: // This routine downloads the font definition for the given bitmap font, ! 2314: // if it has not already been done. The font is downloaded as an ! 2315: // Adobe Type 3 font. ! 2316: // ! 2317: // This routine return TRUE if the font is successfully, or has already ! 2318: // been, downloaded to the printer. It returns FALSE if it fails. ! 2319: // ! 2320: // History: ! 2321: // 27-Feb-1992 -by- Kent Settle (kentse) ! 2322: // Wrote it. ! 2323: //-------------------------------------------------------------------- ! 2324: ! 2325: BOOL DownloadBitmapFont(pdev, pfo) ! 2326: PDEVDATA pdev; ! 2327: FONTOBJ *pfo; ! 2328: { ! 2329: DLFONT *pDLFont; ! 2330: DWORD i, j; ! 2331: DWORD cDownloadedFonts; ! 2332: DWORD cGlyphs, cTmp; ! 2333: HGLYPH *phg; ! 2334: HGLYPH *phgSave; ! 2335: GLYPHDATA *pglyphdata; ! 2336: POINTL ptlTL, ptlBR, ptl1; ! 2337: PIFIMETRICS pifi; ! 2338: PS_FIX psfxXtrans, psfxYtrans; ! 2339: CHAR szFaceName[MAX_STRING]; ! 2340: PSZ pszFaceName; ! 2341: PWSTR pwstr; ! 2342: LONG cjWidth; ! 2343: BYTE *pjBits; ! 2344: LONG EmHeight; ! 2345: XFORMOBJ *pxo; ! 2346: POINTFIX ptfx; ! 2347: PS_FIX psfxPointSize; ! 2348: XFORM fontxform; ! 2349: ! 2350: // search through our list of downloaded GDI fonts to see if the ! 2351: // current font has already been downloaded to the printer. ! 2352: ! 2353: pDLFont = pdev->cgs.pDLFonts; ! 2354: ! 2355: cDownloadedFonts = min(pdev->cgs.cDownloadedFonts, pdev->iDLFonts); ! 2356: ! 2357: for (i = 0; i < cDownloadedFonts; i++) ! 2358: { ! 2359: // is this entry the one we are looking for? simply return if so. ! 2360: ! 2361: if (pDLFont->iUniq == pfo->iUniq) ! 2362: { ! 2363: // update the fontname and size in our current graphics state. ! 2364: ! 2365: strcpy(pdev->cgs.szFont, pDLFont->strFont); ! 2366: pdev->cgs.lidFont = pDLFont->iUniq; ! 2367: ! 2368: return(TRUE); ! 2369: } ! 2370: ! 2371: pDLFont++; ! 2372: } ! 2373: ! 2374: // we did not find that this font has been downloaded yet, so we must ! 2375: // do it now. ! 2376: ! 2377: // if we have reached our downloaded font threshold, then ! 2378: // we will surround ever textout call with a save/restore. ! 2379: ! 2380: if (cDownloadedFonts >= pdev->iDLFonts) ! 2381: { ! 2382: ps_save(pdev, FALSE); ! 2383: pdev->cgs.dwFlags |= CGS_DLFONTTHRESHOLD; ! 2384: cDownloadedFonts = pdev->iDLFonts; ! 2385: } ! 2386: ! 2387: pDLFont = pdev->cgs.pDLFonts; ! 2388: pDLFont += cDownloadedFonts; ! 2389: ! 2390: memset(pDLFont, 0, sizeof(DLFONT)); ! 2391: ! 2392: pDLFont->iFace = pfo->iFace; ! 2393: pDLFont->iUniq = pfo->iUniq; ! 2394: ! 2395: // if we have made it this far, we should simply be able to ! 2396: // download the font now. ! 2397: ! 2398: // we will be downloading an Adobe TYPE 3 font. ! 2399: ! 2400: // allocate a dictionary for the font. ! 2401: ! 2402: PrintString(pdev, "9 dict d begin\n"); ! 2403: ! 2404: // set FontType to 3 indicating user defined font. ! 2405: ! 2406: PrintString(pdev, "/FontType 3 def\n"); ! 2407: ! 2408: // allocate memory for and get the handles for each glyph of the font. ! 2409: ! 2410: if (!(cGlyphs = FONTOBJ_cGetAllGlyphHandles(pfo, NULL))) ! 2411: { ! 2412: RIP("PSCRIPT!DownloadBitmapFont: cGetAllGlyphHandles failed.\n"); ! 2413: return(FALSE); ! 2414: } ! 2415: ! 2416: if (!(phg = (HGLYPH *)HeapAlloc(pdev->hheap, 0, sizeof(HGLYPH) * cGlyphs))) ! 2417: { ! 2418: RIP("PSCRIPT!DownloadBitmapFont: HeapAlloc failed.\n"); ! 2419: return(FALSE); ! 2420: } ! 2421: ! 2422: phgSave = phg; ! 2423: ! 2424: cTmp = FONTOBJ_cGetAllGlyphHandles(pfo, phg); ! 2425: ! 2426: ASSERTPS(cTmp == cGlyphs, "PSCRIPT!DownloadBitmapFont: inconsistent cGlyphs\n"); ! 2427: ! 2428: // how many characters will we define in this font? ! 2429: // keep in mind that we can only do 256 at a time. ! 2430: // remember to leave room for the .notdef character. ! 2431: ! 2432: cGlyphs = min(255, cGlyphs); ! 2433: ! 2434: // run through the array, looking at the bounding box for each ! 2435: // glyph, in order to create the bounding box for the entire ! 2436: // font. ! 2437: ! 2438: ptlTL.x = ADOBE_FONT_UNITS; ! 2439: ptlTL.y = ADOBE_FONT_UNITS; ! 2440: ptlBR.x = 0; ! 2441: ptlBR.y = 0; ! 2442: ! 2443: for (i = 0; i < cGlyphs; i++) ! 2444: { ! 2445: // get the GLYPHDATA structure for each glyph. ! 2446: ! 2447: if (!(cTmp = FONTOBJ_cGetGlyphs(pfo, FO_GLYPHBITS, 1, phg, (PVOID *)&pglyphdata))) ! 2448: { ! 2449: RIP("PSCRIPT!DownloadBitmapFont: cGetGlyphs failed.\n"); ! 2450: HeapFree(pdev->hheap, 0, (PVOID)phgSave); ! 2451: return(FALSE); ! 2452: } ! 2453: ! 2454: ptlTL.x = min(ptlTL.x, pglyphdata->rclInk.left); ! 2455: ptlTL.y = min(ptlTL.y, pglyphdata->rclInk.top); ! 2456: ptlBR.x = max(ptlBR.x, pglyphdata->rclInk.right); ! 2457: ptlBR.y = max(ptlBR.y, pglyphdata->rclInk.bottom); ! 2458: ! 2459: // point to the next glyph handle. ! 2460: ! 2461: phg++; ! 2462: } ! 2463: ! 2464: // get the IFIMETRICS for the font. ! 2465: ! 2466: if (!(pifi = FONTOBJ_pifi(pfo))) ! 2467: { ! 2468: RIP("PSCRIPT!DownloadBitmapFont: pifi failed.\n"); ! 2469: HeapFree(pdev->hheap, 0, (PVOID)phgSave); ! 2470: return(FALSE); ! 2471: } ! 2472: ! 2473: // get the Notional to Device transform. this is needed to ! 2474: // determine the point size. ! 2475: ! 2476: pxo = FONTOBJ_pxoGetXform(pfo); ! 2477: ! 2478: if (pxo == NULL) ! 2479: { ! 2480: RIP("PSCRIPT!DownloadBitmapFont: pxo == NULL.\n"); ! 2481: return(FALSE); ! 2482: } ! 2483: ! 2484: // apply the notional to device transform. ! 2485: ! 2486: ptl1.x = 0; ! 2487: ptl1.y = pifi->fwdUnitsPerEm; ! 2488: ! 2489: XFORMOBJ_bApplyXform(pxo, XF_LTOFX, 1, &ptl1, &ptfx); ! 2490: ! 2491: // now get the length of the vector. ! 2492: ! 2493: EmHeight = FXTOL(iHipot(ptfx.x, ptfx.y)); ! 2494: ! 2495: // we have filled in the GLYPHPOS for each glyph in the font. ! 2496: // reset the pointer to the first glyph. ! 2497: ! 2498: phg = phgSave; ! 2499: ! 2500: PrintString(pdev, "/FontMatrix [1 "); ! 2501: PrintDecimal(pdev, 1, EmHeight); ! 2502: PrintString(pdev, " div 0 0 1 "); ! 2503: PrintDecimal(pdev, 1, EmHeight); ! 2504: PrintString(pdev, " div 0 0] def\n"); ! 2505: ! 2506: // define the bounding box for the font, defined in 1 unit ! 2507: // character space (since FontMatrix = identity). ! 2508: ! 2509: PrintString(pdev, "/FontBBox ["); ! 2510: PrintDecimal(pdev, 4, ptlTL.x, ptlTL.y, ptlBR.x, ptlBR.y); ! 2511: PrintString(pdev, " ] def\n"); ! 2512: ! 2513: // allocate array for encoding vector, then initialize ! 2514: // all characters in encoding vector with '.notdef'. ! 2515: ! 2516: PrintString(pdev, "/Encoding 256 array def\n"); ! 2517: PrintString(pdev, "0 1 255 {Encoding exch /.notdef put} for\n"); ! 2518: ! 2519: // allocate space to store the HGLYPH<==>character code mapping. ! 2520: ! 2521: if (!(pDLFont->phgVector = (HGLYPH *)HeapAlloc(pdev->hheap, 0, ! 2522: sizeof(HGLYPH) * cGlyphs))) ! 2523: { ! 2524: RIP("PSCRIPT!DownloadBitmapFont: HeapAlloc for phgVector failed.\n"); ! 2525: HeapFree(pdev->hheap, 0, (PVOID)phgSave); ! 2526: return(FALSE); ! 2527: } ! 2528: ! 2529: // fill in the HGLYPH encoding vector, and output ! 2530: // the encoding vector to the printer. ! 2531: ! 2532: pDLFont->cGlyphs = cGlyphs; ! 2533: memcpy(pDLFont->phgVector, phg, cGlyphs * sizeof(HGLYPH)); ! 2534: ! 2535: PrintString(pdev, "Encoding\n"); ! 2536: ! 2537: for (i = 0; i < cGlyphs; i++) ! 2538: { ! 2539: PrintString(pdev, "d "); ! 2540: PrintDecimal(pdev, 1, i); ! 2541: PrintString(pdev, " /c"); ! 2542: PrintDecimal(pdev, 1, i); ! 2543: PrintString(pdev, " p\n"); ! 2544: } ! 2545: ! 2546: // under level 1 of PostScript, the 'BuildChar' procedure is called ! 2547: // every time a character from the font is constructed. under ! 2548: // level 2, 'BuildGlyph' is called instead. therefore, we will ! 2549: // define a 'BuildChar' procedure, which basically calls ! 2550: // 'BuildGlyph'. this will provide us support for both level 1 ! 2551: // and level 2 of PostScript. ! 2552: ! 2553: // define the 'BuildGlyph' procedure. start by getting the ! 2554: // character name and the font dictionary from the stack. ! 2555: ! 2556: PrintString(pdev, "/BuildGlyph {0 begin /cn ed /fd ed\n"); ! 2557: ! 2558: // retrieve the character information from the CharData (CD) ! 2559: // dictionary. ! 2560: ! 2561: PrintString(pdev, "/CI fd /CD get cn get def\n"); ! 2562: ! 2563: // get the width and the bounding box from the CharData. ! 2564: // remember to divide the width by 16. ! 2565: ! 2566: PrintString(pdev, "/wx CI 0 get def /cbb CI 1 4 getinterval def\n"); ! 2567: ! 2568: // enable each character to be cached. ! 2569: ! 2570: PrintString(pdev, "wx 0 cbb aload pop setcachedevice\n"); ! 2571: ! 2572: // get the width and height of the bitmap, set invert bool to true ! 2573: // specifying reverse image. ! 2574: ! 2575: PrintString(pdev, "CI 5 get CI 6 get true\n"); ! 2576: ! 2577: // insert x and y translation components into general imagemask ! 2578: // matrix. ! 2579: ! 2580: PrintString(pdev, "[1 0 0 -1 0 0] d 4 CI 7 get p d 5 CI 8 get p\n"); ! 2581: ! 2582: // get hex string bitmap, convert into procedure, then print ! 2583: // the bitmap image. ! 2584: ! 2585: PrintString(pdev, "CI 9 1 getinterval cvx im end } def\n"); ! 2586: ! 2587: // create local storage for 'BuildGlyph' procedure. ! 2588: ! 2589: PrintString(pdev, "/BuildGlyph load 0 5 dict put\n"); ! 2590: ! 2591: // the semantics of 'BuildChar' differ from 'BuildGlyph' in the ! 2592: // following way: 'BuildChar' is called with the font dictionary ! 2593: // and character code on the stack, 'BuildGlyph' is called with ! 2594: // the font dictionary and character name on the stack. the ! 2595: // following 'BuildChar' procedure calls 'BuildGlyph', and retains ! 2596: // compatiblity with level 1 PostScript. ! 2597: ! 2598: PrintString(pdev, "/BuildChar {1 index /Encoding get exch get\n"); ! 2599: PrintString(pdev, "1 index /BuildGlyph get exec} bind def\n"); ! 2600: ! 2601: // now create a dictionary containing information on each character. ! 2602: ! 2603: PrintString(pdev, "/CD "); ! 2604: PrintDecimal(pdev, 1, cGlyphs + 1); ! 2605: PrintString(pdev, " dict def CD begin\n"); ! 2606: ! 2607: for (i = 0; i < cGlyphs; i++) ! 2608: { ! 2609: // get the GLYPHDATA structure for each glyph. ! 2610: ! 2611: if (!(cTmp = FONTOBJ_cGetGlyphs(pfo, FO_GLYPHBITS, 1, phg, (PVOID *)&pglyphdata))) ! 2612: { ! 2613: RIP("PSCRIPT!DownloadBitmapFont: cGetGlyphs failed.\n"); ! 2614: HeapFree(pdev->hheap, 0, (PVOID)phgSave); ! 2615: HeapFree(pdev->hheap, 0, (PVOID)pDLFont->phgVector); ! 2616: return(FALSE); ! 2617: } ! 2618: ! 2619: // the first number in the character description is the width ! 2620: // in 1 unit font space. the next four numbers are the bounding ! 2621: // box in 1 unit font space. the next two numbers are the width ! 2622: // and height of the bitmap. the next two numbers are the x and ! 2623: // y translation values for the matrix given to imagemask. ! 2624: // this is followed by the bitmap itself. ! 2625: ! 2626: // first, output the character name. ! 2627: ! 2628: PrintString(pdev, "/c"); ! 2629: PrintDecimal(pdev, 1, i); ! 2630: ! 2631: // output the character description array. the width and ! 2632: // bounding box need to be normalized to 1 unit font space. ! 2633: ! 2634: // the width will be sent to the printer as the actual width ! 2635: // multiplied by 16 so as not to lose any precision when ! 2636: // normalizing. ! 2637: ! 2638: PrintString(pdev, " ["); ! 2639: PrintPSFIX(pdev, 1, (pglyphdata->fxD << 4)); ! 2640: PrintString(pdev, " "); ! 2641: PrintDecimal(pdev, 4, pglyphdata->rclInk.left, ! 2642: -pglyphdata->rclInk.top, pglyphdata->rclInk.right, ! 2643: -pglyphdata->rclInk.bottom); ! 2644: PrintString(pdev, " "); ! 2645: ! 2646: // output the width and height of the bitmap itself. ! 2647: ! 2648: PrintDecimal(pdev, 2, pglyphdata->gdf.pgb->sizlBitmap.cx, ! 2649: pglyphdata->gdf.pgb->sizlBitmap.cy); ! 2650: PrintString(pdev, " "); ! 2651: ! 2652: // output the translation values for the transform matrix. ! 2653: // the x component is usually the equivalent of the left ! 2654: // sidebearing in pixels. the y component is always the height ! 2655: // of the bitmap minus any displacement factor (such as for characters ! 2656: // with descenders. ! 2657: ! 2658: psfxXtrans = -pglyphdata->gdf.pgb->ptlOrigin.x << 8; ! 2659: psfxYtrans = -pglyphdata->gdf.pgb->ptlOrigin.y << 8; ! 2660: ! 2661: PrintPSFIX(pdev, 2, psfxXtrans, psfxYtrans); ! 2662: PrintString(pdev, "\n<"); ! 2663: ! 2664: // now output the bits. calculate how many bytes each source scanline ! 2665: // contains. remember that the bitmap will be padded to 32bit bounds. ! 2666: ! 2667: // protect ourselves. ! 2668: ! 2669: if ((pglyphdata->gdf.pgb->sizlBitmap.cx < 1) || ! 2670: (pglyphdata->gdf.pgb->sizlBitmap.cy < 1)) ! 2671: { ! 2672: RIP("PSCRIPT!DownloadBitmapFont: Invalid glyphdata!!!.\n"); ! 2673: return(FALSE); ! 2674: } ! 2675: ! 2676: pjBits = pglyphdata->gdf.pgb->aj; ! 2677: ! 2678: for (j = 0; j < (DWORD)pglyphdata->gdf.pgb->sizlBitmap.cy; j++) ! 2679: { ! 2680: cjWidth = (LONG)(pglyphdata->gdf.pgb->sizlBitmap.cx + 7) >> 3; ! 2681: vHexOut(pdev, pjBits, cjWidth); ! 2682: pjBits += cjWidth; ! 2683: } ! 2684: ! 2685: PrintString(pdev, ">]def\n"); ! 2686: ! 2687: // point to the next glyph handle. ! 2688: ! 2689: phg++; ! 2690: } ! 2691: ! 2692: // don't forget the .notdef character. ! 2693: ! 2694: PrintString(pdev, "/.notdef [.24 0 0 0 1 1 0 0 <>]def end\n"); ! 2695: ! 2696: // create a unique ID for the font, then name it. ! 2697: ! 2698: pwstr = (PWSTR)((BYTE *)pifi + pifi->dpwszFaceName); ! 2699: cTmp = wcslen(pwstr); ! 2700: ! 2701: // get the font name from the UNICODE font name. ! 2702: ! 2703: memset(szFaceName, 0, sizeof(szFaceName)); ! 2704: pszFaceName = szFaceName; ! 2705: ! 2706: while (cTmp--) ! 2707: { ! 2708: *pszFaceName = (CHAR)*pwstr++; ! 2709: ! 2710: // replace any spaces in the font name with underscores. ! 2711: ! 2712: if (*pszFaceName == ' ') ! 2713: *pszFaceName = '_'; ! 2714: ! 2715: // replace any parens in the font name with asterisks. ! 2716: ! 2717: if ((*pszFaceName == '(') || (*pszFaceName == ')')) ! 2718: *pszFaceName = '*'; ! 2719: ! 2720: // point to the next character. ! 2721: ! 2722: *pszFaceName++; ! 2723: } ! 2724: ! 2725: // add the point size to the font name, so we can distinguish ! 2726: // different point sizes of the same font. ! 2727: ! 2728: // NOTE Grab a new point size here, rather than reading if from ! 2729: // the CGS. This is necessary to support DrvDownloadFace. ! 2730: ! 2731: psfxPointSize = GetPointSize(pdev, pfo, &fontxform); ! 2732: ! 2733: cTmp = PSFIXToBuffer(pszFaceName, psfxPointSize); ! 2734: ! 2735: // update the buffer pointer. ! 2736: ! 2737: pszFaceName += cTmp; ! 2738: ! 2739: // output the NULL terminator. ! 2740: ! 2741: *pszFaceName = '\0'; ! 2742: ! 2743: // output the unique id, which, in a postscript printer, can ! 2744: // be in the range from 0 to 16777215. ! 2745: ! 2746: PrintString(pdev, "/UniqueID "); ! 2747: PrintDecimal(pdev, 1, (pfo->iUniq & 0xFFFFF)); ! 2748: ! 2749: PrintString(pdev, " def end pop /"); ! 2750: PrintString(pdev, szFaceName); ! 2751: PrintString(pdev, " exch definefont pop\n"); ! 2752: ! 2753: // update the fontname in our current graphics state. ! 2754: ! 2755: strcpy(pdev->cgs.szFont, szFaceName); ! 2756: ! 2757: // update information for this downloaded font. ! 2758: ! 2759: strcpy(pDLFont->strFont, szFaceName); ! 2760: pDLFont->psfxScaleFactor = psfxPointSize; ! 2761: ! 2762: // update the downloaded font counter. ! 2763: ! 2764: pdev->cgs.cDownloadedFonts++; ! 2765: ! 2766: // free up some memory. ! 2767: ! 2768: if (phgSave) ! 2769: HeapFree(pdev->hheap, 0, (PVOID)phgSave); ! 2770: } ! 2771: ! 2772: ! 2773: //-------------------------------------------------------------------- ! 2774: // BOOL DownloadOutlineFont(pdev, pfo) ! 2775: // PDEVDATA pdev; ! 2776: // FONTOBJ *pfo; ! 2777: // ! 2778: // This routine downloads the font definition for the given bitmap font, ! 2779: // if it has not already been done. The font is downloaded as an ! 2780: // Adobe Type 3 font. ! 2781: // ! 2782: // This routine return TRUE if the font is successfully, or has already ! 2783: // been, downloaded to the printer. It returns FALSE if it fails. ! 2784: // ! 2785: // History: ! 2786: // 27-Feb-1992 -by- Kent Settle (kentse) ! 2787: // Wrote it. ! 2788: //-------------------------------------------------------------------- ! 2789: ! 2790: BOOL DownloadOutlineFont(pdev, pfo) ! 2791: PDEVDATA pdev; ! 2792: FONTOBJ *pfo; ! 2793: { ! 2794: DLFONT *pDLFont; ! 2795: DWORD i; ! 2796: DWORD cDownloadedFonts; ! 2797: DWORD cGlyphs, cTmp; ! 2798: HGLYPH *phg; ! 2799: HGLYPH *phgSave; ! 2800: GLYPHDATA *pglyphdata; ! 2801: POINTL ptlTL, ptlBR; ! 2802: PIFIMETRICS pifi; ! 2803: LONG iCharWidth; ! 2804: CHAR szFaceName[MAX_STRING]; ! 2805: PSZ pszFaceName; ! 2806: PWSTR pwstr; ! 2807: ! 2808: // search through our list of downloaded GDI fonts to see if the ! 2809: // current font has already been downloaded to the printer. ! 2810: ! 2811: pDLFont = pdev->cgs.pDLFonts; ! 2812: ! 2813: cDownloadedFonts = min(pdev->cgs.cDownloadedFonts, pdev->iDLFonts); ! 2814: ! 2815: for (i = 0; i < pdev->iDLFonts; i++) ! 2816: { ! 2817: // is this entry the one we are looking for? simply return if so. ! 2818: ! 2819: if (pDLFont->iUniq == pfo->iUniq) ! 2820: { ! 2821: // update the fontname and size in our current graphics state. ! 2822: ! 2823: strcpy(pdev->cgs.szFont, pDLFont->strFont); ! 2824: pdev->cgs.psfxScaleFactor = pDLFont->psfxScaleFactor; ! 2825: pdev->cgs.lidFont = pDLFont->iUniq; ! 2826: ! 2827: return(TRUE); ! 2828: } ! 2829: ! 2830: pDLFont++; ! 2831: } ! 2832: ! 2833: // we did not find that this font has been downloaded yet, so we must ! 2834: // do it now. ! 2835: ! 2836: // if we have reached our downloaded font threshold, then ! 2837: // we will surround ever textout call with a save/restore. ! 2838: ! 2839: if (cDownloadedFonts == pdev->iDLFonts) ! 2840: { ! 2841: ps_save(pdev, FALSE); ! 2842: pdev->cgs.dwFlags |= CGS_DLFONTTHRESHOLD; ! 2843: cDownloadedFonts--; ! 2844: } ! 2845: ! 2846: pDLFont = pdev->cgs.pDLFonts; ! 2847: pDLFont += cDownloadedFonts; ! 2848: ! 2849: // free up the memory for the hglyph array for the old font. ! 2850: ! 2851: if (pDLFont->phgVector) ! 2852: { ! 2853: HeapFree(pdev->hheap, 0, (PVOID)pDLFont->phgVector); ! 2854: pDLFont->phgVector = (HGLYPH *)NULL; ! 2855: } ! 2856: ! 2857: memset(pDLFont, 0, sizeof(DLFONT)); ! 2858: ! 2859: pDLFont->iFace = pfo->iFace; ! 2860: pDLFont->iUniq = pfo->iUniq; ! 2861: ! 2862: // if we have made it this far, we should simply be able to ! 2863: // download the font now. ! 2864: ! 2865: // we will be downloading an Adobe TYPE 3 font. ! 2866: ! 2867: // allocate a dictionary for the font. ! 2868: ! 2869: PrintString(pdev, "10 dict d begin\n"); ! 2870: ! 2871: // set FontType to 3 indicating user defined font. ! 2872: ! 2873: PrintString(pdev, "/FontType 3 def\n"); ! 2874: ! 2875: // all font coordinate systems will be defined in units of 1000. ! 2876: // specify a FontMatrix which transforms the 1000 unit font to a ! 2877: // 1 unit font. ! 2878: ! 2879: PrintString(pdev, "/FontMatrix [.001 0 0 .001 0 0] def\n"); ! 2880: ! 2881: // allocate memory for and get the handles for each glyph of the font. ! 2882: ! 2883: if (!(cGlyphs = FONTOBJ_cGetAllGlyphHandles(pfo, NULL))) ! 2884: { ! 2885: RIP("PSCRIPT!DownloadOutlineFont: cGetAllGlyphHandles failed.\n"); ! 2886: return(FALSE); ! 2887: } ! 2888: ! 2889: if (!(phg = (HGLYPH *)HeapAlloc(pdev->hheap, 0, sizeof(HGLYPH) * cGlyphs))) ! 2890: { ! 2891: RIP("PSCRIPT!DownloadOutlineFont: HeapAlloc failed.\n"); ! 2892: return(FALSE); ! 2893: } ! 2894: ! 2895: phgSave = phg; ! 2896: ! 2897: cTmp = FONTOBJ_cGetAllGlyphHandles(pfo, phg); ! 2898: ! 2899: ASSERTPS(cTmp == cGlyphs, "PSCRIPT!DownloadOutlineFont: inconsistent cGlyphs\n"); ! 2900: ! 2901: // how many characters will we define in this font? ! 2902: // keep in mind that we can only do 256 at a time. ! 2903: // remember to leave room for the .notdef character. ! 2904: ! 2905: cGlyphs = min(255, cGlyphs); ! 2906: ! 2907: // get the IFIMETRICS for the font, used in TTTOADOBE. ! 2908: ! 2909: if (!(pifi = FONTOBJ_pifi(pfo))) ! 2910: { ! 2911: RIP("PSCRIPT!DownloadOutlineFont: pifi failed.\n"); ! 2912: HeapFree(pdev->hheap, 0, (PVOID)phg); ! 2913: return(FALSE); ! 2914: } ! 2915: ! 2916: // run through the array, looking at the bounding box for each ! 2917: // glyph, in order to create the bounding box for the entire ! 2918: // font. ! 2919: ! 2920: ptlTL.x = ADOBE_FONT_UNITS; ! 2921: ptlTL.y = ADOBE_FONT_UNITS; ! 2922: ptlBR.x = 0; ! 2923: ptlBR.y = 0; ! 2924: ! 2925: for (i = 0; i < cGlyphs; i++) ! 2926: { ! 2927: // get the GLYPHDATA structure for each glyph. ! 2928: ! 2929: if (!(cTmp = FONTOBJ_cGetGlyphs(pfo, FO_PATHOBJ, 1, phg, (PVOID *)&pglyphdata))) ! 2930: { ! 2931: RIP("PSCRIPT!DownloadOutlineFont: cGetGlyphs failed.\n"); ! 2932: HeapFree(pdev->hheap, 0, (PVOID)phgSave); ! 2933: return(FALSE); ! 2934: } ! 2935: ! 2936: ptlTL.x = min(ptlTL.x, TTTOADOBE(pglyphdata->rclInk.left)); ! 2937: ptlTL.y = min(ptlTL.y, TTTOADOBE(pglyphdata->rclInk.top)); ! 2938: ptlBR.x = max(ptlBR.x, TTTOADOBE(pglyphdata->rclInk.right)); ! 2939: ptlBR.y = max(ptlBR.y, TTTOADOBE(pglyphdata->rclInk.bottom)); ! 2940: ! 2941: // point to the next glyph handle. ! 2942: ! 2943: phg++; ! 2944: } ! 2945: ! 2946: // we have filled in the GLYPHPOS for each glyph in the font. ! 2947: // reset the pointer to the first glyph. ! 2948: ! 2949: phg = phgSave; ! 2950: ! 2951: // define the bounding box for the font. ! 2952: ! 2953: PrintString(pdev, "/FontBBox ["); ! 2954: PrintDecimal(pdev, 4, ptlTL.x, ptlTL.y, ptlBR.x, ptlBR.y); ! 2955: PrintString(pdev, "] def\n"); ! 2956: ! 2957: // allocate array for encoding vector, then initialize ! 2958: // all characters in encoding vector with '.notdef'. ! 2959: ! 2960: PrintString(pdev, "/Encoding 256 array def\n"); ! 2961: PrintString(pdev, "0 1 255 {Encoding exch /.notdef p} for\n"); ! 2962: ! 2963: // allocate space to store the HGLYPH<==>character code mapping. ! 2964: ! 2965: if (!(pDLFont->phgVector = (HGLYPH *)HeapAlloc(pdev->hheap, 0, ! 2966: sizeof(HGLYPH) * cGlyphs))) ! 2967: { ! 2968: RIP("PSCRIPT!DownloadOutlineFont: HeapAlloc for phgVector failed.\n"); ! 2969: HeapFree(pdev->hheap, 0, (PVOID)phg); ! 2970: return(FALSE); ! 2971: } ! 2972: ! 2973: // initialize array. ! 2974: ! 2975: pDLFont->cGlyphs = cGlyphs; ! 2976: ! 2977: // fill in the HGLYPH encoding vector, and output ! 2978: // the encoding vector to the printer. ! 2979: ! 2980: memcpy(pDLFont->phgVector, phg, cGlyphs * sizeof(HGLYPH)); ! 2981: ! 2982: PrintString(pdev, "Encoding\n"); ! 2983: ! 2984: for (i = 0; i < cGlyphs; i++) ! 2985: { ! 2986: PrintString(pdev, "d "); ! 2987: PrintDecimal(pdev, 1, i); ! 2988: PrintString(pdev, " /c"); ! 2989: PrintDecimal(pdev, 1, i); ! 2990: PrintString(pdev, " p\n"); ! 2991: } ! 2992: ! 2993: // under level 1 of PostScript, the 'BuildChar' procedure is called ! 2994: // every time a character from the font is constructed. under ! 2995: // level 2, 'BuildGlyph' is called instead. therefore, we will ! 2996: // define a 'BuildChar' procedure, which basically calls ! 2997: // 'BuildGlyph'. this will provide us support for both level 1 ! 2998: // and level 2 of PostScript. ! 2999: ! 3000: // define the 'BuildGlyph' procedure. start by getting the ! 3001: // character name and the font dictionary from the stack. ! 3002: ! 3003: PrintString(pdev, "/BuildGlyph {0 begin /cn ed /fd ed\n"); ! 3004: ! 3005: // retrieve the character information from the CharData (CD) ! 3006: // dictionary. ! 3007: ! 3008: PrintString(pdev, "/CI fd /CD get cn get def\n"); ! 3009: ! 3010: // get the width and the bounding box from the CharData. ! 3011: ! 3012: PrintString(pdev, "/wx CI 0 get def /cbb CI 1 4 getinterval def\n"); ! 3013: ! 3014: // enable each character to be cached. ! 3015: ! 3016: PrintString(pdev, "wx 0 cbb aload pop setcachedevice\n"); ! 3017: ! 3018: // get the procedure for rendering the character and execute it. ! 3019: ! 3020: PrintString(pdev, "CI 5 get exec end } def\n"); ! 3021: ! 3022: // create local storage for 'BuildGlyph' procedure. ! 3023: ! 3024: PrintString(pdev, "/BuildGlyph load 0 5 dict p\n"); ! 3025: ! 3026: // the semantics of 'BuildChar' differ from 'BuildGlyph' in the ! 3027: // following way: 'BuildChar' is called with the font dictionary ! 3028: // and character code on the stack, 'BuildGlyph' is called with ! 3029: // the font dictionary and character name on the stack. the ! 3030: // following 'BuildChar' procedure calls 'BuildGlyph', and retains ! 3031: // compatiblity with level 1 PostScript. ! 3032: ! 3033: PrintString(pdev, "/BuildChar {1 index /Encoding get exch get\n"); ! 3034: PrintString(pdev, "1 index /BuildGlyph get exec} bd\n"); ! 3035: ! 3036: // now create a dictionary containing information on each character. ! 3037: ! 3038: PrintString(pdev, "/CD "); ! 3039: PrintDecimal(pdev, 1, cGlyphs + 1); ! 3040: PrintString(pdev, " dict def CD begin\n"); ! 3041: ! 3042: for (i = 0; i < cGlyphs; i++) ! 3043: { ! 3044: // get the GLYPHDATA structure for each glyph. ! 3045: ! 3046: DbgPrint("calling cGetGlyphs.\n"); ! 3047: DbgBreakPoint(); ! 3048: ! 3049: if (!(cTmp = FONTOBJ_cGetGlyphs(pfo, FO_PATHOBJ, 1, phg, (PVOID *)&pglyphdata))) ! 3050: { ! 3051: RIP("PSCRIPT!DownloadOutlineFont: cGetGlyphs failed.\n"); ! 3052: HeapFree(pdev->hheap, 0, (PVOID)phgSave); ! 3053: return(FALSE); ! 3054: } ! 3055: ! 3056: // the first number in the character description is the width ! 3057: // in 1000 unit font space. the next four numbers are the bounding ! 3058: // box in 1000 unit font space. these are followed by the ! 3059: // procedure used to draw the character itself. ! 3060: ! 3061: // first, output the character name. ! 3062: ! 3063: PrintString(pdev, "/c"); ! 3064: PrintDecimal(pdev, 1, i); ! 3065: ! 3066: // output the character description array. ! 3067: ! 3068: // the width will be sent to the printer as the actual width ! 3069: // multiplied by 16 so as not to lose any percision when ! 3070: // normalizing. ! 3071: ! 3072: iCharWidth = TTTOADOBE((LONG)pglyphdata->fxD); ! 3073: ! 3074: ptlTL.x = TTTOADOBE(pglyphdata->rclInk.left); ! 3075: ptlTL.y = TTTOADOBE(pglyphdata->rclInk.top); ! 3076: ptlBR.x = TTTOADOBE(pglyphdata->rclInk.right); ! 3077: ptlBR.y = TTTOADOBE(pglyphdata->rclInk.bottom); ! 3078: ! 3079: // remember to flip over the y coordinates. ! 3080: ! 3081: PrintString(pdev, " ["); ! 3082: PrintDecimal(pdev, 5, iCharWidth, ptlTL.x, -ptlTL.y, ptlBR.x, -ptlBR.y); ! 3083: ! 3084: // output the procedure to draw the character itself. ! 3085: ! 3086: PrintString (pdev, " {"); ! 3087: DrvCommonPath(pdev, pglyphdata->gdf.ppo); ! 3088: PrintString(pdev, "fill }]def\n"); ! 3089: ! 3090: // point to the next glyph handle. ! 3091: ! 3092: phg++; ! 3093: } ! 3094: ! 3095: // don't forget the .notdef character. ! 3096: ! 3097: PrintString(pdev, "/.notdef [0 0 0 0 0 {}]def end\n"); ! 3098: ! 3099: // create a unique ID for the font, then name it. ! 3100: ! 3101: pwstr = (PWSTR)((BYTE *)pifi + pifi->dpwszFaceName); ! 3102: cTmp = wcslen(pwstr); ! 3103: ! 3104: // get the font name from the UNICODE font name. ! 3105: ! 3106: pszFaceName = szFaceName; ! 3107: ! 3108: while (cTmp--) ! 3109: { ! 3110: *pszFaceName = (CHAR)*pwstr++; ! 3111: ! 3112: // replace any spaces in the font name with underscores. ! 3113: ! 3114: if (*pszFaceName == ' ') ! 3115: *pszFaceName = '_'; ! 3116: ! 3117: // replace any parens in the font name with asterisks. ! 3118: ! 3119: if ((*pszFaceName == '(') || (*pszFaceName == ')')) ! 3120: *pszFaceName = '*'; ! 3121: ! 3122: // point to the next character. ! 3123: ! 3124: *pszFaceName++; ! 3125: } ! 3126: ! 3127: // NULL terminate the font name. ! 3128: ! 3129: *pszFaceName = '\0'; ! 3130: ! 3131: // output the unique id, which, in a postscript printer, can ! 3132: // be in the range from 0 to 16777215. ! 3133: ! 3134: PrintString(pdev, "/UniqueID "); ! 3135: PrintDecimal(pdev, 1, (pfo->iUniq & 0xFFFFF)); ! 3136: ! 3137: PrintString(pdev, " def end pop /"); ! 3138: PrintString(pdev, szFaceName); ! 3139: PrintString(pdev, " exch definefont pop\n"); ! 3140: ! 3141: // update the fontname in our current graphics state. ! 3142: ! 3143: strcpy(pdev->cgs.szFont, szFaceName); ! 3144: ! 3145: // update the downloaded font counter. ! 3146: ! 3147: pdev->cgs.cDownloadedFonts++; ! 3148: ! 3149: // free up some memory. ! 3150: ! 3151: if (phgSave) ! 3152: HeapFree(pdev->hheap, 0, (PVOID)phgSave); ! 3153: } ! 3154: ! 3155: ! 3156: //-------------------------------------------------------------------- ! 3157: // BOOL SetFontRemap(pdev, iFontID) ! 3158: // PDEVDATA pdev; ! 3159: // DWORD iFontID; ! 3160: // ! 3161: // This routine adds the specified font to the list of remapped fonts. ! 3162: // ! 3163: // This routine return TRUE for success, FALSE otherwise. ! 3164: // ! 3165: // History: ! 3166: // 11-Jun-1992 -by- Kent Settle (kentse) ! 3167: // Wrote it. ! 3168: //-------------------------------------------------------------------- ! 3169: ! 3170: BOOL SetFontRemap(pdev, iFontID) ! 3171: PDEVDATA pdev; ! 3172: DWORD iFontID; ! 3173: { ! 3174: FREMAP *pfremap; ! 3175: ! 3176: // add the specified font id to the list of remapped fonts. ! 3177: ! 3178: pfremap = &pdev->cgs.FontRemap; ! 3179: ! 3180: // find the end of the list. ! 3181: ! 3182: if (pfremap->pNext) ! 3183: { ! 3184: while (pfremap->pNext) ! 3185: pfremap = (PFREMAP)pfremap->pNext; ! 3186: ! 3187: // allocate the next entry in the list. ! 3188: ! 3189: if (!(pfremap->pNext = (struct _FREMAP *)HeapAlloc(pdev->hheap, 0, sizeof(FREMAP)))) ! 3190: { ! 3191: RIP("PSCRIPT!SetFontRemap: HeapAlloc failed.\n"); ! 3192: return(FALSE); ! 3193: } ! 3194: ! 3195: pfremap = (PFREMAP)pfremap->pNext; ! 3196: } ! 3197: ! 3198: // now that we have found the last entry in the list, fill it in. ! 3199: ! 3200: pfremap->iFontID = iFontID; ! 3201: pfremap->pNext = NULL; ! 3202: ! 3203: return(TRUE); ! 3204: } ! 3205: ! 3206: ! 3207: //-------------------------------------------------------------------- ! 3208: // BOOL QueryFontRemap(pdev, iFontID) ! 3209: // PDEVDATA pdev; ! 3210: // DWORD iFontID; ! 3211: // ! 3212: // This routine scans the list of remapped fonts. ! 3213: // ! 3214: // This routine return TRUE if iFontID is found, FALSE otherwise. ! 3215: // ! 3216: // History: ! 3217: // 11-Jun-1992 -by- Kent Settle (kentse) ! 3218: // Wrote it. ! 3219: //-------------------------------------------------------------------- ! 3220: ! 3221: BOOL QueryFontRemap(pdev, iFontID) ! 3222: PDEVDATA pdev; ! 3223: DWORD iFontID; ! 3224: { ! 3225: FREMAP *pfremap; ! 3226: ! 3227: // add the specified font id to the list of remapped fonts. ! 3228: ! 3229: pfremap = &pdev->cgs.FontRemap; ! 3230: ! 3231: // search the list for iFontID. ! 3232: ! 3233: do ! 3234: { ! 3235: // return TRUE if we have found the font. ! 3236: ! 3237: if (pfremap->iFontID == iFontID) ! 3238: return(TRUE); ! 3239: ! 3240: // we have not found the font, point to the next entry. ! 3241: ! 3242: pfremap = (PFREMAP)pfremap->pNext; ! 3243: ! 3244: } while (pfremap); ! 3245: ! 3246: // we did not find the font. ! 3247: ! 3248: return(FALSE); ! 3249: } ! 3250: ! 3251: ! 3252: //-------------------------------------------------------------------- ! 3253: // DWORD SubstituteIFace(pdev, pfo) ! 3254: // PDEVDATA pdev; ! 3255: // FONTOBJ *pfo; ! 3256: // ! 3257: // This routine takes the TrueType font specified by pfo, and returns ! 3258: // the iFace of the device font to substitute. This routine returns ! 3259: // zero if no font is found for substitution. ! 3260: // ! 3261: // History: ! 3262: // 14-Jul-1992 -by- Kent Settle (kentse) ! 3263: // Wrote it. ! 3264: //-------------------------------------------------------------------- ! 3265: ! 3266: DWORD SubstituteIFace(pdev, pfo) ! 3267: PDEVDATA pdev; ! 3268: FONTOBJ *pfo; ! 3269: { ! 3270: DWORD iFace = 0; ! 3271: DWORD iTmp; ! 3272: CHAR strDevFont[MAX_FONT_NAME]; ! 3273: WCHAR wstrDevFont[MAX_FONT_NAME]; ! 3274: PSTR pstrDevFont; ! 3275: PWSTR pwstrDevFont; ! 3276: IFIMETRICS *pifiTT; ! 3277: DWORD cTmp; ! 3278: PWSTR pwstr, pwstrTT; ! 3279: PNTFM pntfm; ! 3280: BOOL bFound; ! 3281: ! 3282: #if DBG ! 3283: // make sure we have a TrueType font. ! 3284: ! 3285: if (!(pfo->flFontType & TRUETYPE_FONTTYPE)) ! 3286: { ! 3287: DbgPrint("PSCRIPT!SubstituteIFace: Trying to substitute for non-TT font.\n"); ! 3288: return(0); ! 3289: } ! 3290: ! 3291: // make sure we are supposed to be doing font substitution. ! 3292: ! 3293: if (!(pdev->psdm.dwFlags & PSDEVMODE_FONTSUBST)) ! 3294: { ! 3295: DbgPrint("PSCRIPT!SubstituteIFace: not supposed to font substitute.\n"); ! 3296: return(0); ! 3297: } ! 3298: #endif ! 3299: ! 3300: // get the TrueType font name from the IFIMETRICS structure. ! 3301: ! 3302: if (!(pifiTT = FONTOBJ_pifi(pfo))) ! 3303: { ! 3304: RIP("PSCRIPT!SubstituteIFace: FONTOBJ_pifiTT failed.\n"); ! 3305: return(0); ! 3306: } ! 3307: ! 3308: pwstrTT = (PWSTR)((BYTE *)pifiTT + pifiTT->dpwszFaceName); ! 3309: ! 3310: // now search the font substitution table for a matching TrueType font. ! 3311: // the substitution table is in the following format: a NULL terminated ! 3312: // UNICODE TrueType font name followed by the matching NULL terminated ! 3313: // device font name. this sequence is repeated until a double NULL ! 3314: // terminator ends the table. ! 3315: ! 3316: pwstr = pdev->pTTSubstTable; ! 3317: bFound = FALSE; ! 3318: ! 3319: while (*pwstr) ! 3320: { ! 3321: if (!(wcscmp(pwstr, pwstrTT))) ! 3322: { ! 3323: // we found the TrueType font, now get the matching device font. ! 3324: ! 3325: pwstr += (wcslen(pwstr) + 1); ! 3326: wcsncpy(wstrDevFont, pwstr, ! 3327: (sizeof(wstrDevFont) / sizeof(wstrDevFont[0]))); ! 3328: bFound = TRUE; ! 3329: break; ! 3330: } ! 3331: else ! 3332: { ! 3333: // this was not the font in question. skip over both font names. ! 3334: ! 3335: pwstr += (wcslen(pwstr) + 1); ! 3336: pwstr += (wcslen(pwstr) + 1); ! 3337: } ! 3338: } ! 3339: ! 3340: // if we could not get a corresponding device font for any reason, ! 3341: // simply return zero for the iFace. ! 3342: ! 3343: if (!bFound) ! 3344: return(0); ! 3345: ! 3346: // get an ANSI version of the font name. ! 3347: ! 3348: cTmp = wcslen(wstrDevFont); ! 3349: cTmp++; ! 3350: ! 3351: pwstrDevFont = wstrDevFont; ! 3352: pstrDevFont = strDevFont; ! 3353: ! 3354: while (cTmp--) ! 3355: *pstrDevFont++ = (CHAR)*pwstrDevFont++; ! 3356: ! 3357: *pstrDevFont = '\0'; ! 3358: ! 3359: // at this point we have a mapping between a TrueType font name, ! 3360: // and a device font name. we need to determine the iFace of ! 3361: // the font name. ! 3362: ! 3363: for (iTmp = 1; iTmp <= (pdev->cDeviceFonts + pdev->cSoftFonts); iTmp++) ! 3364: { ! 3365: // get the font metrics for the specified font. ! 3366: ! 3367: pntfm = pdev->pfmtable[iTmp - 1].pntfm; ! 3368: ! 3369: // see if it is the font family we are looking for. if it is, ! 3370: // select it into the current graphics state, and return its iFace. ! 3371: ! 3372: if (!strcmp(strDevFont, ((char *)pntfm + pntfm->loszFontName))) ! 3373: { ! 3374: // select the device font in the current graphics state. ! 3375: ! 3376: strcpy(pdev->cgs.szFont, strDevFont); ! 3377: iFace = iTmp; ! 3378: break; ! 3379: } ! 3380: } ! 3381: ! 3382: // return the iFace of the device font to the caller. ! 3383: ! 3384: return(iFace); ! 3385: } ! 3386: ! 3387: ! 3388: ! 3389: //-------------------------------------------------------------------- ! 3390: // ULONG DrvGetGlyphMode(dhpdev, pfo, iMode) ! 3391: // DHPDEV dhpdev; ! 3392: // FONTOBJ *pfo; ! 3393: // ULONG iMode; ! 3394: // ! 3395: // This routine returns to the engine, the type of font caching the ! 3396: // engine should do. ! 3397: // ! 3398: // History: ! 3399: // 22-Jul-1992 -by- Kent Settle (kentse) ! 3400: // Wrote it. ! 3401: //-------------------------------------------------------------------- ! 3402: ! 3403: ULONG DrvGetGlyphMode(dhpdev, pfo) ! 3404: DHPDEV dhpdev; ! 3405: FONTOBJ *pfo; ! 3406: { ! 3407: return(SO_MONOBITMAP); ! 3408: // return(SO_GLYPHHANDLES); ! 3409: } ! 3410: ! 3411: ! 3412: ! 3413: //-------------------------------------------------------------------- ! 3414: // LONG iHipot(x, y) ! 3415: // LONG x; ! 3416: // LONG y; ! 3417: // ! 3418: // This routine returns the hypoteneous of a right triangle. ! 3419: // ! 3420: // FORMULA: ! 3421: // use sq(x) + sq(y) = sq(hypo); ! 3422: // start with MAX(x, y), ! 3423: // use sq(x + 1) = sq(x) + 2x + 1 to incrementally get to the ! 3424: // target hypotenouse. ! 3425: // ! 3426: // History: ! 3427: // 10-Feb-1993 -by- Kent Settle (kentse) ! 3428: // Stole from RASDD. ! 3429: // 21-Aug-1991 -by- Lindsay Harris (lindsayh) ! 3430: // Cleaned up UniDrive version, added comments etc. ! 3431: //-------------------------------------------------------------------- ! 3432: ! 3433: LONG iHipot(x, y) ! 3434: LONG x; ! 3435: LONG y; ! 3436: { ! 3437: register int hypo; /* Value to calculate */ ! 3438: register int delta; /* Used in the calculation loop */ ! 3439: ! 3440: int target; /* Loop limit factor */ ! 3441: ! 3442: // quick exit for frequent trivial cases [bodind] ! 3443: ! 3444: if (x == 0) ! 3445: { ! 3446: return ((y > 0) ? y : -y); ! 3447: } ! 3448: ! 3449: if (y == 0) ! 3450: { ! 3451: return ((x > 0) ? x : -x); ! 3452: } ! 3453: ! 3454: if (x < 0) ! 3455: x = -x; ! 3456: ! 3457: if (y < 0) ! 3458: y = -y; ! 3459: ! 3460: if(x > y) ! 3461: { ! 3462: hypo = x; ! 3463: target = y * y; ! 3464: } ! 3465: else ! 3466: { ! 3467: hypo = y; ! 3468: target = x * x; ! 3469: } ! 3470: ! 3471: for (delta = 0; delta < target; hypo++) ! 3472: delta += hypo << 1 + 1; ! 3473: ! 3474: return hypo; ! 3475: } ! 3476: ! 3477: ! 3478: //-------------------------------------------------------------------------- ! 3479: // BOOL IsJustifiedText(pdev, pfo, pstro, pptSpace, pptNonSpace, pdata) ! 3480: // PDEVDATA pdev; ! 3481: // FONTOBJ *pfo; ! 3482: // STROBJ *pstro; ! 3483: // POINTPSFX *pptSpace; ! 3484: // POINTPSFX *pptNonSpace; ! 3485: // TEXTDATA *pdata; ! 3486: // ! 3487: // This routine analyzes the string defined in pstro. If the spacing after ! 3488: // each non-space character is the same (with in 1), and the spacing after ! 3489: // each space character is the same, this routine will fill in the ! 3490: // POINTPSFX for each value, and return TRUE, otherwise it returns FALSE. ! 3491: // ! 3492: // History: ! 3493: // 31-Mar-1993 -by- Kent Settle (kentse) ! 3494: // Wrote it. ! 3495: //-------------------------------------------------------------------------- ! 3496: ! 3497: ! 3498: BOOL IsJustifiedText(pdev, pfo, pstro, pptSpace, pptNonSpace, pdata) ! 3499: PDEVDATA pdev; ! 3500: FONTOBJ *pfo; ! 3501: STROBJ *pstro; ! 3502: POINTPSFX *pptSpace; ! 3503: POINTPSFX *pptNonSpace; ! 3504: TEXTDATA *pdata; ! 3505: { ! 3506: DWORD i; ! 3507: TEXTDELTA *pdelta; ! 3508: TEXTDELTA *pdeltaSave; ! 3509: POINTFIX ptfxSpace, ptfxNonSpace, ptfxTmp; ! 3510: POINTFIX ptfxSExtra, ptfxNSExtra; ! 3511: GLYPHPOS *pgp; ! 3512: WCHAR wcSpace; ! 3513: FLONG flAccel; ! 3514: LONG cSpace, cNonSpace, denom; ! 3515: DWORD cGlyphs; ! 3516: BOOL bMore; ! 3517: PWSZ pwszOrg; ! 3518: ! 3519: flAccel = pstro->flAccel; ! 3520: ! 3521: // currently, just handle horizontal text. justification for a string ! 3522: // with one character makes no sense. and, justification is ! 3523: // obviously not happening, if we are using default placement. ! 3524: // finally, we must individually place the characters if substitution ! 3525: // is in effect, because it is the only way we have of getting the ! 3526: // true character widths. ! 3527: ! 3528: if ((!(flAccel & SO_HORIZONTAL)) || (pstro->cGlyphs <= 1) || ! 3529: (flAccel & SO_FLAG_DEFAULT_PLACEMENT) || pdata->bFontSubstitution) ! 3530: return(FALSE); ! 3531: ! 3532: // now the ugly part. we must go through the string a character at a ! 3533: // time, comparing the widths given in the pstro with the actual font ! 3534: // character widths. if the difference is the same for each space ! 3535: // character, and the same for each non-space character, then ! 3536: // justification, as we know it, is in effect. ! 3537: ! 3538: // first start off by allocating an array of TEXTDELTAs, so we can fill ! 3539: // them in with the deltas between each character. ! 3540: ! 3541: if (!(pdelta = (TEXTDELTA *)HeapAlloc(pdev->hheap, 0, ! 3542: (sizeof(TEXTDELTA) * (pstro->cGlyphs - 1))))) ! 3543: { ! 3544: #if DBG ! 3545: DbgPrint("PSCRIPT!IsJustifiedText: HeapAlloc for pdelta failed.\n"); ! 3546: #endif ! 3547: return(FALSE); ! 3548: } ! 3549: ! 3550: pdeltaSave = pdelta; ! 3551: ! 3552: // get the original UNICODE string. ! 3553: ! 3554: if (pfo->flFontType & DEVICE_FONTTYPE) ! 3555: pwszOrg = GetUnicodeString(pdev, pfo, pstro); ! 3556: else ! 3557: pwszOrg = pstro->pwszOrg; ! 3558: ! 3559: // fill in the TEXTDELTA structures. ! 3560: ! 3561: if (pstro->pgp) ! 3562: { ! 3563: if (!FillDeltaArray(pdev, pfo, pstro->pgp, pstro, pdelta, pstro->cGlyphs, pwszOrg)) ! 3564: { ! 3565: RIP("PSCRIPT!IsJustifiedText: FillDeltaArray failed.\n"); ! 3566: HeapFree(pdev->hheap, 0, (PVOID)pdeltaSave); ! 3567: return(FALSE); ! 3568: } ! 3569: } ! 3570: else ! 3571: { ! 3572: // prepare to enumerate the string properly. ! 3573: ! 3574: STROBJ_vEnumStart(pstro); ! 3575: ! 3576: // now draw the text. ! 3577: ! 3578: do ! 3579: { ! 3580: bMore = STROBJ_bEnum(pstro, &cGlyphs, &pgp); ! 3581: ! 3582: if (!FillDeltaArray(pdev, pfo, pgp, pstro, pdelta, cGlyphs, pwszOrg)) ! 3583: { ! 3584: RIP("PSCRIPT!IsJustifiedText: FillDeltaArray failed.\n"); ! 3585: HeapFree(pdev->hheap, 0, (PVOID)pdeltaSave); ! 3586: return(FALSE); ! 3587: } ! 3588: ! 3589: pdelta += cGlyphs; ! 3590: pwszOrg += cGlyphs; ! 3591: ! 3592: } while (bMore); ! 3593: } ! 3594: ! 3595: // reset pointer to first structure. ! 3596: ! 3597: pdelta = pdeltaSave; ! 3598: ! 3599: // get the unicode value for the space character. ! 3600: ! 3601: MultiByteToWideChar(CP_ACP, 0, (LPCSTR)" ", 1, (LPWSTR)&wcSpace, 1); ! 3602: ! 3603: // now get the widths of the characters themselves. ! 3604: ! 3605: ptfxSpace.x = -1; ! 3606: ptfxNonSpace.x = -1; ! 3607: ptfxSExtra.x = 0; ! 3608: ptfxSExtra.y = 0; ! 3609: ptfxNSExtra.x = 0; ! 3610: ptfxNSExtra.y = 0; ! 3611: cSpace = 0; ! 3612: cNonSpace = 0; ! 3613: ! 3614: for (i = 0; i < (pstro->cGlyphs - 1); i++) ! 3615: { ! 3616: ptfxTmp.x = abs(pdelta->ptfxorg.x - LTOFX(pdelta->ptlpgp.x)); ! 3617: ptfxTmp.y = abs(pdelta->ptfxorg.y - LTOFX(pdelta->ptlpgp.y)); ! 3618: ! 3619: if (pdelta->wc == wcSpace) ! 3620: { ! 3621: if (ptfxSpace.x == -1) ! 3622: { ! 3623: ptfxSpace = ptfxTmp; ! 3624: ptfxSExtra.x = LTOFX(pdelta->ptlpgp.x) - pdelta->ptfxorg.x; ! 3625: ptfxSExtra.y = LTOFX(pdelta->ptlpgp.y) - pdelta->ptfxorg.y; ! 3626: } ! 3627: else ! 3628: { ! 3629: if ((abs(ptfxSpace.x - ptfxTmp.x) > LTOFX(1)) || ! 3630: (abs(ptfxSpace.y - ptfxTmp.y) > LTOFX(1))) ! 3631: { ! 3632: HeapFree(pdev->hheap, 0, (PVOID)pdeltaSave); ! 3633: return(FALSE); ! 3634: } ! 3635: ! 3636: ptfxSExtra.x += (LTOFX(pdelta->ptlpgp.x) - pdelta->ptfxorg.x); ! 3637: ptfxSExtra.y += (LTOFX(pdelta->ptlpgp.y) - pdelta->ptfxorg.y); ! 3638: } ! 3639: ! 3640: cSpace++; ! 3641: } ! 3642: else // non spacing character. ! 3643: { ! 3644: if (ptfxNonSpace.x == -1) ! 3645: { ! 3646: ptfxNonSpace = ptfxTmp; ! 3647: ptfxNSExtra.x = LTOFX(pdelta->ptlpgp.x) - pdelta->ptfxorg.x; ! 3648: ptfxNSExtra.y = LTOFX(pdelta->ptlpgp.y) - pdelta->ptfxorg.y; ! 3649: } ! 3650: else ! 3651: { ! 3652: if ((abs(ptfxNonSpace.x - ptfxTmp.x) > LTOFX(1)) || ! 3653: (abs(ptfxNonSpace.y - ptfxTmp.y) > LTOFX(1))) ! 3654: { ! 3655: HeapFree(pdev->hheap, 0, (PVOID)pdeltaSave); ! 3656: return(FALSE); ! 3657: } ! 3658: ! 3659: ptfxNSExtra.x += (LTOFX(pdelta->ptlpgp.x) - pdelta->ptfxorg.x); ! 3660: ptfxNSExtra.y += (LTOFX(pdelta->ptlpgp.y) - pdelta->ptfxorg.y); ! 3661: } ! 3662: ! 3663: cNonSpace++; ! 3664: } ! 3665: ! 3666: pdelta++; ! 3667: } ! 3668: ! 3669: // fill in the justification amounts. ! 3670: ! 3671: if (cSpace == 0) ! 3672: { ! 3673: pptSpace->x = 0; ! 3674: pptSpace->y = 0; ! 3675: } ! 3676: else ! 3677: { ! 3678: denom = pdev->psdm.dm.dmPrintQuality * cSpace; ! 3679: ! 3680: pptSpace->x = ((ptfxSExtra.x << 4) * PS_RESOLUTION) / denom; ! 3681: pptSpace->y = ((ptfxSExtra.y << 4) * PS_RESOLUTION) / denom; ! 3682: } ! 3683: ! 3684: if (cNonSpace == 0) ! 3685: { ! 3686: pptNonSpace->x = 0; ! 3687: pptNonSpace->y = 0; ! 3688: } ! 3689: else ! 3690: { ! 3691: denom = pdev->psdm.dm.dmPrintQuality * cNonSpace; ! 3692: ! 3693: pptNonSpace->x = ((ptfxNSExtra.x << 4) * PS_RESOLUTION) / denom; ! 3694: pptNonSpace->y = ((ptfxNSExtra.y << 4) * PS_RESOLUTION) / denom; ! 3695: } ! 3696: ! 3697: // free some memory. ! 3698: ! 3699: HeapFree(pdev->hheap, 0, (PVOID)pdeltaSave); ! 3700: ! 3701: return(TRUE); ! 3702: } ! 3703: ! 3704: ! 3705: //-------------------------------------------------------------------------- ! 3706: // BOOL FillDeltaArray(pdev, pfo, pgp, pstro, pdelta, cGlyphs, pwsz) ! 3707: // PDEVDATA pdev; ! 3708: // FONTOBJ *pfo; ! 3709: // GLYPHPOS *pgp; ! 3710: // STROBJ *pstro; ! 3711: // TEXTDELTA *pdelta; ! 3712: // DWORD cGlyphs; ! 3713: // PWSZ pwsz; ! 3714: // ! 3715: // This routine fills in the given TEXTDELTA array from the given STROBJ. ! 3716: // ! 3717: // History: ! 3718: // 31-Mar-1993 -by- Kent Settle (kentse) ! 3719: // Wrote it. ! 3720: //-------------------------------------------------------------------------- ! 3721: ! 3722: BOOL FillDeltaArray(pdev, pfo, pgp, pstro, pdelta, cGlyphs, pwsz) ! 3723: PDEVDATA pdev; ! 3724: FONTOBJ *pfo; ! 3725: GLYPHPOS *pgp; ! 3726: STROBJ *pstro; ! 3727: TEXTDELTA *pdelta; ! 3728: DWORD cGlyphs; ! 3729: PWSZ pwsz; ! 3730: { ! 3731: DWORD i; ! 3732: GLYPHDATA *pglyphdata; ! 3733: DWORD cReturned; ! 3734: GLYPHDATA glyphdata; ! 3735: ! 3736: if (!pwsz) ! 3737: { ! 3738: #if DBG ! 3739: DbgPrint("PSCRIPT!FillDeltaArray: NULL pwsz.\n"); ! 3740: #endif ! 3741: return(FALSE); ! 3742: } ! 3743: ! 3744: // initialize pglyphdata for device font case. ! 3745: ! 3746: pglyphdata = &glyphdata; ! 3747: ! 3748: // fill in the TEXTDELTA structures. ! 3749: ! 3750: for (i = 0; i < (cGlyphs - 1); i++) ! 3751: { ! 3752: // get the UNICODE code point. ! 3753: ! 3754: pdelta->wc = *pwsz++; ! 3755: ! 3756: // get the delta vector as defined by the GLYPHPOS. ! 3757: ! 3758: pdelta->ptlpgp.x = (pgp + 1)->ptl.x - pgp->ptl.x; ! 3759: pdelta->ptlpgp.y = (pgp + 1)->ptl.y - pgp->ptl.y; ! 3760: ! 3761: if (pfo->flFontType & DEVICE_FONTTYPE) ! 3762: { ! 3763: if (!GetDeviceWidths(pdev, pfo, &glyphdata, pgp->hg)) ! 3764: { ! 3765: RIP("PSCRIPT!FillDeltaArray: GetDeviceWidth failed.\n"); ! 3766: return(FALSE); ! 3767: } ! 3768: } ! 3769: else ! 3770: { ! 3771: // now get the delta vector for the glyph itself. ! 3772: ! 3773: if (!(cReturned = FONTOBJ_cGetGlyphs(pfo, FO_GLYPHBITS, 1, ! 3774: &pgp->hg, ! 3775: (PVOID *)&pglyphdata))) ! 3776: { ! 3777: RIP("PSCRIPT!FillDeltaArray: cGetGlyphs failed.\n"); ! 3778: return(FALSE); ! 3779: } ! 3780: } ! 3781: ! 3782: pdelta->ptfxorg.x = pglyphdata->ptqD.x.HighPart; ! 3783: pdelta->ptfxorg.y = pglyphdata->ptqD.y.HighPart; ! 3784: ! 3785: pgp++; ! 3786: pdelta++; ! 3787: } ! 3788: ! 3789: return(TRUE); ! 3790: } ! 3791: ! 3792: ! 3793: //-------------------------------------------------------------------------- ! 3794: // PWSTR GetUnicodeString(pdev, pfo, pstro) ! 3795: // PDEVDATA pdev; ! 3796: // FONTOBJ *pfo; ! 3797: // STROBJ *pstro; ! 3798: // ! 3799: // This routine allocates a UNICODE string, and fills it is from the pstro. ! 3800: // This routine is ONLY called for device fonts. ! 3801: // ! 3802: // History: ! 3803: // 10-May-1993 -by- Kent Settle (kentse) ! 3804: // Wrote it. ! 3805: //-------------------------------------------------------------------------- ! 3806: ! 3807: PWSTR GetUnicodeString(pdev, pfo, pstro) ! 3808: PDEVDATA pdev; ! 3809: FONTOBJ *pfo; ! 3810: STROBJ *pstro; ! 3811: { ! 3812: PWSTR pwstr, pwstrSave; ! 3813: BOOL bMore; ! 3814: PUCMap pmap; ! 3815: PNTFM pntfm; ! 3816: DWORD cGlyphs; ! 3817: GLYPHPOS *pgp; ! 3818: ! 3819: // allocate the UNICODE string, leaving room for NULL terminator. ! 3820: ! 3821: if (!(pwstr = (PWSTR)HeapAlloc(pdev->hheap, 0, ! 3822: ((pstro->cGlyphs + 1) * sizeof(WCHAR))))) ! 3823: { ! 3824: RIP("PSCRIPT!GetUnicodeString: HeapAlloc for pwstr failed.\n"); ! 3825: return((PWSTR)NULL); ! 3826: } ! 3827: ! 3828: pwstrSave = pwstr; ! 3829: ! 3830: // prepare to enumerate the string. ! 3831: ! 3832: STROBJ_vEnumStart(pstro); ! 3833: ! 3834: // get the GLYPHPOS structure for each glyph. from that, get the ! 3835: // HGLYPH. from that, get the UNICODE codepoint, and jam that into ! 3836: // our allocate UNICODE string. ! 3837: ! 3838: // get the font metrics for the specified font. ! 3839: ! 3840: pntfm = pdev->pfmtable[pfo->iFace - 1].pntfm; ! 3841: ! 3842: // get local pointer to mapping table for current font. ! 3843: ! 3844: if (!strcmp((char *)pntfm + pntfm->loszFontName, "Symbol")) ! 3845: pmap = SymbolMap; ! 3846: else if (!strcmp((char *)pntfm + pntfm->loszFontName, "ZapfDingbats")) ! 3847: pmap = DingbatsMap; ! 3848: else ! 3849: pmap = LatinMap; ! 3850: ! 3851: if (pstro->pgp) ! 3852: ConstructUCString(pstro->pgp, pmap, pstro->cGlyphs, pwstr); ! 3853: else ! 3854: { ! 3855: do ! 3856: { ! 3857: bMore = STROBJ_bEnum(pstro, &cGlyphs, &pgp); ! 3858: ! 3859: ConstructUCString(pgp, pmap, cGlyphs, pwstr); ! 3860: ! 3861: pwstr += cGlyphs; ! 3862: ! 3863: } while (bMore); ! 3864: } ! 3865: ! 3866: return(pwstrSave); ! 3867: } ! 3868: ! 3869: ! 3870: //-------------------------------------------------------------------------- ! 3871: // VOID ConstructUCString(pgp, pmap, cGlyphs, pwstr) ! 3872: // GLYPHPOS *pgp; ! 3873: // PUCMap pmap; ! 3874: // DWORD cGlyphs; ! 3875: // PWSTR pwstr; ! 3876: // ! 3877: // This routine constructs a UNICODE string from the pstro. ! 3878: // This routine is ONLY called for device fonts. ! 3879: // ! 3880: // History: ! 3881: // 10-May-1993 -by- Kent Settle (kentse) ! 3882: // Wrote it. ! 3883: //-------------------------------------------------------------------------- ! 3884: ! 3885: VOID ConstructUCString(pgp, pmap, cGlyphs, pwstr) ! 3886: GLYPHPOS *pgp; ! 3887: PUCMap pmap; ! 3888: DWORD cGlyphs; ! 3889: PWSTR pwstr; ! 3890: { ! 3891: BOOL bFound; ! 3892: DWORD i; ! 3893: PUCMap pmapReset; ! 3894: WCHAR *pwc; ! 3895: CHAR jChar; ! 3896: ! 3897: // assume character not found in font. ! 3898: ! 3899: bFound = FALSE; ! 3900: ! 3901: pwc = pwstr; ! 3902: pmapReset = pmap; ! 3903: ! 3904: for (i = 0; i < cGlyphs; i++) ! 3905: { ! 3906: pmap = pmapReset; ! 3907: ! 3908: jChar = (CHAR)pgp->hg; ! 3909: ! 3910: while (pmap->szChar) ! 3911: { ! 3912: // search for the matching code in mapping.h. remember ! 3913: // that the high bit is used to indicate the font needs ! 3914: // to be remapped. so ignore the high bit while checking ! 3915: // for a character match. ! 3916: ! 3917: if (jChar == (CHAR)pmap->usPSValue) ! 3918: { ! 3919: bFound = TRUE; ! 3920: ! 3921: *pwc = (WCHAR)pmap->usUCValue; ! 3922: break; ! 3923: } ! 3924: ! 3925: // point to the next character in mapping.h. ! 3926: ! 3927: pmap++; ! 3928: } // while. ! 3929: ! 3930: // if the character in question was not found, replace it with ! 3931: // our default character. ! 3932: ! 3933: if (!bFound) ! 3934: { ! 3935: // get the unicode value for the period character. ! 3936: ! 3937: MultiByteToWideChar(CP_ACP, 0, (LPCSTR)".", 1, (LPWSTR)pwc, 1); ! 3938: } ! 3939: ! 3940: // point to the next glyph to fill in. ! 3941: ! 3942: pwc++; ! 3943: ! 3944: // point to the next GLYPHPOS structure. ! 3945: ! 3946: pgp++; ! 3947: } ! 3948: ! 3949: // add the NULL terminator. ! 3950: ! 3951: *pwc = (WCHAR)'\0'; ! 3952: } ! 3953: ! 3954: ! 3955: //-------------------------------------------------------------------------- ! 3956: // BOOL GetDeviceWidths(pdev, pfo, pgd, hg) ! 3957: // PDEVDATA pdev; ! 3958: // FONTOBJ *pfo; ! 3959: // GLYPHDATA *pgd; ! 3960: // HGLYPH hg; ! 3961: // ! 3962: // This routine fills in the width parameters of a GLYPHDATA ! 3963: // structure for the given HGLYPH. This is currently needed since ! 3964: // the journaling code does not allow us to do engine callbacks ! 3965: // such as FONTOBJ_cGetGlyphs with a device font. ! 3966: // ! 3967: // History: ! 3968: // 24-May-1993 -by- Kent Settle (kentse) ! 3969: // Wrote it. ! 3970: //-------------------------------------------------------------------------- ! 3971: ! 3972: BOOL GetDeviceWidths(pdev, pfo, pgd, hg) ! 3973: PDEVDATA pdev; ! 3974: FONTOBJ *pfo; ! 3975: GLYPHDATA *pgd; ! 3976: HGLYPH hg; ! 3977: { ! 3978: PNTFM pntfm; ! 3979: XFORMOBJ *pxo; ! 3980: PBYTE pCharCode; ! 3981: PBYTE pCode; ! 3982: PUSHORT pCharWidth; ! 3983: int i; ! 3984: POINTL ptl; ! 3985: POINTFIX ptfx; ! 3986: LONG lWidth; ! 3987: ! 3988: // make sure we have been given a valid font. ! 3989: ! 3990: if ((pfo->iFace == 0) || (pfo->iFace > (pdev->cDeviceFonts + pdev->cSoftFonts))) ! 3991: { ! 3992: RIP("PSCRIPT!GetDeviceWidths: invalid iFace.\n"); ! 3993: SetLastError(ERROR_INVALID_PARAMETER); ! 3994: return(FALSE); ! 3995: } ! 3996: ! 3997: // get the metrics for the given font. ! 3998: ! 3999: pntfm = pdev->pfmtable[pfo->iFace - 1].pntfm; ! 4000: ! 4001: // get the Notional to Device transform. ! 4002: ! 4003: if(!(pxo = FONTOBJ_pxoGetXform(pfo))) ! 4004: { ! 4005: RIP("PSCRIPT!DrvQueryFontData: pxo == NULL.\n"); ! 4006: return(-1); ! 4007: } ! 4008: ! 4009: // get the font transform information. ! 4010: ! 4011: XFORMOBJ_iGetXform(pxo, &pdev->cgs.FontXform); ! 4012: ! 4013: // fill in the glyph widths portions of the GLYPHDATA structure. ! 4014: ! 4015: // We don't actually return bitmaps, but we give them ! 4016: // metrics via this call. ! 4017: ! 4018: // get a pointer to the character codes. ! 4019: ! 4020: pCharCode = ((PBYTE)pntfm + pntfm->loCharMetrics + ! 4021: DWORDALIGN(pntfm->cCharacters * sizeof(USHORT))); ! 4022: ! 4023: // get a pointer to the character widths. ! 4024: ! 4025: pCharWidth = (PUSHORT)((PBYTE)pntfm + pntfm->loCharMetrics); ! 4026: ! 4027: // now get the character width for the given GLYPH. ! 4028: // we set our HGLYPHs to be equal to the PostScript ! 4029: // character code for that given glyph. this allows ! 4030: // us to quickly search through our font metrics and ! 4031: // find the width for the given character. ! 4032: ! 4033: // first get a pointer to the character codes. once ! 4034: // the character has been found, we know how much to ! 4035: // index into the character widths and find the width ! 4036: // in question. ! 4037: ! 4038: pCode = pCharCode; ! 4039: ! 4040: for (i = 0; (USHORT)i < pntfm->cCharacters; i++) ! 4041: { ! 4042: if (*pCharCode++ == (BYTE)hg) ! 4043: break; ! 4044: } ! 4045: ! 4046: // now get the width in question. ! 4047: ! 4048: lWidth = (LONG)pCharWidth[i]; ! 4049: ! 4050: #if 0 ! 4051: // now fill in the GLYPHDATA structure. ! 4052: // remember under NT 0,0 is top left, while under ! 4053: // PostScript 0,0 is bottom left. return device coords. ! 4054: ! 4055: ptl.x = pntfm->rcBBox.left; ! 4056: ptl.y = 0; ! 4057: ! 4058: XFORMOBJ_bApplyXform(pxo, XF_LTOFX, 1, &ptl, &ptfx); ! 4059: ! 4060: pgd->rclInk.left = FXTOL(iHipot(ptfx.x, ptfx.y)); ! 4061: ! 4062: ptl.x = pntfm->rcBBox.bottom; ! 4063: ptl.y = 0; ! 4064: ! 4065: XFORMOBJ_bApplyXform(pxo, XF_LTOFX, 1, &ptl, &ptfx); ! 4066: ! 4067: pgd->rclInk.top = FXTOL(iHipot(ptfx.x, ptfx.y)); ! 4068: ! 4069: ptl.x = pntfm->rcBBox.right; ! 4070: ptl.y = 0; ! 4071: ! 4072: XFORMOBJ_bApplyXform(pxo, XF_LTOFX, 1, &ptl, &ptfx); ! 4073: ! 4074: pgd->rclInk.right = FXTOL(iHipot(ptfx.x, ptfx.y)); ! 4075: ! 4076: ptl.x = pntfm->rcBBox.top; ! 4077: ptl.y = 0; ! 4078: ! 4079: XFORMOBJ_bApplyXform(pxo, XF_LTOFX, 1, &ptl, &ptfx); ! 4080: ! 4081: pgd->rclInk.bottom = FXTOL(iHipot(ptfx.x, ptfx.y)); ! 4082: #endif ! 4083: ! 4084: ptl.x = lWidth; ! 4085: ptl.y = 0; ! 4086: ! 4087: XFORMOBJ_bApplyXform(pxo, XF_LTOFX, 1, &ptl, &ptfx); ! 4088: ! 4089: pgd->fxD = iHipot(ptfx.x, ptfx.y); ! 4090: ! 4091: pgd->ptqD.x.HighPart = ptfx.x; ! 4092: pgd->ptqD.x.LowPart = 0; ! 4093: pgd->ptqD.y.HighPart = ptfx.y; ! 4094: pgd->ptqD.y.LowPart = 0; ! 4095: ! 4096: #if 0 ! 4097: pgd->fxA = 0; ! 4098: pgd->fxAB = pgd->fxD; ! 4099: ! 4100: pgd->fxInkTop = - LTOFX(pgd->rclInk.top); ! 4101: pgd->fxInkBottom = - LTOFX(pgd->rclInk.bottom); ! 4102: #endif ! 4103: ! 4104: pgd->hg = hg; ! 4105: ! 4106: return(TRUE); ! 4107: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.