![[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 / vga|
Return to textout.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga |
1.1 ! root 1: /******************************Module*Header*******************************\ ! 2: * Module Name: textout.c ! 3: * ! 4: * VGA DrvTextOut Entry point ! 5: * ! 6: * Copyright (c) 1992 Microsoft Corporation ! 7: \**************************************************************************/ ! 8: #include "driver.h" ! 9: #include "textout.h" ! 10: ! 11: #define SO_MASK \ ! 12: ( \ ! 13: SO_FLAG_DEFAULT_PLACEMENT | \ ! 14: SO_ZERO_BEARINGS | \ ! 15: SO_CHAR_INC_EQUAL_BM_BASE | \ ! 16: SO_MAXEXT_EQUAL_BM_SIDE \ ! 17: ) ! 18: ! 19: // accelerator masks for four canonical directions of ! 20: // writing (multiples of 90 degrees) ! 21: ! 22: #define SO_LTOR (SO_MASK | SO_HORIZONTAL) ! 23: #define SO_RTOL (SO_LTOR | SO_REVERSED) ! 24: #define SO_TTOB (SO_MASK | SO_VERTICAL) ! 25: #define SO_BTOT (SO_TTOB | SO_REVERSED) ! 26: ! 27: /**************************************************************************\ ! 28: * Function Declarations ! 29: \**************************************************************************/ ! 30: ! 31: VOID vGlyphBlt (PDEVSURF,PRECTL,ULONG,PGLYPHPOS,ULONG,ULONG,ULONG,FLONG); ! 32: VOID vStringBlt(PDEVSURF,PRECTL,ULONG,PGLYPHPOS,ULONG,ULONG,ULONG,FLONG); ! 33: ULONG ulSetXParentRegs(ROP4,PULONG,BOOL); ! 34: VOID vResetVGARegs(void); ! 35: BOOL bIdenticalRect(PRECTL,PRECTL); ! 36: FLONG flClipRect(PRECTL,PRECTL,PRECTL); ! 37: VOID lclFillRect(CLIPOBJ *pco, ULONG culRcl, PRECTL prcl, PDEVSURF pdsurf, ! 38: INT iColor); ! 39: BOOL DrvIntersectRect(PRECTL prcDst, PRECTL prcSrc1, PRECTL prcSrc2); ! 40: VOID vFastText(GLYPHPOS *, ULONG, PBYTE, ULONG, ULONG, DEVSURF *, RECTL *, ! 41: RECTL *, INT, INT, ULONG, RECTL *); ! 42: ! 43: /**************************************************************************\ ! 44: * Mix mode-Rop4 Mapping Table ! 45: \**************************************************************************/ ! 46: ! 47: static ROP4 arop4[] = { // !!! This table needs serious fixing ! 48: 0x0000, /* 0 */ ! 49: 0x0000, /* DPon */ ! 50: 0x0000, /* DPna */ ! 51: 0x0f0f, /* Pn */ ! 52: 0x0000, /* PDna */ ! 53: 0x5555, /* Dn */ ! 54: 0x0000, /* DPx */ ! 55: 0x0000, /* DPan */ ! 56: 0x0000, /* DPa */ ! 57: 0x0000, /* DPxn */ ! 58: 0x0000, /* D */ ! 59: 0x0000, /* DPno */ ! 60: 0xf0f0, /* P */ ! 61: 0x0000, /* PDno */ ! 62: 0x0000, /* DPo */ ! 63: 0xffff /* 1 */ ! 64: }; ! 65: ! 66: #define B_ORDERED_RECT(prcl) (((prcl) == (PRECTL)NULL) ? 1 : (((prcl)->left <= (prcl)->right) && ((prcl)->top <= (prcl)->bottom))) ! 67: ! 68: ! 69: /******************************Public*Routine******************************\ ! 70: * BOOL DrvTextOut(pso,pstro,pfo,pco,prclExtra,prcOpaque, ! 71: * pvFore,pvBack,pptOrg,r2Fore,r2Back) ! 72: * ! 73: \**************************************************************************/ ! 74: ! 75: BOOL DrvTextOut( ! 76: SURFOBJ *pso, ! 77: STROBJ *pstro, ! 78: FONTOBJ *pfo, ! 79: CLIPOBJ *pco, ! 80: PRECTL prclExtra, ! 81: PRECTL prclOpaque, ! 82: BRUSHOBJ *pboFore, ! 83: BRUSHOBJ *pboOpaque, ! 84: PPOINTL pptlOrg, ! 85: MIX mix) ! 86: { ! 87: PDEVSURF pdsurf; // Pointer to device surface ! 88: ! 89: ULONG iClip; // Clip object's complexity ! 90: ULONG iClipTmp; // Clip object's complexity ! 91: ULONG ircl; // index to current clip rect ! 92: BOOL bMore; // Flag for clip enumeration ! 93: RECT_ENUM txen; // Clip enumeration object ! 94: ! 95: GLYPHPOS *pgp; // pointer to the 1st glyph ! 96: GLYPHBITS *pgb; // pointer to glyph bits. ! 97: ! 98: BOOL bMoreGlyphs; // Glyph enumeration flag ! 99: ULONG cGlyph; // number of glyphs in one batch ! 100: ULONG iGlyph; // index to current glyph ! 101: RECTL rclGlyph; // string/glyph cell ! 102: RECTL rclTmp; // Temporary rectangle ! 103: RECTL rclBankTmp; // Temporary rectangle when bank ! 104: // clipping ! 105: ! 106: ROP4 rop4; // Rop tranlated from mix mode ! 107: ULONG iSolidTextColor; // Solid foreground text color ! 108: ULONG iSolidForeColor; // Solid foreground color ! 109: ULONG iSolidBkColor; // Solid background color ! 110: ! 111: FLONG flStr = 0; // Accelator flag for DrvTextOut() ! 112: ! 113: ULONG ulMixMode; // Glyph mix mode ! 114: PFN pfnBlt; // function to output glyph/string ! 115: FLONG flOption = 0; // Accelator flag for pfnBlt ! 116: FLONG flOptionTemp; // Working version of flOption ! 117: ! 118: RECTL arclTmp[4]; // Temp storage for portions of ! 119: // opaquing rect ! 120: ULONG culRcl; // Temp rectangle count ! 121: ! 122: //--------------------------------------------------------------------- ! 123: // Get the target surface information ! 124: //--------------------------------------------------------------------- ! 125: ! 126: // Now find out if the target is the screen ! 127: pdsurf = (PDEVSURF) pso->dhsurf; ! 128: ! 129: //--------------------------------------------------------------------- ! 130: // Get information about clip object. ! 131: //--------------------------------------------------------------------- ! 132: ! 133: iClip = DC_TRIVIAL; ! 134: ! 135: if (pco != NULL) { ! 136: iClip = pco->iDComplexity; ! 137: } ! 138: ! 139: //--------------------------------------------------------------------- ! 140: // Get text color. ! 141: //--------------------------------------------------------------------- ! 142: ! 143: iSolidForeColor = iSolidTextColor = pboFore->iSolidColor; ! 144: ! 145: //--------------------------------------------------------------------- ! 146: // See if this is text we can handle faster with special-case code. ! 147: //--------------------------------------------------------------------- ! 148: ! 149: if ((((prclOpaque != NULL) && (iClip != DC_COMPLEX)) || ! 150: // handle opaque both non-clipped & ! 151: // rectangle-clipped ! 152: ((prclOpaque == NULL) && (iClip == DC_TRIVIAL))) && ! 153: // handle xpar non-clipped only ! 154: // for now ! 155: (pstro->pgp != NULL) && // no glyph enumeration for now ! 156: (prclExtra == NULL) && // no extra rects for now ! 157: ((pstro->flAccel & (SO_HORIZONTAL | SO_VERTICAL | SO_REVERSED)) == ! 158: SO_HORIZONTAL)) { // only left-to-right text for now ! 159: ! 160: ULONG ulBufferWidthInBytes; ! 161: ULONG ulBufferBytes; ! 162: BOOL bTextPerfectFit; ! 163: ULONG fDrawFlags; ! 164: BYTE *pjTempBuffer; ! 165: BOOL bTempAlloc; ! 166: ! 167: // It's the type of text we can special-case; see if the temp buffer is ! 168: // big enough for the text; if not, try to allocate enough memory. ! 169: // Round up to the nearest dword multiple. ! 170: ! 171: ulBufferWidthInBytes = ((((pstro->rclBkGround.right + 15) & ~0x0F) - ! 172: (pstro->rclBkGround.left & ~0x0F)) >> 3); ! 173: ulBufferBytes = ((ulBufferWidthInBytes * ! 174: (pstro->rclBkGround.bottom - pstro->rclBkGround.top)) + 3) ! 175: & ~0x03; ! 176: ! 177: if (ulBufferBytes <= pdsurf->ulTempBufferSize) { ! 178: // The temp buffer is big enough, so we'll use it ! 179: pjTempBuffer = pdsurf->pvBankBufferPlane0; ! 180: bTempAlloc = FALSE; ! 181: } else { ! 182: // The temp buffer isn't big enough, so we'll try to allocate ! 183: // enough memory ! 184: if ((pjTempBuffer = ! 185: LocalAlloc(LMEM_FIXED, ulBufferBytes)) == NULL) { ! 186: // We couldn't get enough memory, so fall back to the general, ! 187: // slow code ! 188: goto NoFastText; ! 189: } ! 190: ! 191: // Mark that we have to free the buffer when we're done ! 192: bTempAlloc = TRUE; ! 193: } ! 194: ! 195: // One way or another, we've found a buffer that's big enough; set up ! 196: // for accelerated text drawing ! 197: ! 198: // Set fixed pitch, overlap, and top & bottom Y alignment flags ! 199: fDrawFlags = ((pstro->ulCharInc != 0) ? 0x01 : 0) | ! 200: (((pstro->flAccel & (SO_ZERO_BEARINGS | ! 201: SO_FLAG_DEFAULT_PLACEMENT)) != ! 202: (SO_ZERO_BEARINGS | SO_FLAG_DEFAULT_PLACEMENT)) ! 203: ? 0x02 : 0) | ! 204: (((pstro->flAccel & (SO_ZERO_BEARINGS | ! 205: SO_FLAG_DEFAULT_PLACEMENT | ! 206: SO_MAXEXT_EQUAL_BM_SIDE)) == ! 207: (SO_ZERO_BEARINGS | SO_FLAG_DEFAULT_PLACEMENT | ! 208: SO_MAXEXT_EQUAL_BM_SIDE)) ? 0x04 : 0); ! 209: ! 210: // If there's an opaque rectangle, we'll do as much opaquing as ! 211: // possible as we do the text. If the opaque rectangle is larger than ! 212: // the text rectangle, then we'll do the fringe areas right now, and ! 213: // the text and associated background areas together later ! 214: if (prclOpaque != (PRECTL) NULL) { ! 215: ! 216: // This driver only handles solid brushes ! 217: iSolidBkColor = pboOpaque->iSolidColor; ! 218: ! 219: // See if we have fringe areas to do. If so, build a list of ! 220: // rectangles to fill, in rightdown order ! 221: ! 222: culRcl = 0; ! 223: ! 224: // Top fragment ! 225: if (pstro->rclBkGround.top > prclOpaque->top) { ! 226: arclTmp[culRcl].top = prclOpaque->top; ! 227: arclTmp[culRcl].left = prclOpaque->left; ! 228: arclTmp[culRcl].right = prclOpaque->right; ! 229: arclTmp[culRcl++].bottom = pstro->rclBkGround.top; ! 230: } ! 231: ! 232: // Left fragment ! 233: if (pstro->rclBkGround.left > prclOpaque->left) { ! 234: arclTmp[culRcl].top = pstro->rclBkGround.top; ! 235: arclTmp[culRcl].left = prclOpaque->left; ! 236: arclTmp[culRcl].right = pstro->rclBkGround.left; ! 237: arclTmp[culRcl++].bottom = pstro->rclBkGround.bottom; ! 238: } ! 239: ! 240: // Right fragment ! 241: if (pstro->rclBkGround.right < prclOpaque->right) { ! 242: arclTmp[culRcl].top = pstro->rclBkGround.top; ! 243: arclTmp[culRcl].right = prclOpaque->right; ! 244: arclTmp[culRcl].left = pstro->rclBkGround.right; ! 245: arclTmp[culRcl++].bottom = pstro->rclBkGround.bottom; ! 246: } ! 247: ! 248: // Bottom fragment ! 249: if (pstro->rclBkGround.bottom < prclOpaque->bottom) { ! 250: arclTmp[culRcl].bottom = prclOpaque->bottom; ! 251: arclTmp[culRcl].left = prclOpaque->left; ! 252: arclTmp[culRcl].right = prclOpaque->right; ! 253: arclTmp[culRcl++].top = pstro->rclBkGround.bottom; ! 254: } ! 255: ! 256: // Fill any fringe rectangles we found ! 257: if (culRcl != 0) { ! 258: if (iClip == DC_TRIVIAL) { ! 259: vTrgBlt(pdsurf, culRcl, arclTmp, R2_COPYPEN, ! 260: iSolidBkColor); ! 261: } else { ! 262: lclFillRect(pco, culRcl, arclTmp, pdsurf, ! 263: iSolidBkColor); ! 264: } ! 265: } ! 266: } ! 267: ! 268: // We're done with separate opaquing; any further opaquing will happen ! 269: // as part of the text drawing ! 270: ! 271: // Clear the buffer if the text isn't going to set every bit ! 272: bTextPerfectFit = (pstro->flAccel & (SO_ZERO_BEARINGS | ! 273: SO_FLAG_DEFAULT_PLACEMENT | SO_MAXEXT_EQUAL_BM_SIDE | ! 274: SO_CHAR_INC_EQUAL_BM_BASE)) == ! 275: (SO_ZERO_BEARINGS | SO_FLAG_DEFAULT_PLACEMENT | ! 276: SO_MAXEXT_EQUAL_BM_SIDE | SO_CHAR_INC_EQUAL_BM_BASE); ! 277: ! 278: if (!bTextPerfectFit) { ! 279: // Note that we already rounded up to a dword multiple size. ! 280: vClearMemDword((ULONG *)pjTempBuffer, ulBufferBytes >> 2); ! 281: } ! 282: ! 283: // Draw the text into the temp buffer, and thence to the screen ! 284: vFastText(pstro->pgp, ! 285: pstro->cGlyphs, ! 286: ((PBYTE) pjTempBuffer) + ! 287: ((pstro->rclBkGround.left & 0x08) ? 1 : 0), ! 288: ulBufferWidthInBytes, ! 289: pstro->ulCharInc, ! 290: pdsurf, ! 291: &pstro->rclBkGround, ! 292: prclOpaque, ! 293: iSolidForeColor, ! 294: iSolidBkColor, ! 295: fDrawFlags, ! 296: (iClip == DC_TRIVIAL) ? NULL : &pco->rclBounds); ! 297: ! 298: // Free up any memory we allocated for the temp buffer ! 299: if (bTempAlloc) { ! 300: LocalFree(pjTempBuffer); ! 301: } ! 302: ! 303: return(TRUE); ! 304: ! 305: } ! 306: ! 307: NoFastText: ! 308: ! 309: //-------------------------------------------------------------------------- ! 310: // Get the foreground and background colors ! 311: //-------------------------------------------------------------------------- ! 312: ! 313: rop4 = arop4[(mix & 255) - R2_BLACK]; // Get ROP4 from mix mode ! 314: ! 315: // This driver only handles solid brushes ! 316: ! 317: // If no background rectangle, we need to paint only the glyph foreground. ! 318: // Set VGA registers for the current rop and foreground color at once and ! 319: // maintain them while blting the glyphs. ! 320: ! 321: if (prclOpaque == (PRECTL) NULL) ! 322: { ! 323: ulMixMode = ulSetXParentRegs(rop4, &iSolidForeColor, TRUE); ! 324: flStr |= TO_NO_OPAQUE_RECT; ! 325: } else { ! 326: ! 327: // This driver only handles solid brushes ! 328: iSolidBkColor = pboOpaque->iSolidColor; ! 329: // ASSERT ( iSolidBkColor != 0xFFFFFFFFL, "Non solid opaque brush\n" ); ! 330: } ! 331: ! 332: //-------------------------------------------------------------------------- ! 333: // Enumerate glyphs for the string, and output to screen one batch at a time. ! 334: // Here is how we will output background rectangle and glyphs:- ! 335: // ! 336: // if glyphs are non-justified and horizontally aligned ! 337: // if opaque background rectangle doesn't exactly match the string bound ! 338: // Paint portions of background that are outside text cells ! 339: // Output the string one batch at a time, drawing both fg & bg in cells ! 340: // else ! 341: // Paint opaque rectangle only once ! 342: // Output to screen one glyph at a time ! 343: // ! 344: //-------------------------------------------------------------------------- ! 345: ! 346: // Set up the STROBJ for enumerating the glyphs ! 347: ! 348: // STROBJ_vEnumStart(pstro); // This is automatic. ! 349: ! 350: if ((pstro->flAccel == SO_LTOR) && (pstro->ulCharInc != 0)) ! 351: { ! 352: flStr |= TO_FIXED_PITCH; ! 353: if ((pstro->ulCharInc & 7) == 0) ! 354: flStr |= TO_MULTIPLE_BYTE; ! 355: } ! 356: ! 357: do { ! 358: ! 359: // Get the next batch of glyphs ! 360: ! 361: if (pstro->pgp != NULL) { ! 362: // There's only the one batch of glyphs, so save ourselves a call ! 363: pgp = pstro->pgp; ! 364: cGlyph = pstro->cGlyphs; ! 365: bMoreGlyphs = FALSE; ! 366: } else { ! 367: bMoreGlyphs = STROBJ_bEnum(pstro,&cGlyph,&pgp); ! 368: } ! 369: ! 370: //-------------------------------------------------------------------- ! 371: // No glyph, no work! ! 372: //-------------------------------------------------------------------- ! 373: ! 374: if ( cGlyph ) { ! 375: // Collect information about the string. ! 376: ! 377: pgb = pgp->pgdf->pgb; // Locate the bitmap info. ! 378: ! 379: if ((flStr & TO_MULTIPLE_BYTE) && ! 380: ((pgb->ptlOrigin.x + pgp->ptl.x) & 7) == 0) { ! 381: flStr |= TO_BYTE_ALIGNED; ! 382: } ! 383: ! 384: if ((pstro->flAccel == SO_LTOR) && ! 385: (pgb->sizlBitmap.cy <= MAX_GLYPH_HEIGHT)) { ! 386: // We can blt horizontally aligned string with non-justified ! 387: // text at once. ! 388: ! 389: pfnBlt = (PFN)vStringBlt; ! 390: flOption |= VGB_ENTIRE_STRING_BLT; ! 391: ! 392: // we can special-case an aligned byte-size string ! 393: ! 394: flOption |= (flStr & (VGB_BYTE_ALIGNED | VGB_MULTIPLE_BYTE)); ! 395: ! 396: // If there's an opaque rectangle, then if the opaque ! 397: // rectangle exactly matches the text rectangle, we'll do the ! 398: // opaque rectangle as we do the text. If the opaque rectangle ! 399: // is larger than the text rectangle, then we'll do the fringe ! 400: // areas right now, and the text and associated background ! 401: // areas together, later. ! 402: if (!(flStr & TO_NO_OPAQUE_RECT)) { ! 403: ! 404: // See if we have fringe areas to do. If so, build a ! 405: // list of rectangles to fill, in rightdown order ! 406: ! 407: culRcl = 0; ! 408: ! 409: // Top fragment ! 410: if (pstro->rclBkGround.top > prclOpaque->top) { ! 411: arclTmp[culRcl].top = prclOpaque->top; ! 412: arclTmp[culRcl].left = prclOpaque->left; ! 413: arclTmp[culRcl].right = prclOpaque->right; ! 414: arclTmp[culRcl++].bottom = pstro->rclBkGround.top; ! 415: } ! 416: ! 417: // Left fragment ! 418: if (pstro->rclBkGround.left > prclOpaque->left) { ! 419: arclTmp[culRcl].top = pstro->rclBkGround.top; ! 420: arclTmp[culRcl].left = prclOpaque->left; ! 421: arclTmp[culRcl].right = pstro->rclBkGround.left; ! 422: arclTmp[culRcl++].bottom = ! 423: pstro->rclBkGround.bottom; ! 424: } ! 425: ! 426: // Right fragment ! 427: if (pstro->rclBkGround.right < prclOpaque->right) { ! 428: arclTmp[culRcl].top = pstro->rclBkGround.top; ! 429: arclTmp[culRcl].right = prclOpaque->right; ! 430: arclTmp[culRcl].left = pstro->rclBkGround.right; ! 431: arclTmp[culRcl++].bottom = ! 432: pstro->rclBkGround.bottom; ! 433: } ! 434: ! 435: // Bottom fragment ! 436: if (pstro->rclBkGround.bottom < prclOpaque->bottom) { ! 437: arclTmp[culRcl].bottom = prclOpaque->bottom; ! 438: arclTmp[culRcl].left = prclOpaque->left; ! 439: arclTmp[culRcl].right = prclOpaque->right; ! 440: arclTmp[culRcl++].top = pstro->rclBkGround.bottom; ! 441: } ! 442: ! 443: // Fill any fringe rectangles we found ! 444: if (culRcl > 0) { ! 445: if (iClip == DC_TRIVIAL) { ! 446: vTrgBlt(pdsurf, culRcl, arclTmp, R2_COPYPEN, ! 447: iSolidBkColor); ! 448: } else { ! 449: lclFillRect(pco, culRcl, arclTmp, pdsurf, ! 450: iSolidBkColor); ! 451: } ! 452: } ! 453: ! 454: ! 455: // The opaque rectangle exactly matches the text ! 456: // background cells. We can simultaneously paint it ! 457: // with the glyph. Then, pretend no background ! 458: // rectangle. ! 459: ! 460: flStr |= TO_NO_OPAQUE_RECT; ! 461: flOption |= VGB_OPAQUE_BKGRND; ! 462: ! 463: // Although we do not want to set the VGA regs, we ! 464: // need to know their mode when we actually blt. ! 465: ! 466: ulMixMode = ulSetXParentRegs(rop4, &iSolidForeColor, FALSE); ! 467: ! 468: } ! 469: ! 470: // It is foolishly assumed in the clipping vStrBlt that GDI ! 471: // puts all positions in the GLYPHPOS array even when the font ! 472: // is fixed pitch. ! 473: ! 474: if (pstro->ulCharInc != 0) { ! 475: UINT ii; ! 476: LONG x,y; ! 477: ! 478: x = pgp[0].ptl.x; ! 479: y = pgp[0].ptl.y; ! 480: ! 481: for (ii=1; ii<cGlyph; ii++) { ! 482: x += pstro->ulCharInc; ! 483: pgp[ii].ptl.x = x; ! 484: pgp[ii].ptl.y = y; ! 485: } ! 486: } ! 487: } else { ! 488: // We need to output one glyph at a time. ! 489: ! 490: pfnBlt = (PFN) vGlyphBlt; ! 491: ! 492: // It is foolishly assumed in vGlyphBlt that GDI puts all ! 493: // positions in the GLYPHPOS array even when the font is ! 494: // fixed pitch. ! 495: ! 496: if (pstro->ulCharInc != 0) { ! 497: UINT ii; ! 498: LONG x,y; ! 499: ! 500: x = pgp[0].ptl.x; ! 501: y = pgp[0].ptl.y; ! 502: for (ii=1; ii<cGlyph; ii++) { ! 503: x += pstro->ulCharInc; ! 504: pgp[ii].ptl.x = x; ! 505: pgp[ii].ptl.y = y; ! 506: } ! 507: } ! 508: } ! 509: } ! 510: ! 511: //------------------------------------------------------------------ ! 512: // Paint background rectangle if exists. ! 513: //------------------------------------------------------------------ ! 514: ! 515: if (!(flStr & TO_NO_OPAQUE_RECT)) ! 516: { ! 517: switch ( iClip ) ! 518: { ! 519: case DC_RECT: ! 520: ! 521: // Intersect opaque and clip rectangles ! 522: ! 523: flClipRect(&rclTmp, prclOpaque, &pco->rclBounds); ! 524: ! 525: if (BINVALIDRECT(rclTmp)) ! 526: { ! 527: break; ! 528: }; ! 529: prclOpaque = &rclTmp; ! 530: ! 531: case DC_TRIVIAL: ! 532: vTrgBlt(pdsurf, 1, prclOpaque, R2_COPYPEN, iSolidBkColor); ! 533: break; ! 534: ! 535: case DC_COMPLEX: ! 536: ! 537: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, ! 538: ENUM_RECT_LIMIT); ! 539: bMore = TRUE; ! 540: ! 541: do ! 542: { ! 543: if (bMore) { ! 544: bMore = CLIPOBJ_bEnum(pco, (ULONG) ! 545: sizeof(txen), (PVOID) &txen); ! 546: } ! 547: ! 548: for (ircl = 0; ircl < txen.c; ircl++) ! 549: { ! 550: ! 551: // Clip only if we have clipping region ! 552: ! 553: flClipRect ( &rclTmp, prclOpaque, &txen.arcl[ircl] ); ! 554: ! 555: if (!(BINVALIDRECT(rclTmp))) ! 556: { ! 557: // rop4 <--> PATCOPY ! 558: ! 559: vTrgBlt(pdsurf, 1, &rclTmp, ! 560: R2_COPYPEN, iSolidBkColor); ! 561: }; ! 562: } ! 563: ! 564: } while (bMore); ! 565: break; ! 566: } ! 567: ! 568: // We need to paint the background only once. So pretend it ! 569: // does not exist anymore. ! 570: ! 571: flStr |= TO_NO_OPAQUE_RECT; ! 572: ! 573: // Set VGA registers for transparent glyphs. ! 574: ! 575: ulMixMode = ulSetXParentRegs(rop4, &iSolidForeColor, TRUE); ! 576: ! 577: } ! 578: ! 579: //---------------------------------------------------------------------- ! 580: // We are ready to output glyphs to screen. By now either the background ! 581: // rectangle (if any) was painted or we will paint it while outputting ! 582: // each glyph/string. ! 583: //---------------------------------------------------------------------- ! 584: ! 585: for (iGlyph = 0; iGlyph < cGlyph; iGlyph++) ! 586: { ! 587: pgb = pgp[iGlyph].pgdf->pgb; ! 588: iClipTmp = iClip; ! 589: ! 590: if (!(flOption & VGB_ENTIRE_STRING_BLT)) ! 591: { ! 592: pgp[iGlyph].ptl.x += pgb->ptlOrigin.x; ! 593: pgp[iGlyph].ptl.y += pgb->ptlOrigin.y; ! 594: ! 595: rclGlyph.left = pgp[iGlyph].ptl.x; ! 596: rclGlyph.right = rclGlyph.left + pgb->sizlBitmap.cx; ! 597: rclGlyph.top = pgp[iGlyph].ptl.y; ! 598: rclGlyph.bottom = rclGlyph.top + pgb->sizlBitmap.cy; ! 599: ! 600: if ((iClipTmp == DC_TRIVIAL) && ! 601: ((rclGlyph.left < pco->rclBounds.left) || ! 602: (rclGlyph.top < pco->rclBounds.top) || ! 603: (rclGlyph.right > pco->rclBounds.right) || ! 604: (rclGlyph.bottom > pco->rclBounds.bottom))) ! 605: iClipTmp = DC_RECT; ! 606: } else { ! 607: // Build the correct bounding box for the current batch of ! 608: // glyphs (the bounding box in the STROBJ is for the entire ! 609: // string, not on a per-batch basis) ! 610: rclGlyph.left = pgp[iGlyph].ptl.x; ! 611: rclGlyph.right = pgp[iGlyph + cGlyph - 1].ptl.x + ! 612: pgp[iGlyph + cGlyph - 1].pgdf->pgb->sizlBitmap.cx; ! 613: rclGlyph.top = pstro->rclBkGround.top; ! 614: rclGlyph.bottom = pstro->rclBkGround.bottom; ! 615: } ! 616: ! 617: flOption &= ~(VGB_VERT_CLIPPED_GLYPH | VGB_HORIZ_CLIPPED_GLYPH); ! 618: ! 619: switch ( iClipTmp ) ! 620: { ! 621: case DC_RECT: ! 622: ! 623: // Intersect glyph and clip rectangles ! 624: ! 625: flOption |= flClipRect(&rclGlyph, &rclGlyph, &pco->rclBounds); ! 626: if (BINVALIDRECT(rclGlyph)) ! 627: break; ! 628: ! 629: case DC_TRIVIAL: ! 630: // Cycle through all banks that the (possibly clipped) ! 631: // glpyh rect spans ! 632: ! 633: // If the proper bank for the top scan line of ! 634: // the clipped glyph isn't mapped in, map it in ! 635: if ((rclGlyph.top < pdsurf->rcl1WindowClip.top) || ! 636: (rclGlyph.top >= pdsurf->rcl1WindowClip.bottom)) { ! 637: ! 638: // Map in the bank containing the top (possibly ! 639: // clipped) glyph line ! 640: pdsurf->pfnBankControl(pdsurf, ! 641: rclGlyph.top, ! 642: JustifyTop); ! 643: } ! 644: ! 645: // Now draw the part of the rect that's in each ! 646: // bank ! 647: ! 648: for (;;) { ! 649: ! 650: flOptionTemp = flOption | ! 651: flClipRect(&rclBankTmp, &rclGlyph, ! 652: &pdsurf->rcl1WindowClip); ! 653: ! 654: (*pfnBlt)(pdsurf, &rclBankTmp, cGlyph, ! 655: &pgp[iGlyph], iSolidForeColor, iSolidBkColor, ! 656: ulMixMode, flOptionTemp); ! 657: ! 658: // Done if this bank contains the last line ! 659: // of the fill ! 660: if (rclGlyph.bottom <= pdsurf->rcl1WindowClip.bottom) { ! 661: break; ! 662: } ! 663: ! 664: // Map in the next bank ! 665: pdsurf->pfnBankControl(pdsurf, ! 666: pdsurf->rcl1WindowClip.bottom, ! 667: JustifyTop); ! 668: ! 669: } ! 670: ! 671: break; ! 672: ! 673: case DC_COMPLEX: ! 674: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, ! 675: ENUM_RECT_LIMIT); ! 676: bMore = TRUE; ! 677: ! 678: do ! 679: { ! 680: if (bMore) { ! 681: // Enumerate more clip rects ! 682: bMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(txen), ! 683: (PVOID) &txen); ! 684: } ! 685: ! 686: // Draw the portion of the glyph that intersects each ! 687: // clip rect in turn ! 688: for (ircl = 0; ircl < txen.c; ircl++) ! 689: { ! 690: // Clip the glyph to the next clip rect, and set ! 691: // our clipping flags ! 692: flOption |= flClipRect ( &rclTmp, &rclGlyph, ! 693: &txen.arcl[ircl] ); ! 694: ! 695: // If we have a valid rectangle to draw, draw it ! 696: if (!(BINVALIDRECT(rclTmp))) { ! 697: // Cycle through all banks that the clipped ! 698: // glpyh rect spans ! 699: ! 700: // If the proper bank for the top scan line of ! 701: // the clipped glyph isn't mapped in, map it in ! 702: if ((rclTmp.top < ! 703: pdsurf->rcl1WindowClip.top) || ! 704: (rclTmp.top >= ! 705: pdsurf->rcl1WindowClip.bottom)) { ! 706: ! 707: // Map in the bank containing the top ! 708: // clipped glyph line ! 709: pdsurf->pfnBankControl(pdsurf, ! 710: rclTmp.top, ! 711: JustifyTop); ! 712: } ! 713: ! 714: // Now draw the part of the rect that's in each ! 715: // bank ! 716: ! 717: for (;;) { ! 718: ! 719: flOptionTemp = flOption | ! 720: flClipRect(&rclBankTmp, &rclTmp, ! 721: &pdsurf->rcl1WindowClip); ! 722: ! 723: ! 724: (*pfnBlt)(pdsurf, &rclBankTmp, cGlyph, ! 725: &pgp[iGlyph], iSolidForeColor, ! 726: iSolidBkColor, ulMixMode, ! 727: flOptionTemp); ! 728: ! 729: // Done if this bank contains the last line ! 730: // of the fill ! 731: if (rclTmp.bottom <= ! 732: pdsurf->rcl1WindowClip.bottom) { ! 733: break; ! 734: } ! 735: ! 736: // Map in the next bank ! 737: pdsurf->pfnBankControl(pdsurf, ! 738: pdsurf->rcl1WindowClip.bottom, ! 739: JustifyTop); ! 740: ! 741: } ! 742: } ! 743: ! 744: flOption &= ~(VGB_VERT_CLIPPED_GLYPH | ! 745: VGB_HORIZ_CLIPPED_GLYPH); ! 746: } ! 747: } while (bMore); ! 748: break; ! 749: } ! 750: ! 751: // We might have blted the entire string. ! 752: ! 753: if (flOption & VGB_ENTIRE_STRING_BLT) ! 754: break; ! 755: } ! 756: ! 757: } while (bMoreGlyphs); ! 758: ! 759: // Reset VGA registers ! 760: ! 761: vResetVGARegs(); ! 762: ! 763: //-------------------------------------------------------------------------- ! 764: // Now handle the 'extra' rectangles. ! 765: //-------------------------------------------------------------------------- ! 766: ! 767: if (prclExtra != (PRECTL) NULL) ! 768: { ! 769: while (prclExtra->left != prclExtra->right) ! 770: { ! 771: switch ( iClip ) ! 772: { ! 773: case DC_TRIVIAL: ! 774: vTrgBlt(pdsurf, 1, prclExtra, mix, iSolidTextColor); ! 775: break; ! 776: ! 777: case DC_RECT: ! 778: ! 779: // Intersect opaque and clip rectangles ! 780: ! 781: flClipRect ( &rclTmp, prclExtra, &pco->rclBounds ); ! 782: ! 783: if (BINVALIDRECT(rclTmp)) ! 784: break; ! 785: ! 786: vTrgBlt(pdsurf, 1, &rclTmp, mix, iSolidTextColor); ! 787: break; ! 788: ! 789: case DC_COMPLEX: ! 790: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, ! 791: ENUM_RECT_LIMIT); ! 792: bMore = TRUE; ! 793: ! 794: do ! 795: { ! 796: if (bMore) { ! 797: bMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(txen), ! 798: (PVOID) &txen); ! 799: } ! 800: ! 801: for (ircl = 0; ircl < txen.c; ircl++) ! 802: { ! 803: flClipRect ( &rclTmp, prclExtra, &txen.arcl[ircl] ); ! 804: ! 805: if (!(BINVALIDRECT(rclTmp))) ! 806: { ! 807: vTrgBlt(pdsurf, 1, &rclTmp, ! 808: mix, iSolidTextColor); ! 809: }; ! 810: } ! 811: } while (bMore); ! 812: break; ! 813: }; ! 814: ! 815: prclExtra++; // Advance to next extra rectangle ! 816: } ! 817: } ! 818: ! 819: //-------------------------------------------------------------------------- ! 820: // Clean up the surface ! 821: //-------------------------------------------------------------------------- ! 822: ! 823: pptlOrg; ! 824: return(TRUE); ! 825: } ! 826: ! 827: ! 828: //-------------------------------------------------------------------------- ! 829: // Fills the specified rectangles on the specified surface with the ! 830: // specified color, honoring the requested clipping. No more than four ! 831: // rectangles should be passed in. Intended for drawing the areas of the ! 832: // opaquing rectangle that extended beyond the text box. The rectangles must ! 833: // be in left to right, top to bottom order. Assumes there is at least one ! 834: // rectangle in the list. ! 835: //-------------------------------------------------------------------------- ! 836: ! 837: VOID lclFillRect( ! 838: CLIPOBJ *pco, ! 839: ULONG culRcl, ! 840: PRECTL prcl, ! 841: PDEVSURF pdsurf, ! 842: INT iColor) ! 843: { ! 844: BOOL bMore; // Flag for clip enumeration ! 845: RECT_ENUM txen; // Clip enumeration object ! 846: ULONG i, j; ! 847: RECTL arclTmp[4]; ! 848: ULONG culRclTmp; ! 849: RECTL *prclTmp, *prclClipTmp; ! 850: INT iLastBottom; ! 851: RECTL *pClipRcl; ! 852: INT iClip; ! 853: ! 854: // ASSERT(culRcl <= 4, "Too many rects"); ! 855: ! 856: iClip = DC_TRIVIAL; ! 857: ! 858: if (pco != NULL) { ! 859: iClip = pco->iDComplexity; ! 860: } ! 861: ! 862: switch ( iClip ) { ! 863: ! 864: case DC_TRIVIAL: ! 865: ! 866: vTrgBlt(pdsurf, culRcl, prcl, R2_COPYPEN, iColor); ! 867: ! 868: break; ! 869: ! 870: case DC_RECT: ! 871: ! 872: prclTmp = &pco->rclBounds; ! 873: ! 874: // Generate a list of clipped rects ! 875: for (culRclTmp=0, i=0; i<culRcl; i++, prcl++) { ! 876: ! 877: // Intersect fill and clip rectangles ! 878: if (DrvIntersectRect(&arclTmp[culRclTmp], prcl, prclTmp)) { ! 879: ! 880: // Add to list if anything's left to draw ! 881: culRclTmp++; ! 882: } ! 883: } ! 884: ! 885: // Draw the clipped rects ! 886: if (culRclTmp != 0) { ! 887: vTrgBlt(pdsurf, culRclTmp, arclTmp, R2_COPYPEN, iColor); ! 888: } ! 889: ! 890: break; ! 891: ! 892: case DC_COMPLEX: ! 893: ! 894: // Bottom of last rectangle to fill ! 895: iLastBottom = prcl[culRcl-1].bottom; ! 896: ! 897: // Initialize the clip rectangle enumeration to rightdown so we can ! 898: // take advantage of the rectangle list being rightdown ! 899: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, ! 900: ENUM_RECT_LIMIT); ! 901: ! 902: // Scan through all the clip rectangles, looking for intersects ! 903: // of fill areas with region rectangles ! 904: do { ! 905: ! 906: // Get a batch of region rectangles ! 907: bMore = CLIPOBJ_bEnum(pco, (ULONG)sizeof(txen), (PVOID)&txen); ! 908: ! 909: // Clip the rect list to each region rect ! 910: for (j = txen.c, pClipRcl = txen.arcl; j-- > 0; pClipRcl++) { ! 911: ! 912: // Since the rectangles and the region enumeration are both ! 913: // rightdown, we can zip through the region until we reach ! 914: // the first fill rect, and are done when we've passed the ! 915: // last fill rect. ! 916: ! 917: if (pClipRcl->top >= iLastBottom) { ! 918: // Past last fill rectangle; nothing left to do ! 919: return; ! 920: } ! 921: ! 922: // Do intersection tests only if we've reached the top of ! 923: // the first rectangle to fill ! 924: if (pClipRcl->bottom > prcl->top) { ! 925: ! 926: // We've reached the top Y scan of the first rect, so ! 927: // it's worth bothering checking for intersection ! 928: ! 929: // Generate a list of the rects clipped to this region ! 930: // rect ! 931: prclTmp = prcl; ! 932: prclClipTmp = arclTmp; ! 933: for (i = culRcl, culRclTmp=0; i-- > 0; prclTmp++) { ! 934: ! 935: // Intersect fill and clip rectangles ! 936: if (DrvIntersectRect(prclClipTmp, prclTmp, ! 937: pClipRcl)) { ! 938: ! 939: // Add to list if anything's left to draw ! 940: culRclTmp++; ! 941: prclClipTmp++; ! 942: } ! 943: } ! 944: ! 945: // Draw the clipped rects ! 946: if (culRclTmp != 0) { ! 947: vTrgBlt(pdsurf, culRclTmp, arclTmp, R2_COPYPEN, ! 948: iColor); ! 949: } ! 950: } ! 951: } ! 952: } while (bMore); ! 953: ! 954: break; ! 955: } ! 956: ! 957: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.