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