![[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 / video / displays / xga|
Return to textout.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / xga |
1.1 ! root 1: /******************************Module*Header*******************************\ ! 2: * Module Name: TextOut.c ! 3: * ! 4: * XGA Text accelerations ! 5: * ! 6: * Copyright (c) 1992 Microsoft Corporation ! 7: * ! 8: \**************************************************************************/ ! 9: ! 10: #include "driver.h" ! 11: ! 12: // Part of the fix to limit the amount of resources allocated for fonts ! 13: ! 14: #define MAX_GLYPHS_TO_ALLOC 256 ! 15: ! 16: #define CJ_SCAN(cx) (((cx) + 7) >> 3) ! 17: ! 18: BOOL bSetXgaTextColorAndMix(PPDEV ppdev, MIX mix, BRUSHOBJ *pboFore, BRUSHOBJ *pboOpaque); ! 19: BOOL bOpaqueRect(PPDEV pdev, CLIPOBJ *pco, RECTL *prclOpaque, BRUSHOBJ *pboOpaque); ! 20: ! 21: PCACHEDGLYPH pCacheFont(PPDEV ppdev, STROBJ *pstro, FONTOBJ *pfo); ! 22: BOOL bBlowCache(SURFOBJ *pso); ! 23: ! 24: BOOL bHandleCachedFonts( ! 25: SURFOBJ *pso, ! 26: STROBJ *pstro, ! 27: FONTOBJ *pfo, ! 28: CLIPOBJ *pco, ! 29: RECTL *prclExtra, ! 30: RECTL *prclOpaque, ! 31: BRUSHOBJ *pboFore, ! 32: BRUSHOBJ *pboOpaque, ! 33: POINTL *pptlOrg, ! 34: MIX mix ! 35: ); ! 36: ! 37: ! 38: BOOL bHandleNonCachedFonts( ! 39: SURFOBJ *pso, ! 40: STROBJ *pstro, ! 41: FONTOBJ *pfo, ! 42: CLIPOBJ *pco, ! 43: RECTL *prclExtra, ! 44: RECTL *prclOpaque, ! 45: BRUSHOBJ *pboFore, ! 46: BRUSHOBJ *pboOpaque, ! 47: POINTL *pptlOrg, ! 48: MIX mix ! 49: ); ! 50: ! 51: BYTE Rop2ToXgaRop[] = { ! 52: XGA_0, /* 0 */ ! 53: XGA_S_OR_NOT_D, /* DPon */ ! 54: XGA_NOT_S_AND_D, /* DPna */ ! 55: XGA_NOT_S, /* Pn */ ! 56: XGA_NOT_S_AND_NOT_D,/* PDna */ ! 57: XGA_NOT_D, /* Dn */ ! 58: XGA_S_XOR_D, /* DPx */ ! 59: XGA_S_AND_NOT_D, /* DPan */ ! 60: XGA_S_AND_D, /* DPa */ ! 61: XGA_S_XOR_NOT_D, /* DPxn */ ! 62: XGA_D, /* D */ ! 63: XGA_NOT_S_OR_D, /* DPno */ ! 64: XGA_S, /* P */ ! 65: XGA_NOT_S_OR_NOT_D, /* PDno */ ! 66: XGA_S_OR_D, /* DPo */ ! 67: XGA_1 /* 1 */ ! 68: }; ! 69: ! 70: BYTE jNibbleBitSwap[] = { ! 71: 0x00, // 0 - 0000 ! 72: 0x08, // 1 - 0001 ! 73: 0x04, // 2 - 0010 ! 74: 0x0C, // 3 - 0011 ! 75: 0x02, // 4 - 0100 ! 76: 0x0A, // 5 - 0101 ! 77: 0x06, // 6 - 0110 ! 78: 0x0E, // 7 - 0111 ! 79: 0x01, // 8 - 1000 ! 80: 0x09, // 9 - 1001 ! 81: 0x05, // A - 1010 ! 82: 0x0D, // B - 1011 ! 83: 0x03, // C - 1100 ! 84: 0x0B, // D - 1101 ! 85: 0x07, // E - 1110 ! 86: 0x0F // F - 1111 ! 87: }; ! 88: ! 89: #define BITSWAP(b) ((jNibbleBitSwap[b & 0xF] << 4) | (jNibbleBitSwap[(b >> 4) & 0xF])) ! 90: ! 91: ! 92: /**************************************************************************** ! 93: * DrvTextOut ! 94: ***************************************************************************/ ! 95: BOOL DrvTextOut( ! 96: SURFOBJ *pso, ! 97: STROBJ *pstro, ! 98: FONTOBJ *pfo, ! 99: CLIPOBJ *pco, ! 100: RECTL *prclExtra, ! 101: RECTL *prclOpaque, ! 102: BRUSHOBJ *pboFore, ! 103: BRUSHOBJ *pboOpaque, ! 104: POINTL *pptlOrg, ! 105: MIX mix) ! 106: { ! 107: BOOL b; ! 108: ! 109: DISPDBG((2, "XGA.DLL!DrvTextOut - Entry\n")); ! 110: ! 111: vWaitForCoProcessor((PPDEV)pso->dhpdev, 100); ! 112: ! 113: b = FALSE; ! 114: ! 115: // For now only handle fonts with the A & B spaceing components ! 116: // of 0. This limitation will be removed when I get some more time ! 117: // to work on this driver. !!! ! 118: ! 119: if (!(pstro->flAccel & SO_ZERO_BEARINGS)) ! 120: { ! 121: if ((pso) && (pso->iType == STYPE_DEVICE)) ! 122: pso = ((PPDEV)(pso->dhpdev))->pSurfObj; ! 123: ! 124: b = EngTextOut(pso, pstro, pfo, pco, ! 125: prclExtra, prclOpaque, pboFore, ! 126: pboOpaque, pptlOrg, mix); ! 127: return(b); ! 128: } ! 129: ! 130: if (((PPDEV)pso->dhpdev)->ulfAccelerations_debug & CACHED_FONTS) ! 131: { ! 132: b = bHandleCachedFonts(pso, pstro, pfo, pco, ! 133: prclExtra, prclOpaque, pboFore, ! 134: pboOpaque, pptlOrg, mix); ! 135: ! 136: if (b == FALSE) ! 137: { ! 138: b = bHandleNonCachedFonts(pso, pstro, pfo, pco, ! 139: prclExtra, prclOpaque, pboFore, ! 140: pboOpaque, pptlOrg, mix); ! 141: } ! 142: } ! 143: ! 144: if (b == FALSE) ! 145: { ! 146: if ((pso) && (pso->iType == STYPE_DEVICE)) ! 147: pso = ((PPDEV)(pso->dhpdev))->pSurfObj; ! 148: ! 149: b = EngTextOut(pso, pstro, pfo, pco, ! 150: prclExtra, prclOpaque, pboFore, ! 151: pboOpaque, pptlOrg, mix); ! 152: } ! 153: ! 154: return (b); ! 155: ! 156: ! 157: } ! 158: ! 159: /**************************************************************************** ! 160: * bHandleCachedFonts ! 161: ***************************************************************************/ ! 162: BOOL bHandleCachedFonts( ! 163: SURFOBJ *pso, ! 164: STROBJ *pstro, ! 165: FONTOBJ *pfo, ! 166: CLIPOBJ *pco, ! 167: RECTL *prclExtra, ! 168: RECTL *prclOpaque, ! 169: BRUSHOBJ *pboFore, ! 170: BRUSHOBJ *pboOpaque, ! 171: POINTL *pptlOrg, ! 172: MIX mix) ! 173: { ! 174: BOOL b, ! 175: bMoreGlyphs, ! 176: bFound; ! 177: ! 178: ULONG iGlyph, ! 179: cGlyphs; ! 180: ! 181: POINTL ptl; ! 182: ! 183: GLYPHPOS *pgp; ! 184: ! 185: ULONG ulPhyXgaGlyphBuff; ! 186: ! 187: UINT ihGlyph, ! 188: cxGlyph, ! 189: cyGlyph, ! 190: GlyphBmPitchInBytes, ! 191: GlyphBmPitchInPels; ! 192: ! 193: ULONG XGAPixelOp, ! 194: ulXgaMask; ! 195: ! 196: INT yGlyphBias; ! 197: ! 198: PCACHEDGLYPH pCachedGlyphs, ! 199: pcg; ! 200: ! 201: FONTINFO fi; ! 202: ! 203: ULONG cFntGlyphs; ! 204: ! 205: PXGACPREGS pXgaCpRegs = ((PPDEV)pso->dhpdev)->pXgaCpRegs; ! 206: ! 207: ! 208: DISPDBG((3, "XGA.DLL!bHandleCachedFonts\n")); ! 209: ! 210: // Take care of any opaque rectangles. ! 211: ! 212: if (prclOpaque != NULL) ! 213: { ! 214: b = bOpaqueRect((PPDEV)pso->dhpdev, pco, prclOpaque, pboOpaque); ! 215: if (b == FALSE) ! 216: { ! 217: return (b); ! 218: } ! 219: } ! 220: ! 221: // Take care of the glyph attributes, color and mix. ! 222: ! 223: b = bSetXgaTextColorAndMix((PPDEV)pso->dhpdev, mix, pboFore, pboOpaque); ! 224: if (b == FALSE) ! 225: return (b); ! 226: ! 227: // Take care of setting the clip rectangle for the string. ! 228: ! 229: b = bSetXgaClipping((PPDEV)pso->dhpdev, pco, &ulXgaMask); ! 230: if (b == FALSE) ! 231: return (b); ! 232: ! 233: // Setup the Control Word for the XGA. ! 234: ! 235: XGAPixelOp = BS_BACK_COLOR | FS_FORE_COLOR | ! 236: STEP_PX_BLT | ! 237: SRC_PEL_MAP_A | DST_PEL_MAP_A | ! 238: PATT_PEL_MAP_B | MSK_DISABLE | ! 239: DM_ALL_PELS | OCT_DY ; ! 240: ! 241: XGAPixelOp |= ulXgaMask; ! 242: ! 243: // ! 244: // Get the glyphs into the cache. If the cache is full, then blow ! 245: // away the cache and start caching over. If there is a problem ! 246: // with blowing away the cache go back and try the A/B buffer ! 247: // approach. If the cache was blown away with no error start caching ! 248: // all over again. If there is another problem with caching then go ! 249: // back and try the A/B buffer approach, and finally, if the A/B ! 250: // buffer scheme fails go back to the engine. ! 251: // ! 252: ! 253: pCachedGlyphs = pCacheFont((PPDEV)pso->dhpdev, pstro, pfo); ! 254: if (pCachedGlyphs == NULL) ! 255: { ! 256: DISPDBG((1, "XGA.DLL!bHandleCachedFonts - pCacheFont failed once\n")); ! 257: b = bBlowCache(pso); ! 258: if (b == FALSE) ! 259: { ! 260: DISPDBG((1, "XGA.DLL!bHandleCachedFonts - bBlowCache failed\n")); ! 261: return (FALSE); ! 262: } ! 263: ! 264: pCachedGlyphs = pCacheFont((PPDEV)pso->dhpdev, pstro, pfo); ! 265: if (pCachedGlyphs == NULL) ! 266: { ! 267: DISPDBG((1, "XGA.DLL!bHandleCachedFonts - pCacheFont failed twice\n")); ! 268: return(FALSE); ! 269: } ! 270: } ! 271: ! 272: // Need to get the number of glyphs in the font. ! 273: // Get the font info. ! 274: ! 275: FONTOBJ_vGetInfo(pfo, sizeof(FONTINFO), &fi); ! 276: cFntGlyphs = fi.cGlyphsSupported; ! 277: ! 278: // This is where we clamp the size of the Font structures we are allocating. ! 279: ! 280: if (cFntGlyphs > MAX_GLYPHS_TO_ALLOC) ! 281: cFntGlyphs = MAX_GLYPHS_TO_ALLOC; ! 282: ! 283: ! 284: // Get the Glyph Handles. ! 285: ! 286: STROBJ_vEnumStart(pstro); ! 287: ! 288: do ! 289: { ! 290: bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp); ! 291: ! 292: // If this is a mono-spaced font we need to set the X ! 293: // for each glyph. ! 294: ! 295: if (pstro->ulCharInc != 0) ! 296: { ! 297: UINT ii; ! 298: LONG x,y; ! 299: ! 300: x = pgp[0].ptl.x; ! 301: y = pgp[0].ptl.y; ! 302: for (ii=1; ii < cGlyphs; ii++) ! 303: { ! 304: x += pstro->ulCharInc; ! 305: pgp[ii].ptl.x = x; ! 306: pgp[ii].ptl.y = y; ! 307: } ! 308: } ! 309: ! 310: for (iGlyph = 0; iGlyph < cGlyphs; iGlyph++) ! 311: { ! 312: ! 313: ! 314: // Get the Glyph Handle. ! 315: // If there was a hash table hit for the glygph ! 316: // then were "golden", if not then we have to search ! 317: // the collision list. ! 318: ! 319: ihGlyph = pgp[iGlyph].hg % cFntGlyphs; ! 320: ! 321: pcg = &(pCachedGlyphs[ihGlyph]); ! 322: if (!(pcg->fl & VALID_GLYPH) || (pcg->hg != pgp[iGlyph].hg)) ! 323: { ! 324: DISPDBG((2, "XGA.DLL!bHandleCachedFonts - searching collision list\n")); ! 325: ! 326: bFound = FALSE; ! 327: pcg = &(pCachedGlyphs[ihGlyph]); ! 328: while (pcg->pcgCollisionLink != END_COLLISIONS) ! 329: { ! 330: pcg = pcg->pcgCollisionLink; ! 331: if (pcg->hg == pgp[iGlyph].hg) ! 332: { ! 333: bFound = TRUE; ! 334: break; ! 335: } ! 336: } ! 337: ! 338: // If we do not find the glyph in the cache, then something ! 339: // went wrong. We emit an error message, then fail, so the ! 340: // non-cached font code can render the glyph. ! 341: ! 342: if (bFound == FALSE) ! 343: { ! 344: DISPDBG((1, "XGA.DLL!bHandleCachedFonts - Cached Font not found\n")); ! 345: return (FALSE); ! 346: ! 347: } ! 348: ! 349: } ! 350: ! 351: ulPhyXgaGlyphBuff = pcg->ulCpPhysicalMemory; ! 352: cxGlyph = pcg->sizlBitmap.cx; ! 353: cyGlyph = pcg->sizlBitmap.cy; ! 354: GlyphBmPitchInPels = pcg->BmPitchInPels; ! 355: GlyphBmPitchInBytes = pcg->BmPitchInBytes; ! 356: ! 357: // Adjust the placement of the glyph. ! 358: ! 359: yGlyphBias = (cyGlyph + pcg->ptlOrigin.y) - 1; ! 360: ! 361: ptl.x = pgp[iGlyph].ptl.x + pcg->ptlOrigin.x; ! 362: ptl.y = pgp[iGlyph].ptl.y + yGlyphBias; ! 363: ! 364: // Note: We wait here so every thing that can be done ! 365: // to get ready for the next character is done ! 366: // before we have to wait for the CoProcessor. ! 367: ! 368: vWaitForCoProcessor((PPDEV)pso->dhpdev, 10); ! 369: ! 370: // Setup the pattern bitmap Pel interface registers. ! 371: ! 372: pXgaCpRegs->XGAPixelMapIndex = PEL_MAP_B; ! 373: pXgaCpRegs->XGAPixMapBasePtr = ulPhyXgaGlyphBuff; ! 374: pXgaCpRegs->XGAPixMapWidth = GlyphBmPitchInPels - 1; ! 375: pXgaCpRegs->XGAPixMapHeight = cyGlyph - 1; ! 376: pXgaCpRegs->XGAPixMapFormat = PATT_MAP_FORMAT; ! 377: ! 378: // Setup the Blit pattern and dest. ! 379: // Note: There is no source bitmap, Until we get the pattern ! 380: // brush. ! 381: ! 382: pXgaCpRegs->XGAOpDim1 = cxGlyph - 1; ! 383: pXgaCpRegs->XGAOpDim2 = cyGlyph - 1; ! 384: ! 385: pXgaCpRegs->XGAPatternMapX = 0; ! 386: pXgaCpRegs->XGAPatternMapY = cyGlyph - 1; ! 387: ! 388: pXgaCpRegs->XGADestMapX = LOWORD(ptl.x); ! 389: pXgaCpRegs->XGADestMapY = LOWORD(ptl.y); ! 390: ! 391: // Do the blit operation. ! 392: ! 393: pXgaCpRegs->XGAPixelOp = XGAPixelOp; ! 394: ! 395: ! 396: } ! 397: ! 398: } while(bMoreGlyphs); ! 399: ! 400: return (TRUE); ! 401: ! 402: } ! 403: ! 404: /**************************************************************************** ! 405: * bHandleNonCachedFonts ! 406: ***************************************************************************/ ! 407: BOOL bHandleNonCachedFonts( ! 408: SURFOBJ *pso, ! 409: STROBJ *pstro, ! 410: FONTOBJ *pfo, ! 411: CLIPOBJ *pco, ! 412: RECTL *prclExtra, ! 413: RECTL *prclOpaque, ! 414: BRUSHOBJ *pboFore, ! 415: BRUSHOBJ *pboOpaque, ! 416: POINTL *pptlOrg, ! 417: MIX mix) ! 418: { ! 419: BOOL b, ! 420: bMoreGlyphs; ! 421: ULONG iGlyph, ! 422: cGlyphs; ! 423: GLYPHBITS *pgb; ! 424: POINTL ptl; ! 425: GLYPHPOS *pgp; ! 426: PBYTE pLinXgaGlyphBuff, ! 427: pXgaLinGlyphBuffA, ! 428: pXgaLinGlyphBuffB; ! 429: ULONG ulPhyXgaGlyphBuff, ! 430: ulXgaPhyGlyphBuffA, ! 431: ulXgaPhyGlyphBuffB, ! 432: cjGlyphBuff; ! 433: UINT i, ! 434: cxGlyph, ! 435: cyGlyph, ! 436: nGlyph, ! 437: GlyphBmPitchInBytes, ! 438: GlyphBmPitchInPels; ! 439: ULONG XGAPixelOp, ! 440: ulXgaMask; ! 441: FONTINFO FontInfo; ! 442: PCPALLOCNODE pcpanA, ! 443: pcpanB; ! 444: INT yGlyphBias; ! 445: ! 446: PXGACPREGS pXgaCpRegs = ((PPDEV)pso->dhpdev)->pXgaCpRegs; ! 447: ! 448: DISPDBG((3, "XGA.DLL!bHandleNonCachedFonts\n")); ! 449: ! 450: // Take care of any opaque rectangles. ! 451: ! 452: if (prclOpaque != NULL) ! 453: { ! 454: b = bOpaqueRect((PPDEV)pso->dhpdev, pco, prclOpaque, pboOpaque); ! 455: if (b == FALSE) ! 456: { ! 457: return (b); ! 458: } ! 459: } ! 460: ! 461: // Take care of the glyph attributes, color and mix. ! 462: ! 463: b = bSetXgaTextColorAndMix((PPDEV)pso->dhpdev, mix, pboFore, pboOpaque); ! 464: if (b == FALSE) ! 465: return (b); ! 466: ! 467: // Take care of the clipping. ! 468: ! 469: b = bSetXgaClipping((PPDEV)pso->dhpdev, pco, &ulXgaMask); ! 470: if (b == FALSE) ! 471: return (b); ! 472: ! 473: // Setup the Control Word for the XGA. ! 474: ! 475: XGAPixelOp = BS_BACK_COLOR | FS_FORE_COLOR | ! 476: STEP_PX_BLT | ! 477: SRC_PEL_MAP_A | DST_PEL_MAP_A | ! 478: PATT_PEL_MAP_B | MSK_DISABLE | ! 479: DM_ALL_PELS | OCT_DY ; ! 480: ! 481: XGAPixelOp |= ulXgaMask; ! 482: ! 483: // Get the size of the largest glyph in the font. ! 484: ! 485: FONTOBJ_vGetInfo(pfo, sizeof(FONTINFO), &FontInfo); ! 486: ! 487: cjGlyphBuff = FontInfo.cjMaxGlyph1; ! 488: ! 489: // Get the Glyph Data. ! 490: ! 491: STROBJ_vEnumStart(pstro); ! 492: ! 493: // Get two buffers in XGA off screen memory. ! 494: ! 495: pcpanA = (PCPALLOCNODE) hCpAlloc((PPDEV)pso->dhpdev, cjGlyphBuff, XGA_LOCK_MEM); ! 496: pXgaLinGlyphBuffA = (PBYTE) pcpanA->pCpLinearMemory; ! 497: ulXgaPhyGlyphBuffA = pcpanA->ulCpPhysicalMemory; ! 498: ! 499: pcpanB = (PCPALLOCNODE) hCpAlloc((PPDEV)pso->dhpdev, cjGlyphBuff, XGA_LOCK_MEM); ! 500: pXgaLinGlyphBuffB = (PBYTE) pcpanB->pCpLinearMemory; ! 501: ulXgaPhyGlyphBuffB = pcpanB->ulCpPhysicalMemory; ! 502: ! 503: do ! 504: { ! 505: bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp); ! 506: ! 507: // If this is a mono-spaced font we need to set the X ! 508: // for each glyph. ! 509: ! 510: if (pstro->ulCharInc != 0) ! 511: { ! 512: UINT ii; ! 513: LONG x,y; ! 514: ! 515: x = pgp[0].ptl.x; ! 516: y = pgp[0].ptl.y; ! 517: for (ii=1; ii < cGlyphs; ii++) ! 518: { ! 519: x += pstro->ulCharInc; ! 520: pgp[ii].ptl.x = x; ! 521: pgp[ii].ptl.y = y; ! 522: } ! 523: } ! 524: ! 525: for (iGlyph = 0; iGlyph < cGlyphs; iGlyph++) ! 526: { ! 527: ! 528: // Get a pointer to the GlyphBits. ! 529: ! 530: pgb = pgp[iGlyph].pgdf->pgb; ! 531: ! 532: // Get the linear address for the XGA Glyph Buffer. ! 533: ! 534: if (iGlyph & 0x1) ! 535: { ! 536: pLinXgaGlyphBuff = pXgaLinGlyphBuffA; ! 537: ulPhyXgaGlyphBuff = ulXgaPhyGlyphBuffA; ! 538: } ! 539: else ! 540: { ! 541: pLinXgaGlyphBuff = pXgaLinGlyphBuffB; ! 542: ulPhyXgaGlyphBuff = ulXgaPhyGlyphBuffB; ! 543: } ! 544: ! 545: // Copy over the bits. ! 546: ! 547: cxGlyph = pgb->sizlBitmap.cx; ! 548: cyGlyph = pgb->sizlBitmap.cy; ! 549: ! 550: GlyphBmPitchInBytes = CJ_SCAN(cxGlyph); ! 551: GlyphBmPitchInPels = GlyphBmPitchInBytes * 8; ! 552: ! 553: nGlyph = GlyphBmPitchInBytes * cyGlyph; ! 554: ! 555: // Need to swap the bits with in the byte. ! 556: // I think there is an easier way. ! 557: ! 558: for (i = 0; i < nGlyph; i++) ! 559: { ! 560: pLinXgaGlyphBuff[i] = BITSWAP(pgb->aj[i]); ! 561: } ! 562: ! 563: // Adjust the placement of the glyph. ! 564: ! 565: yGlyphBias = (cyGlyph + pgb->ptlOrigin.y) - 1; ! 566: ! 567: ptl.x = pgp[iGlyph].ptl.x; ! 568: ptl.y = pgp[iGlyph].ptl.y + yGlyphBias; ! 569: ! 570: // Note: We wait here so every thing that can be done ! 571: // to get ready for the next character is done ! 572: // before we have to wait for the CoProcessor. ! 573: ! 574: vWaitForCoProcessor((PPDEV)pso->dhpdev, 10); ! 575: ! 576: // Setup the pattern bitmap Pel interface registers. ! 577: ! 578: pXgaCpRegs->XGAPixelMapIndex = PEL_MAP_B; ! 579: pXgaCpRegs->XGAPixMapBasePtr = ulPhyXgaGlyphBuff; ! 580: pXgaCpRegs->XGAPixMapWidth = GlyphBmPitchInPels - 1; ! 581: pXgaCpRegs->XGAPixMapHeight = cyGlyph - 1; ! 582: pXgaCpRegs->XGAPixMapFormat = PATT_MAP_FORMAT; ! 583: ! 584: // Setup the Blit pattern and dest. ! 585: // Note: There is no source bitmap, Until we get the pattern ! 586: // brush. ! 587: ! 588: pXgaCpRegs->XGAOpDim1 = cxGlyph - 1; ! 589: pXgaCpRegs->XGAOpDim2 = cyGlyph - 1; ! 590: ! 591: pXgaCpRegs->XGAPatternMapX = 0; ! 592: pXgaCpRegs->XGAPatternMapY = cyGlyph - 1; ! 593: ! 594: pXgaCpRegs->XGADestMapX = LOWORD(ptl.x); ! 595: pXgaCpRegs->XGADestMapY = LOWORD(ptl.y); ! 596: ! 597: // Do the blit operation. ! 598: ! 599: pXgaCpRegs->XGAPixelOp = XGAPixelOp; ! 600: ! 601: ! 602: } ! 603: ! 604: ! 605: } while(bMoreGlyphs); ! 606: ! 607: hCpFree((PPDEV)(pso->dhpdev), (HANDLE) pcpanA); ! 608: hCpFree((PPDEV)(pso->dhpdev), (HANDLE) pcpanB); ! 609: ! 610: return (TRUE); ! 611: ! 612: } ! 613: ! 614: ! 615: /***************************************************************************** ! 616: * XGA Solid Opaque Rect. ! 617: * ! 618: * Returns TRUE if the Opaque Rect was handled. ! 619: ****************************************************************************/ ! 620: BOOL bOpaqueRect(PPDEV ppdev, CLIPOBJ *pco, RECTL *prclOpaque, BRUSHOBJ *pboOpaque) ! 621: ! 622: { ! 623: BOOL b; ! 624: INT width, ! 625: height; ! 626: ! 627: ULONG XGAPixelOp, ! 628: ulXgaMask, ! 629: iSolidColor; ! 630: ! 631: PXGACPREGS pXgaCpRegs = ppdev->pXgaCpRegs; ! 632: ! 633: ! 634: DISPDBG((3, "XGA.DLL!bOpaqueRect - Entry\n")); ! 635: ! 636: b = bSetXgaClipping(ppdev, pco, &ulXgaMask); ! 637: if (b == FALSE) ! 638: return (b); ! 639: ! 640: ! 641: iSolidColor = pboOpaque->iSolidColor; ! 642: if (iSolidColor == -1) ! 643: return(FALSE); ! 644: ! 645: // Setup the BitBlt parameters. ! 646: ! 647: width = (prclOpaque->right - prclOpaque->left) - 1; ! 648: height = (prclOpaque->bottom - prclOpaque->top) - 1; ! 649: ! 650: pXgaCpRegs->XGAOpDim1 = width; ! 651: pXgaCpRegs->XGAOpDim2 = height; ! 652: ! 653: pXgaCpRegs->XGADestMapX = (USHORT) prclOpaque->left; ! 654: pXgaCpRegs->XGADestMapY = (USHORT) prclOpaque->top; ! 655: ! 656: pXgaCpRegs->XGAForeGrMix = XGA_S; ! 657: pXgaCpRegs->XGABackGrMix = XGA_S; ! 658: ! 659: pXgaCpRegs->XGAForeGrColorReg = iSolidColor; ! 660: pXgaCpRegs->XGABackGrColorReg = iSolidColor; ! 661: ! 662: // Now build the Pel Operation Register Op Code; ! 663: ! 664: XGAPixelOp = BS_BACK_COLOR | FS_FORE_COLOR | ! 665: STEP_PX_BLT | ! 666: SRC_PEL_MAP_A | DST_PEL_MAP_A | ! 667: PATT_FOREGROUND; ! 668: ! 669: XGAPixelOp |= ulXgaMask; ! 670: ! 671: pXgaCpRegs->XGAPixelOp = XGAPixelOp; ! 672: ! 673: vWaitForCoProcessor(ppdev, 10); ! 674: ! 675: return (TRUE); ! 676: ! 677: ! 678: } ! 679: ! 680: ! 681: ! 682: /****************************************************************************** ! 683: * bSetXgaTextColorAndMix - Setup the XGA's Text Colors and mix modes ! 684: *****************************************************************************/ ! 685: BOOL bSetXgaTextColorAndMix(PPDEV ppdev, MIX mix, BRUSHOBJ *pboFore, BRUSHOBJ *pboOpaque) ! 686: { ! 687: ULONG ulForeSolidColor; ! 688: BYTE jXgaForeMix; ! 689: ! 690: PXGACPREGS pXgaCpRegs = ppdev->pXgaCpRegs; ! 691: ! 692: // Pickup all the glyph attributes. ! 693: ! 694: jXgaForeMix = Rop2ToXgaRop[(mix & 0xF) - R2_BLACK]; ! 695: ! 696: ulForeSolidColor = pboFore->iSolidColor; ! 697: ! 698: // Let the engine handle the non-solid brush cases. ! 699: ! 700: if (ulForeSolidColor == -1) ! 701: return(FALSE); ! 702: ! 703: // Set the XGA Attributes. ! 704: ! 705: pXgaCpRegs->XGAForeGrMix = jXgaForeMix; ! 706: pXgaCpRegs->XGABackGrMix = XGA_D; ! 707: ! 708: pXgaCpRegs->XGAForeGrColorReg = ulForeSolidColor; ! 709: } ! 710: ! 711: ! 712: ! 713: ! 714: ! 715: /***************************************************************************** ! 716: * pCacheFont - Make sure the glyphs we need in this font are cached. ! 717: * Return a pointer to the array of glyph caches. ! 718: * ! 719: * if there is an error, return NULL. ! 720: ****************************************************************************/ ! 721: PCACHEDGLYPH pCacheFont(PPDEV ppdev, STROBJ *pstro, FONTOBJ *pfo) ! 722: { ! 723: ULONG iUniq; ! 724: ! 725: FONTINFO fi; ! 726: ! 727: PCACHEDFONT pcf, ! 728: pCachedFont; ! 729: ! 730: ULONG i, ! 731: iGlyph, ! 732: cFntGlyphs, ! 733: cStrGlyphs, ! 734: nGlyph, ! 735: iGlyphCache; ! 736: ! 737: UINT nSize; ! 738: ! 739: GLYPHPOS *pgp; ! 740: ! 741: GLYPHBITS *pgb; ! 742: ! 743: PCACHEDGLYPH pCachedGlyphs, ! 744: pcgNew, ! 745: pcg; ! 746: ! 747: ULONG cxGlyph, ! 748: cyGlyph, ! 749: GlyphBmPitchInPels, ! 750: GlyphBmPitchInBytes; ! 751: ! 752: PBYTE pLinXgaGlyphBuff; ! 753: ! 754: PCPALLOCNODE pcpan; ! 755: ! 756: HGLYPH hg; ! 757: ! 758: BOOL bFound; ! 759: ! 760: // Are we already doing any caching for this font? ! 761: ! 762: iUniq = pfo->iUniq; ! 763: ! 764: if (ppdev->pCachedFontsRoot == NULL) ! 765: { ! 766: // This is the first font. ! 767: // Allocate a node for it. ! 768: ! 769: ppdev->pCachedFontsRoot = (PCACHEDFONT) LocalAlloc(LPTR, sizeof(CACHEDFONT)); ! 770: if (ppdev->pCachedFontsRoot == NULL) ! 771: { ! 772: DISPDBG((1, "XGA.DLL!pCacheFont - LocalAlloc of pCachedFontsRoot failed\n")); ! 773: return(NULL); ! 774: } ! 775: ! 776: pCachedFont = ppdev->pCachedFontsRoot; ! 777: pCachedFont->iUniq = iUniq; ! 778: ! 779: } ! 780: else ! 781: { ! 782: // Search for the font in the font list ! 783: ! 784: for (pcf = ppdev->pCachedFontsRoot; pcf != NULL; pcf = pcf->pcfNext) ! 785: { ! 786: if (pcf->iUniq == iUniq) ! 787: break; ! 788: } ! 789: ! 790: if (pcf != NULL) ! 791: { ! 792: pCachedFont = pcf; ! 793: } ! 794: else ! 795: { ! 796: // Allocate a Font Cache node. ! 797: ! 798: pCachedFont = (PCACHEDFONT) LocalAlloc(LPTR, sizeof(CACHEDFONT)); ! 799: if (pCachedFont == NULL) ! 800: { ! 801: DISPDBG((1, "XGA.DLL!pCacheFont - LocalAlloc of pCachedFont failed\n")); ! 802: return(NULL); ! 803: } ! 804: ! 805: // Add this font to the beginning of the font list. ! 806: ! 807: pCachedFont->pcfNext = ppdev->pCachedFontsRoot; ! 808: ppdev->pCachedFontsRoot = pCachedFont; ! 809: ! 810: // Set the font ID for the font. ! 811: ! 812: pCachedFont->iUniq = iUniq; ! 813: } ! 814: } ! 815: ! 816: // If this font is new to the font cache, allocate the glyph cache. ! 817: ! 818: FONTOBJ_vGetInfo(pfo, sizeof(FONTINFO), &fi); ! 819: cFntGlyphs = fi.cGlyphsSupported; ! 820: ! 821: // This is where we clamp the size of the Font structures we are allocating. ! 822: ! 823: if (cFntGlyphs > MAX_GLYPHS_TO_ALLOC) ! 824: cFntGlyphs = MAX_GLYPHS_TO_ALLOC; ! 825: ! 826: if (pCachedFont->pCachedGlyphs == NULL) ! 827: { ! 828: // Get the font info. ! 829: ! 830: pCachedFont->cGlyphs = cFntGlyphs; ! 831: ! 832: // Allocate memory for the CachedGlyphs of this font. ! 833: ! 834: nSize = cFntGlyphs * sizeof(CACHEDGLYPH); ! 835: ! 836: pCachedFont->pCachedGlyphs = (PCACHEDGLYPH) LocalAlloc(LPTR, nSize); ! 837: if (pCachedFont->pCachedGlyphs == NULL) ! 838: { ! 839: DISPDBG((1, "XGA.DLL!pCacheFont - LocalAlloc of pCachedGlyphs failed\n")); ! 840: pCachedFont->cGlyphs = 0; ! 841: return(NULL); ! 842: } ! 843: ! 844: } ! 845: ! 846: // Add the glyphs we're concerned about to the Glyph Cache. ! 847: ! 848: STROBJ_bEnum(pstro, &cStrGlyphs, &pgp); ! 849: ! 850: pCachedGlyphs = pCachedFont->pCachedGlyphs; ! 851: for (iGlyph = 0; iGlyph < cStrGlyphs; iGlyph++) ! 852: { ! 853: // Get the glyph handle, this will be used as the index ! 854: // into the glyph cache for this font. ! 855: ! 856: iGlyphCache = (UINT) pgp[iGlyph].hg % cFntGlyphs; ! 857: ! 858: // Check if the glyph is already in the cache. ! 859: ! 860: hg = pgp[iGlyph].hg; ! 861: pcg = &(pCachedGlyphs[iGlyphCache]); ! 862: if (!(pcg->fl & VALID_GLYPH) || (pcg->hg != hg)) ! 863: { ! 864: // The glyph element in the main hash table for this font ! 865: // is not for this glyph. ! 866: // Search the collision list to see if we have allocated ! 867: // a glyph node yet. ! 868: ! 869: bFound = FALSE; ! 870: for (pcg = &(pCachedGlyphs[iGlyphCache]); ! 871: pcg->pcgCollisionLink != END_COLLISIONS; ! 872: pcg = pcg->pcgCollisionLink) ! 873: { ! 874: if (pcg->hg == hg) ! 875: { ! 876: bFound = TRUE; ! 877: break; ! 878: } ! 879: } ! 880: ! 881: // If we found an allocated glyph node for this font, ! 882: // then continue the testing for glyphs. ! 883: ! 884: if (bFound == TRUE) ! 885: continue; ! 886: ! 887: // A glyph node has not been allocated for this glyph yet ! 888: // in the collision list, so search to the end of the collision ! 889: // and allocate the node. ! 890: ! 891: if (!(pCachedGlyphs[iGlyphCache].fl & VALID_GLYPH)) ! 892: { ! 893: // The glyph element has not been allocated yet, so ! 894: // we will allocate it now. ! 895: ! 896: pcg = &(pCachedGlyphs[iGlyphCache]); ! 897: } ! 898: else ! 899: { ! 900: DISPDBG((2, "XGA.DLL!pCacheFont - Collision in the glyph hash table\n")); ! 901: ! 902: // Search for the end of the collision list. ! 903: ! 904: pcg = &(pCachedGlyphs[iGlyphCache]); ! 905: ! 906: while (pcg->pcgCollisionLink != END_COLLISIONS) ! 907: { ! 908: pcg = pcg->pcgCollisionLink; ! 909: } ! 910: ! 911: // Allocate a new font glyph node. ! 912: ! 913: pcgNew = (PCACHEDGLYPH) LocalAlloc(LPTR, sizeof(CACHEDGLYPH)); ! 914: if (pcgNew == NULL) ! 915: { ! 916: DISPDBG((1, "XGA.DLL!pCacheFont - Local Alloc (pcgNew) failed\n")); ! 917: return (NULL); ! 918: } ! 919: ! 920: // Connect the end of the collision list to the new ! 921: // glyph node. ! 922: ! 923: pcg->pcgCollisionLink = pcgNew; ! 924: ! 925: // Set up the pointer to the node where going to init. ! 926: ! 927: pcg = pcgNew; ! 928: ! 929: } ! 930: ! 931: ! 932: ! 933: // Pickup the pointer to the glyph bits. ! 934: ! 935: pgb = pgp[iGlyph].pgdf->pgb; ! 936: ! 937: cxGlyph = pgb->sizlBitmap.cx; ! 938: cyGlyph = pgb->sizlBitmap.cy; ! 939: ! 940: GlyphBmPitchInBytes = CJ_SCAN(cxGlyph); ! 941: GlyphBmPitchInPels = GlyphBmPitchInBytes * 8; ! 942: ! 943: nGlyph = GlyphBmPitchInBytes * cyGlyph; ! 944: ! 945: // Allocate memory for the glyph data on the XGA. ! 946: ! 947: pcpan = (PCPALLOCNODE) hCpAlloc(ppdev ,nGlyph, XGA_LOCK_MEM); ! 948: if (pcpan == NULL) ! 949: { ! 950: DISPDBG((1, "XGA.DLL!pCacheFont - hCpAlloc failed\n")); ! 951: return(NULL); ! 952: } ! 953: ! 954: // Initialize the Glyph Cache node. ! 955: ! 956: pcg->fl |= VALID_GLYPH; ! 957: pcg->hg = pgp[iGlyph].hg; ! 958: pcg->pcgCollisionLink = END_COLLISIONS; ! 959: pcg->ptlOrigin = pgb->ptlOrigin; ! 960: pcg->sizlBitmap = pgb->sizlBitmap; ! 961: ! 962: pcg->BmPitchInPels = GlyphBmPitchInPels; ! 963: pcg->BmPitchInBytes = GlyphBmPitchInBytes; ! 964: ! 965: pcg->pcpan = pcpan; ! 966: pcg->pCpLinearMemory = pcpan->pCpLinearMemory; ! 967: pcg->ulCpPhysicalMemory = pcpan->ulCpPhysicalMemory; ! 968: ! 969: // Initialize the Glyph Cache data in XGA memory. ! 970: ! 971: pLinXgaGlyphBuff = pcpan->pCpLinearMemory; ! 972: ! 973: // Need to swap the bits with in the byte. ! 974: // I think there is an easier way. ! 975: ! 976: for (i = 0; i < nGlyph; i++) ! 977: { ! 978: pLinXgaGlyphBuff[i] = BITSWAP(pgb->aj[i]); ! 979: } ! 980: } ! 981: } ! 982: ! 983: return(pCachedGlyphs); ! 984: ! 985: } ! 986: ! 987: /**************************************************************************** ! 988: * bBlowCache - Blow Away the Cache ! 989: ***************************************************************************/ ! 990: BOOL bBlowCache(SURFOBJ *pso) ! 991: { ! 992: BOOL b; ! 993: PCACHEDFONT pcf, ! 994: pcfLast; ! 995: ! 996: // Traverse the CachedFonts list. ! 997: // Free all the system memory used for each font. ! 998: ! 999: for (pcf = ((PPDEV)pso->dhpdev)->pCachedFontsRoot; pcf != NULL; pcf = pcf->pcfNext) ! 1000: { ! 1001: LocalFree(pcf->pCachedGlyphs); ! 1002: } ! 1003: ! 1004: // Now free all the memory for the font nodes. ! 1005: ! 1006: for (pcf = ((PPDEV)pso->dhpdev)->pCachedFontsRoot; pcf != NULL; ) ! 1007: { ! 1008: pcfLast = pcf; ! 1009: pcf = pcf->pcfNext; ! 1010: LocalFree(pcfLast); ! 1011: } ! 1012: ! 1013: ((PPDEV)pso->dhpdev)->pCachedFontsRoot = NULL; ! 1014: ! 1015: // Now Free all the memory used to maintain the XGA heap. ! 1016: ! 1017: b = bCpMmDestroyHeap((PPDEV)pso->dhpdev); ! 1018: if (b == FALSE) ! 1019: { ! 1020: DISPDBG((1, "XGA.DLL!bBlowCache - bCpMmDestroyHeap failed\n")); ! 1021: return (b); ! 1022: } ! 1023: ! 1024: // Now ReInitialize the XGA Heap. ! 1025: ! 1026: b = bCpMmInitHeap( (PPDEV)pso->dhpdev ); ! 1027: if (b == FALSE) ! 1028: { ! 1029: DISPDBG((1, "XGA.DLL!bBlowCache - bCpMmInitHeap failed\n")); ! 1030: } ! 1031: ! 1032: return (b); ! 1033: ! 1034: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.