![[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 / vga256|
Return to textout.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256 |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: TextOut.c
3: *
4: * Text
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: *
8: \**************************************************************************/
9:
10: #include "driver.h"
11:
12: BOOL vFastText(PDEV *, GLYPHPOS *, ULONG, PBYTE, ULONG, ULONG, RECTL *,
13: RECTL *, INT, INT, ULONG);
14: VOID lclFillRect(CLIPOBJ *, ULONG, PRECTL, PPDEV, INT);
15:
16: /****************************************************************************
17: * DrvTextOut
18: ***************************************************************************/
19:
20: BOOL DrvTextOut(
21: SURFOBJ* pso,
22: STROBJ* pstro,
23: FONTOBJ* pfo,
24: CLIPOBJ* pco,
25: RECTL* prclExtra,
26: RECTL* prclOpaque,
27: BRUSHOBJ* pboFore,
28: BRUSHOBJ* pboOpaque,
29: POINTL* pptlOrg,
30: MIX mix)
31: {
32: BOOL b;
33: PPDEV ppdev;
34: INT iClip; // clip object's complexity
35: ULONG iSolidForeColor; // Solid foreground color
36: ULONG iSolidBkColor; // Solid background color
37: RECTL arclTmp[4]; // Temp storage for portions of opaquing rect
38: ULONG culRcl; // Temp rectangle count
39:
40: ppdev = (PPDEV) pso->dhpdev;
41:
42:
43: //---------------------------------------------------------------------
44: // Get information about clip object.
45: //---------------------------------------------------------------------
46:
47: iClip = DC_TRIVIAL;
48:
49: if (pco != NULL) {
50: iClip = pco->iDComplexity;
51: }
52:
53: //---------------------------------------------------------------------
54: // Get text color.
55: //---------------------------------------------------------------------
56:
57: iSolidForeColor = pboFore->iSolidColor;
58:
59: //---------------------------------------------------------------------
60: // See if this is text we can handle faster with special-case code.
61: //---------------------------------------------------------------------
62:
63: if (((ppdev->fl & DRIVER_PLANAR_CAPABLE) ||
64: (prclOpaque == (PRECTL) NULL)) && // opaque only if planar for now
65: // LATER implement fast non-planar
66: // opaque
67: (iClip == DC_TRIVIAL) && // no clipping for now
68: ((pstro->rclBkGround.right & ~0x03) >
69: ((pstro->rclBkGround.left + 3) & ~0x03)) &&
70: // not if no full nibbles spanned
71: // for now @@@
72: (pstro->pgp != NULL) && // no glyph enumeration for now
73: (prclExtra == NULL) && // no extra rects for now
74: ((pstro->flAccel & (SO_HORIZONTAL | SO_VERTICAL | SO_REVERSED)) ==
75: SO_HORIZONTAL)) { // only left-to-right text for now
76:
77: ULONG ulBufferWidthInBytes;
78: ULONG ulBufferBytes;
79: BOOL bTextPerfectFit;
80: ULONG fDrawFlags;
81:
82: // It's the type of text we can special-case; see if the temp buffer is
83: // big enough for the text.
84:
85: ulBufferWidthInBytes = ((((pstro->rclBkGround.right + 7) & ~0x07) -
86: (pstro->rclBkGround.left & ~0x07)) >> 3);
87: ulBufferBytes = ulBufferWidthInBytes *
88: (pstro->rclBkGround.bottom - pstro->rclBkGround.top);
89:
90: if (ulBufferBytes <= TMP_BUFFER_SIZE) {
91:
92: // It's big enough; set up for the accelerator
93:
94: // Set fixed pitch, overlap, and top & bottom Y alignment flags
95: fDrawFlags = ((pstro->ulCharInc != 0) ? 0x01 : 0) |
96: (((pstro->flAccel & (SO_ZERO_BEARINGS |
97: SO_FLAG_DEFAULT_PLACEMENT)) !=
98: (SO_ZERO_BEARINGS | SO_FLAG_DEFAULT_PLACEMENT))
99: ? 0x02 : 0) |
100: (((pstro->flAccel & (SO_ZERO_BEARINGS |
101: SO_FLAG_DEFAULT_PLACEMENT |
102: SO_MAXEXT_EQUAL_BM_SIDE)) ==
103: (SO_ZERO_BEARINGS | SO_FLAG_DEFAULT_PLACEMENT |
104: SO_MAXEXT_EQUAL_BM_SIDE)) ? 0x04 : 0);
105:
106: // If there's an opaque rectangle, we'll do as much opaquing as
107: // possible as we do the text. If the opaque rectangle is larger
108: // than the text rectangle, then we'll do the fringe areas right
109: // now, and the text and associated background areas together,
110: // later.
111: if (prclOpaque != (PRECTL) NULL) {
112:
113: // This driver only handles solid brushes
114: iSolidBkColor = pboOpaque->iSolidColor;
115:
116: // See if we have fringe areas to do. If so, build a list of
117: // rectangles to fill, in rightdown order
118:
119: culRcl = 0;
120:
121: // Top fragment
122: if (pstro->rclBkGround.top > prclOpaque->top) {
123: arclTmp[culRcl].top = prclOpaque->top;
124: arclTmp[culRcl].left = prclOpaque->left;
125: arclTmp[culRcl].right = prclOpaque->right;
126: arclTmp[culRcl++].bottom = pstro->rclBkGround.top;
127: }
128:
129: // Left fragment
130: if (pstro->rclBkGround.left > prclOpaque->left) {
131: arclTmp[culRcl].top = pstro->rclBkGround.top;
132: arclTmp[culRcl].left = prclOpaque->left;
133: arclTmp[culRcl].right = pstro->rclBkGround.left;
134: arclTmp[culRcl++].bottom = pstro->rclBkGround.bottom;
135: }
136:
137: // Right fragment
138: if (pstro->rclBkGround.right < prclOpaque->right) {
139: arclTmp[culRcl].top = pstro->rclBkGround.top;
140: arclTmp[culRcl].right = prclOpaque->right;
141: arclTmp[culRcl].left = pstro->rclBkGround.right;
142: arclTmp[culRcl++].bottom = pstro->rclBkGround.bottom;
143: }
144:
145: // Bottom fragment
146: if (pstro->rclBkGround.bottom < prclOpaque->bottom) {
147: arclTmp[culRcl].bottom = prclOpaque->bottom;
148: arclTmp[culRcl].left = prclOpaque->left;
149: arclTmp[culRcl].right = prclOpaque->right;
150: arclTmp[culRcl++].top = pstro->rclBkGround.bottom;
151: }
152:
153: if (culRcl != 0) {
154: if (iClip == DC_TRIVIAL) {
155: vTrgBlt(ppdev, culRcl, arclTmp, R2_COPYPEN,
156: *((RBRUSH_COLOR*) &iSolidBkColor), NULL);
157: } else {
158: lclFillRect(pco, culRcl, arclTmp, ppdev,
159: iSolidBkColor);
160: }
161: }
162: }
163:
164: // We're done with separate opaquing; any further opaquing will
165: // happen as part of the text drawing
166:
167: // Clear the buffer if the text isn't going to set every bit
168: // BUGBUG do I have to pay attention to ulCharInc?
169: bTextPerfectFit = (pstro->flAccel & (SO_ZERO_BEARINGS |
170: SO_FLAG_DEFAULT_PLACEMENT | SO_MAXEXT_EQUAL_BM_SIDE |
171: SO_CHAR_INC_EQUAL_BM_BASE)) ==
172: (SO_ZERO_BEARINGS | SO_FLAG_DEFAULT_PLACEMENT |
173: SO_MAXEXT_EQUAL_BM_SIDE | SO_CHAR_INC_EQUAL_BM_BASE);
174:
175: if (!bTextPerfectFit) {
176: vClearMemDword(ppdev->pvTmp, (ulBufferBytes + 3) >> 2);
177: }
178:
179: // Draw the text into the temp buffer, and thence to the screen
180: vFastText(ppdev,
181: pstro->pgp,
182: pstro->cGlyphs,
183: ppdev->pvTmp,
184: ulBufferWidthInBytes,
185: pstro->ulCharInc,
186: &pstro->rclBkGround,
187: prclOpaque,
188: iSolidForeColor,
189: iSolidBkColor,
190: fDrawFlags);
191:
192: return(TRUE);
193:
194: }
195: }
196:
197: // Can't special-case; let the engine draw the text
198:
199: pso = ppdev->pSurfObj;
200:
201: // It may be that the opaquing rectangle is larger than the text rectangle,
202: // so we'll want to use that to tell the bank manager which banks to
203: // enumerate:
204:
205: pco = pcoBankStart(ppdev,
206: (prclOpaque != NULL) ? prclOpaque : &pstro->rclBkGround,
207: pso,
208: pco);
209:
210: do {
211: b = EngTextOut(pso,
212: pstro,
213: pfo,
214: pco,
215: prclExtra,
216: prclOpaque,
217: pboFore,
218: pboOpaque,
219: pptlOrg,
220: mix);
221:
222: } while (b && bBankEnum(ppdev, pso, pco));
223:
224: return(b);
225: }
226:
227: //--------------------------------------------------------------------------
228: // Fills the specified rectangles on the specified surface with the
229: // specified color, honoring the requested clipping. No more than four
230: // rectangles should be passed in. Intended for drawing the areas of the
231: // opaquing rectangle that extended beyond the text box. The rectangles must
232: // be in left to right, top to bottom order. Assumes there is at least one
233: // rectangle in the list.
234: //--------------------------------------------------------------------------
235:
236: VOID lclFillRect(
237: CLIPOBJ *pco,
238: ULONG culRcl,
239: PRECTL prcl,
240: PPDEV ppdev,
241: INT iColor)
242: {
243: BOOL bMore; // Flag for clip enumeration
244: TEXTENUM txen; // Clip enumeration object
245: ULONG i, j;
246: RECTL arclTmp[4];
247: ULONG culRclTmp;
248: RECTL *prclTmp, *prclClipTmp;
249: INT iLastBottom;
250: RECTL *pClipRcl;
251: INT iClip;
252:
253: iClip = DC_TRIVIAL;
254:
255: if (pco != NULL) {
256: iClip = pco->iDComplexity;
257: }
258:
259: switch ( iClip ) {
260:
261: case DC_TRIVIAL:
262:
263: vTrgBlt(ppdev, culRcl, prcl, R2_COPYPEN,
264: *((RBRUSH_COLOR*) &iColor), NULL);
265:
266: break;
267:
268: case DC_RECT:
269:
270: prclTmp = &pco->rclBounds;
271:
272: // Generate a list of clipped rects
273: for (culRclTmp=0, i=0; i<culRcl; i++, prcl++) {
274:
275: // Intersect fill and clip rectangles
276: if (bIntersectRect(&arclTmp[culRclTmp], prcl, prclTmp)) {
277:
278: // Add to list if anything's left to draw
279: culRclTmp++;
280: }
281: }
282:
283: // Draw the clipped rects
284: if (culRclTmp != 0) {
285: vTrgBlt(ppdev, culRclTmp, arclTmp, R2_COPYPEN,
286: *((RBRUSH_COLOR*) &iColor), NULL);
287: }
288:
289: break;
290:
291: case DC_COMPLEX:
292:
293: // Bottom of last rectangle to fill
294: iLastBottom = prcl[culRcl-1].bottom;
295:
296: // Initialize the clip rectangle enumeration to rightdown so we can
297: // take advantage of the rectangle list being rightdown
298: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_RIGHTDOWN,
299: TO_RECT_LIMIT);
300:
301: // Scan through all the clip rectangles, looking for intersects
302: // of fill areas with region rectangles
303: do {
304:
305: // Get a batch of region rectangles
306: bMore = CLIPOBJ_bEnum(pco, (ULONG)sizeof(txen), (PVOID)&txen);
307:
308: // Clip the rect list to each region rect
309: for (j = txen.c, pClipRcl = txen.arcl; j-- > 0; pClipRcl++) {
310:
311: // Since the rectangles and the region enumeration are both
312: // rightdown, we can zip through the region until we reach
313: // the first fill rect, and are done when we've passed the
314: // last fill rect.
315:
316: if (pClipRcl->top >= iLastBottom) {
317: // Past last fill rectangle; nothing left to do
318: return;
319: }
320:
321: // Do intersection tests only if we've reached the top of
322: // the first rectangle to fill
323: if (pClipRcl->bottom > prcl->top) {
324:
325: // We've reached the top Y scan of the first rect, so
326: // it's worth bothering checking for intersection
327:
328: // Generate a list of the rects clipped to this region
329: // rect
330: prclTmp = prcl;
331: prclClipTmp = arclTmp;
332: for (i = culRcl, culRclTmp=0; i-- > 0; prclTmp++) {
333:
334: // Intersect fill and clip rectangles
335: if (bIntersectRect(prclClipTmp, prclTmp,
336: pClipRcl)) {
337:
338: // Add to list if anything's left to draw
339: culRclTmp++;
340: prclClipTmp++;
341: }
342: }
343:
344: // Draw the clipped rects
345: if (culRclTmp != 0) {
346: vTrgBlt(ppdev, culRclTmp, arclTmp, R2_COPYPEN,
347: *((RBRUSH_COLOR*) &iColor), NULL);
348: }
349: }
350: }
351: } while (bMore);
352:
353: break;
354: }
355:
356: }
357:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.