![[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 / s3|
Return to textout.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3 |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: TextOut.c
3: *
4: * S3 Text accelerations
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: *
8: \**************************************************************************/
9:
10: #include "driver.h"
11: #include "memory.h"
12:
13: // Part of the fix to limit the amount of resources allocated for fonts
14:
15: #define MAX_GLYPHS_TO_ALLOC 256
16:
17: // number of bytes in the glyph bitmap scanline
18:
19: #define CJ_SCAN(cx) (((cx) + 7) >> 3)
20:
21: #define TRIVIAL_ACCEPT 0x00000001
22: #define MONO_SPACED_FONT 0x00000002
23: #define MONO_SIZE_VALID 0x00000004
24: #define MONO_FIRST_TIME 0x00000008
25:
26: PCACHEDFONT pCachedFontsRoot; // Cached Fonts list root.
27:
28: WORD iPlaneBits[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
29:
30: BOOL bOpaqueRect(
31: PPDEV ppdev,
32: RECTL *prclOpaque,
33: RECTL *prclBounds,
34: BRUSHOBJ *pboOpaque);
35:
36: BOOL bSetS3TextColorAndMix(
37: PPDEV ppdev,
38: MIX mix,
39: BRUSHOBJ *pboFore,
40: BRUSHOBJ *pboOpaque);
41:
42: VOID vBlowCache(PPDEV ppdev);
43:
44: VOID vInitGlyphAlloc(PPDEV ppdev);
45:
46: BOOL bAllocGlyphMemory(PPDEV ppdev,
47: PSIZEL psizlGlyph,
48: PXYZPOINTL pxyzGlyph);
49:
50: PCACHEDGLYPH pCacheFont(PPDEV ppdev,
51: STROBJ *pstro,
52: FONTOBJ *pfo,
53: PCACHEDFONT *ppCachedFont);
54:
55: BOOL bAllocateGlyph(PPDEV ppdev,
56: HGLYPH hg,
57: GLYPHBITS *pgb,
58: PCACHEDGLYPH pcg);
59:
60: BOOL bHandleNonCachedFonts(SURFOBJ *pso,
61: STROBJ *pstro,
62: FONTOBJ *pfo,
63: RECTL *prclClip,
64: RECTL *prclExtra,
65: RECTL *prclOpaque,
66: BRUSHOBJ *pboFore,
67: BRUSHOBJ *pboOpaque,
68: POINTL *pptlOrg,
69: MIX mix);
70:
71: BOOL bHandleCachedFonts(SURFOBJ *pso,
72: STROBJ *pstro,
73: RECTL *prclClip,
74: FONTOBJ *pfo,
75: RECTL *prclOpaque,
76: BRUSHOBJ *pboFore,
77: BRUSHOBJ *pboOpaque,
78: POINTL *pptlOrg,
79: MIX mix);
80:
81: #if DBG
82:
83: ULONG nGlyphs, nOverlaps;
84:
85: #define TFIFOWAIT(level) nGlyphs++; \
86: if (INPW(GP_STAT) & level) { \
87: nOverlaps++; \
88: while (INPW(GP_STAT) & level); \
89: }
90: #else
91:
92: #define TFIFOWAIT(level) FIFOWAIT(level)
93:
94: #endif
95:
96:
97: /****************************************************************************
98: * DrvDestroyFont
99: ***************************************************************************/
100: VOID DrvDestroyFont(FONTOBJ *pfo)
101: {
102: PCACHEDFONT pCachedFont, pcfLast;
103: PCACHEDGLYPH pcg, pcgNext;
104: INT nGlyphs, i;
105:
106: DISPDBG((1, "S3.DLL!DrvDestroyFont - Entry\n"));
107:
108: if (((pCachedFont = ((PCACHEDFONT) pfo->pvConsumer)) != NULL))
109: {
110: if (pfo->iUniq == pCachedFont->iUniq)
111: {
112: // We have found our font.
113:
114: DISPDBG((1, "S3.DLL: Destroying font: pfo->iUniq: %x\n",
115: pfo->iUniq));
116:
117: // First free any nodes in the collision list.
118:
119: nGlyphs = pCachedFont->cGlyphs+1;
120: for (i = 0; i < nGlyphs; i++)
121: {
122: // get a pointer to this glyph node.
123:
124: pcg = &(pCachedFont->pCachedGlyphs[i]);
125:
126: // get a pointer to this glyphs collision list
127:
128: pcg = pcg->pcgCollisionLink;
129: for (; pcg != NULL; pcg = pcgNext)
130: {
131: pcgNext = pcg->pcgCollisionLink;
132: LocalFree(pcg);
133: }
134: }
135:
136: // Now free the cached glyph array
137:
138: LocalFree(pCachedFont->pCachedGlyphs);
139:
140: // Now remove the font node from the list of fonts
141: // and free it.
142:
143: pcfLast = (PCACHEDFONT) &pCachedFontsRoot;
144: for (pCachedFont = pCachedFontsRoot;
145: pCachedFont != NULL;
146: pCachedFont = pCachedFont->pcfNext)
147: {
148: if (pCachedFont->iUniq == pfo->iUniq)
149: {
150: pcfLast->pcfNext = pCachedFont->pcfNext;
151: LocalFree(pCachedFont);
152: break;
153: }
154: pcfLast = pCachedFont;
155: }
156:
157: if (pCachedFont == NULL)
158: {
159: RIP("S3.DLL!DrvDestroyFont - pCachedFont not found\n");
160: }
161: }
162: else
163: {
164: RIP("S3.DLL!DrvDestroyFont - pfo->pvConsumer error\n");
165: }
166: }
167:
168: // In all cases we want to zero out the pvConsumer field.
169:
170: pfo->pvConsumer = NULL;
171:
172: }
173:
174:
175: /****************************************************************************
176: * DrvTextOut
177: ***************************************************************************/
178: BOOL DrvTextOut(
179: SURFOBJ *pso,
180: STROBJ *pstro,
181: FONTOBJ *pfo,
182: CLIPOBJ *pco,
183: RECTL *prclExtra,
184: RECTL *prclOpaque,
185: BRUSHOBJ *pboFore,
186: BRUSHOBJ *pboOpaque,
187: POINTL *pptlOrg,
188: MIX mix)
189: {
190: BOOL b, bMore;
191: UINT i;
192: ENUMRECTS8 EnumRects8;
193: PPDEV ppdev;
194:
195: DISPDBG((3, "S3.DLL: DrvTextOut - Entry\n"));
196:
197: // Pickup the ppdev.
198:
199: ppdev = (PPDEV) pso->dhpdev;
200:
201: // Protect the code path from a potentially NULL clip object
202: // This also gives a maximum rclBounds which we use later:
203:
204: if (pco == NULL || pco->iDComplexity == DC_TRIVIAL)
205: {
206: pco = ppdev->pcoDefault;
207: }
208:
209: // Determine if we can cache this string.
210: // This is done by checking the size of glyph.
211:
212: b = TRUE;
213:
214: if ((pfo->cxMax > GLYPH_CACHE_CX) ||
215: ((pstro->rclBkGround.bottom - pstro->rclBkGround.top) > GLYPH_CACHE_CY))
216: {
217: b = FALSE;
218: }
219:
220: // If the glyphs in this string will fit in the font cache
221: // then try to render it as a cached font.
222:
223: if (b == TRUE)
224: {
225: // Take care of the clipping.
226:
227: if (pco->iDComplexity != DC_COMPLEX)
228: {
229: b = bHandleCachedFonts(pso, pstro, &(pco->rclBounds), pfo,
230: prclOpaque, pboFore,
231: pboOpaque, pptlOrg, mix);
232:
233: }
234: else
235: {
236: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0);
237:
238: do
239: {
240: bMore = CLIPOBJ_bEnum(pco, sizeof (ENUMRECTS8),
241: (PULONG)&EnumRects8);
242:
243: for (i = 0; i < EnumRects8.c; i++)
244: {
245: b = bHandleCachedFonts(pso, pstro, &(EnumRects8.arcl[i]),
246: pfo, prclOpaque, pboFore, pboOpaque, pptlOrg, mix);
247: if (!b)
248: {
249: // If we failed, stop immediately, so we can fall back
250: // to bHandleNonCachedFonts. Otherwise, if we just blew
251: // the cache, the next call in this loop will succeed,
252: // and we'll never redo this rectangle properly. Note
253: // that this is very inefficient, forcing the whole
254: // rest of the call to go through
255: // bHandleNonCachedFonts
256: break;
257: }
258: }
259:
260: } while (bMore & b);
261: }
262: }
263:
264: // If something went wrong with rendering the string as a cached
265: // font then render it as a large font.
266:
267: if (b == FALSE)
268: {
269: if (pco->iDComplexity != DC_COMPLEX)
270: {
271: b = bHandleNonCachedFonts(pso, pstro, pfo, &(pco->rclBounds),
272: prclExtra, prclOpaque, pboFore, pboOpaque, pptlOrg, mix);
273:
274: }
275: else
276: {
277: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0);
278:
279: do
280: {
281: bMore = CLIPOBJ_bEnum(pco, sizeof (ENUMRECTS8),
282: (PULONG)&EnumRects8);
283:
284: for (i = 0; i < EnumRects8.c; i++)
285: {
286: b = bHandleNonCachedFonts(pso, pstro, pfo,
287: &(EnumRects8.arcl[i]), prclExtra, prclOpaque,
288: pboFore, pboOpaque, pptlOrg, mix);
289: }
290:
291: } while (bMore);
292: }
293:
294: vResetS3Clipping(ppdev);
295: }
296:
297: return (b);
298: }
299:
300:
301: /****************************************************************************
302: * bHandleCachedFonts
303: ***************************************************************************/
304: BOOL bHandleCachedFonts(
305: SURFOBJ *pso,
306: STROBJ *pstro,
307: RECTL *prclClip,
308: FONTOBJ *pfo,
309: RECTL *prclOpaque,
310: BRUSHOBJ *pboFore,
311: BRUSHOBJ *pboOpaque,
312: POINTL *pptlOrg,
313: MIX mix)
314: {
315: BOOL b, bMoreGlyphs, bFound;
316: ULONG iGlyph, cGlyphs;
317: POINTL ptl;
318: GLYPHPOS *pgp;
319: INT ihGlyph, cxGlyph, cyGlyph;
320: PCACHEDGLYPH pCachedGlyphs, pcg, pcgNew;
321: WORD Cmd;
322: XYZPOINTL xyzGlyph;
323: PCACHEDFONT pCachedFont;
324: PPDEV ppdev;
325: INT i, culRcl;
326: ULONG flAccel;
327: RECTL arclTmp[4];
328: ULONG ulCharInc;
329: ULONG yMonoStart, xMonoPosition;
330: POINTL ptlSrc;
331: RECTL rclGlyph;
332: HGLYPH hg;
333: GLYPHBITS *pgb;
334: ULONG fl = 0;
335: BYTE jBackgroundRop;
336:
337: DISPDBG((4, "S3.DLL:bHandleCachedFonts - Entry\n"));
338:
339: ppdev = (PPDEV) pso->dhpdev;
340:
341: //
342: // If we have seen this font before then pvConsumer will be non-NULL.
343: //
344:
345: if (((pCachedFont = ((PCACHEDFONT) pfo->pvConsumer)) != NULL))
346: {
347: pCachedGlyphs = pCachedFont->pCachedGlyphs;
348:
349: if (pfo->iUniq != pCachedFont->iUniq)
350: {
351: DISPDBG((1, "S3.DLL: pfo->iUniq: %x, pCachedFont->iUniq: %x\n",
352: pfo->iUniq, pCachedFont->iUniq));
353: return (FALSE);
354: }
355: }
356:
357: else
358: {
359: DISPDBG((2, "S3.DLL!bHandleCachedFonts - Caching Font: %d\n", pfo->iUniq));
360:
361: pCachedGlyphs = pCacheFont(ppdev, pstro, pfo, &pCachedFont);
362:
363: if (pCachedGlyphs == NULL)
364: {
365: DISPDBG((1, "S3.DLL!bHandleCachedFonts - pCacheFont failed once\n"));
366:
367: vBlowCache(ppdev);
368:
369: pCachedGlyphs = pCacheFont(ppdev, pstro, pfo, &pCachedFont);
370: if (pCachedGlyphs == NULL)
371: {
372: DISPDBG((1, "S3.DLL!bHandleCachedFonts - pCacheFont failed twice\n"));
373: return(FALSE);
374: }
375: }
376:
377: (PCACHEDFONT)(pfo->pvConsumer) = pCachedFont;
378: }
379:
380: // If this string has a Zero Bearing and the string object's
381: // opaque rectangle is the same size as the opaque rectangle then
382: // and opaque mode is requested, then lay down the glyphs in
383: // opaque mode.
384:
385: if (((flAccel = pstro->flAccel) & SO_ZERO_BEARINGS) &&
386: ((flAccel & (SO_HORIZONTAL | SO_VERTICAL | SO_REVERSED)) == SO_HORIZONTAL) &&
387: (flAccel & SO_CHAR_INC_EQUAL_BM_BASE) &&
388: (prclOpaque != NULL))
389: {
390: // If the Opaque rect and the string rect match then
391: // were done. If not then we have to fill in the strips
392: // (top, bottom, left, and right) around the text.
393:
394: culRcl = 0;
395:
396: // Top fragment
397:
398: if (pstro->rclBkGround.top > prclOpaque->top)
399: {
400: arclTmp[culRcl].top = prclOpaque->top;
401: arclTmp[culRcl].left = prclOpaque->left;
402: arclTmp[culRcl].right = prclOpaque->right;
403: arclTmp[culRcl++].bottom = pstro->rclBkGround.top;
404: }
405:
406: // Left fragment
407:
408: if (pstro->rclBkGround.left > prclOpaque->left)
409: {
410: arclTmp[culRcl].top = pstro->rclBkGround.top;
411: arclTmp[culRcl].left = prclOpaque->left;
412: arclTmp[culRcl].right = pstro->rclBkGround.left;
413: arclTmp[culRcl++].bottom = pstro->rclBkGround.bottom;
414: }
415:
416: // Right fragment
417:
418: if (pstro->rclBkGround.right < prclOpaque->right)
419: {
420: arclTmp[culRcl].top = pstro->rclBkGround.top;
421: arclTmp[culRcl].right = prclOpaque->right;
422: arclTmp[culRcl].left = pstro->rclBkGround.right;
423: arclTmp[culRcl++].bottom = pstro->rclBkGround.bottom;
424: }
425:
426: // Bottom fragment
427:
428: if (pstro->rclBkGround.bottom < prclOpaque->bottom)
429: {
430: arclTmp[culRcl].bottom = prclOpaque->bottom;
431: arclTmp[culRcl].left = prclOpaque->left;
432: arclTmp[culRcl].right = prclOpaque->right;
433: arclTmp[culRcl++].top = pstro->rclBkGround.bottom;
434: }
435:
436: // Fill any fringe rectangles we found
437:
438: for (i = 0; i < culRcl; i++)
439: {
440: bOpaqueRect(ppdev, &(arclTmp[i]), prclClip, pboOpaque);
441: }
442:
443: // Set the mix mode for opaque text.
444:
445: mix = (mix & 0x0F) | (R2_COPYPEN << 8);
446: b = bSetS3TextColorAndMix(ppdev, mix, pboFore, pboOpaque);
447: if (b == FALSE)
448: return (b);
449:
450: }
451: else
452: {
453: // Take care of any opaque rectangles.
454:
455: if (prclOpaque != NULL)
456: {
457: bOpaqueRect(ppdev, prclOpaque, prclClip, pboOpaque);
458: }
459:
460: jBackgroundRop = R2_NOP;
461:
462: // Take care of the glyph attributes, color and mix.
463:
464: mix = (mix & 0x0F) | (jBackgroundRop << 8);
465: b = bSetS3TextColorAndMix(ppdev, mix, pboFore, pboOpaque);
466: if (b == FALSE)
467: return (b);
468: }
469:
470: // Test for a trivial accept of the string rect.
471:
472: if (bTrivialAcceptTest(&(pstro->rclBkGround), prclClip))
473: fl |= TRIVIAL_ACCEPT;
474:
475: // Test and setup for a mono-spaced font.
476:
477: if ((ulCharInc = pstro->ulCharInc) != 0)
478: fl |= MONO_SPACED_FONT;
479:
480: // Set the S3 command.
481:
482: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE |
483: MULTIPLE_PIXELS| DRAWING_DIR_TBLRXM;
484:
485: // This does not change in the inner loop so it is now out of it.
486:
487: FIFOWAIT(FIFO_1_EMPTY);
488: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | DISPLAY_MEMORY));
489:
490: // Get the Glyph Handles.
491:
492: if ((pstro->pgp) == NULL)
493: STROBJ_vEnumStart(pstro);
494:
495: do
496: {
497: if (pstro->pgp == NULL)
498: {
499: bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp);
500:
501: }
502: else
503: {
504: pgp = pstro->pgp;
505: cGlyphs = pstro->cGlyphs;
506: bMoreGlyphs = FALSE;
507: }
508:
509: // For mono space fonts this is non-zero.
510:
511: if (fl & MONO_SPACED_FONT)
512: {
513: xMonoPosition = pgp[0].ptl.x;
514: yMonoStart = pgp[0].ptl.y;
515: }
516:
517: for (iGlyph = 0; iGlyph < cGlyphs; iGlyph++)
518: {
519: // Get the Glyph Handle.
520: // If there was a hash table hit for the glygph
521: // then were "golden", if not then we have to search
522: // the collision list.
523:
524: ihGlyph = pgp[iGlyph].hg & pCachedFont->cGlyphs;
525:
526: pcg = &(pCachedGlyphs[ihGlyph]);
527:
528: if ((hg = pgp[iGlyph].hg) != pcg->hg)
529: {
530: if (!(pcg->fl & VALID_GLYPH))
531: {
532: // Allocate a place in the cache.
533:
534: pgb = pgp[iGlyph].pgdf->pgb;
535: b = bAllocateGlyph(ppdev, hg, pgb, pcg);
536: if (b == FALSE)
537: {
538: vBlowCache(ppdev);
539: return (FALSE);
540: }
541:
542: b = bSetS3TextColorAndMix(ppdev, mix, pboFore, pboOpaque);
543: if (b == FALSE)
544: return (FALSE);
545:
546: FIFOWAIT(FIFO_1_EMPTY);
547: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | DISPLAY_MEMORY));
548:
549: }
550: else
551: {
552: // Search the collision list.
553:
554: DISPDBG((1, "S3.DLL!bHandleCachedFonts - searching collision list\n"));
555:
556: bFound = FALSE;
557: while (pcg->pcgCollisionLink != END_COLLISIONS)
558: {
559: pcg = pcg->pcgCollisionLink;
560:
561: if (pcg->hg == pgp[iGlyph].hg)
562: {
563: bFound = TRUE;
564: break;
565: }
566: }
567:
568: if (!bFound)
569: {
570: // Allocate a new font glyph node.
571:
572: pcgNew = (PCACHEDGLYPH) LocalAlloc(LPTR, sizeof(CACHEDGLYPH));
573: if (pcgNew == NULL)
574: {
575: DISPDBG((1, "S3.DLL!bHandleCachedFont - Local Alloc (pcgNew) failed\n"));
576: return (FALSE);
577: }
578:
579: // Connect the end of the collision list to the new
580: // glyph node.
581:
582: pcg->pcgCollisionLink = pcgNew;
583:
584: // Set up the pointer to the node where going to init.
585:
586: pcg = pcgNew;
587:
588: pgb = pgp[iGlyph].pgdf->pgb;
589: b = bAllocateGlyph(ppdev, hg, pgb, pcg);
590: if (b == FALSE)
591: {
592: vBlowCache(ppdev);
593: return (FALSE);
594: }
595:
596: b = bSetS3TextColorAndMix(ppdev, mix, pboFore, pboOpaque);
597: if (b == FALSE)
598: return (FALSE);
599:
600: FIFOWAIT(FIFO_1_EMPTY);
601: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | DISPLAY_MEMORY));
602:
603: }
604: }
605: }
606:
607: // Adjust the placement of the glyph.
608: // And if this is a mono-spaced font set the blt height & width.
609:
610: if (fl & MONO_SPACED_FONT)
611: {
612: ptl.x = xMonoPosition + pcg->ptlOrigin.x;
613: ptl.y = yMonoStart + pcg->ptlOrigin.y;
614: xMonoPosition += ulCharInc;
615:
616: if ((!(fl & MONO_SIZE_VALID) && (fl & TRIVIAL_ACCEPT)) ||
617: (!(fl & MONO_FIRST_TIME)))
618: {
619: fl |= MONO_SIZE_VALID;
620:
621: TFIFOWAIT(FIFO_2_EMPTY);
622: OUTPW(RECT_WIDTH, pcg->sizlBitmap.cx - 1);
623: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | (pcg->sizlBitmap.cy - 1)));
624: }
625:
626: }
627: else
628: {
629: ptl.x = pgp[iGlyph].ptl.x + pcg->ptlOrigin.x;
630: ptl.y = pgp[iGlyph].ptl.y + pcg->ptlOrigin.y;
631: }
632:
633: if (fl & TRIVIAL_ACCEPT)
634: {
635: // Blit the glyph
636:
637: if (!(fl & MONO_SPACED_FONT))
638: {
639: TFIFOWAIT(FIFO_2_EMPTY);
640: OUTPW(RECT_WIDTH, pcg->sizlBitmap.cx - 1);
641: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | (pcg->sizlBitmap.cy - 1)));
642: }
643:
644: TFIFOWAIT(FIFO_6_EMPTY);
645: TEST_AND_SET_RD_MASK(LOWORD(pcg->xyzGlyph.z));
646:
647: OUTPW(CUR_X, pcg->xyzGlyph.x);
648: OUTPW(CUR_Y, pcg->xyzGlyph.y);
649: OUTPW(DEST_X, ptl.x);
650: OUTPW(DEST_Y, ptl.y);
651: OUTPW(CMD, Cmd);
652:
653: }
654: else
655: {
656: xyzGlyph = pcg->xyzGlyph;
657:
658: // Clip each character,
659:
660: rclGlyph.left = ptl.x;
661: rclGlyph.top = ptl.y;
662: rclGlyph.right = ptl.x + pcg->sizlBitmap.cx;
663: rclGlyph.bottom = ptl.y + pcg->sizlBitmap.cy;
664:
665: if (bIntersectTest(&rclGlyph, prclClip))
666: {
667: rclGlyph.left = max (rclGlyph.left, prclClip->left);
668: rclGlyph.top = max (rclGlyph.top, prclClip->top);
669: rclGlyph.right = min (rclGlyph.right, prclClip->right);
670: rclGlyph.bottom = min (rclGlyph.bottom, prclClip->bottom);
671:
672: cxGlyph = (rclGlyph.right - rclGlyph.left) - 1;
673: cyGlyph = (rclGlyph.bottom - rclGlyph.top) - 1;
674:
675: if (cxGlyph < 0 || cyGlyph < 0)
676: continue;
677:
678: ptlSrc.x = xyzGlyph.x + (rclGlyph.left - ptl.x);
679: ptlSrc.y = xyzGlyph.y + (rclGlyph.top - ptl.y);
680:
681: // Blit the glyph
682:
683: TFIFOWAIT(FIFO_8_EMPTY);
684: TEST_AND_SET_RD_MASK(LOWORD(pcg->xyzGlyph.z));
685:
686: OUTPW(RECT_WIDTH, cxGlyph);
687: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cyGlyph));
688: OUTPW(CUR_X, ptlSrc.x);
689: OUTPW(CUR_Y, ptlSrc.y);
690: OUTPW(DEST_X, rclGlyph.left);
691: OUTPW(DEST_Y, rclGlyph.top);
692: OUTPW(CMD, Cmd);
693:
694: }
695: else
696: {
697: continue;
698: }
699: }
700: }
701:
702: } while(bMoreGlyphs);
703:
704: return (TRUE);
705:
706: }
707:
708:
709: /****************************************************************************
710: * bHandleNonCachedFonts
711: ***************************************************************************/
712: BOOL bHandleNonCachedFonts(
713: SURFOBJ *pso,
714: STROBJ *pstro,
715: FONTOBJ *pfo,
716: RECTL *prclClip,
717: RECTL *prclExtra,
718: RECTL *prclOpaque,
719: BRUSHOBJ *pboFore,
720: BRUSHOBJ *pboOpaque,
721: POINTL *pptlOrg,
722: MIX mix)
723: {
724: BOOL b,
725: bMoreGlyphs;
726: ULONG iGlyph,
727: cGlyphs;
728: GLYPHBITS *pgb;
729: POINTL ptl;
730: GLYPHPOS *pgp;
731: LONG cyGlyph,
732: cjGlyph,
733: GlyphBmPitchInBytes;
734: WORD S3Cmd;
735: INT i, culRcl;
736: ULONG flAccel;
737: RECTL arclTmp[4];
738:
739: ULONG ulCharInc;
740: ULONG yMonoStart, xMonoPosition;
741: PPDEV ppdev;
742: BYTE jBackgroundRop;
743: RECTL rclClip;
744:
745: ULONG fl = 0;
746:
747: DISPDBG((4, "S3.DLL!bHandleNonCachedFonts\n"));
748:
749: ppdev = (PPDEV) pso->dhpdev;
750:
751: // We need to reset the clipping so any opaque rectangles are
752: // rendered correctly.
753:
754: vResetS3Clipping(ppdev);
755:
756: // If this string has a Zero Bearing and the string object's
757: // opaque rectangle is the same size as the opaque rectangle then
758: // and opaque mode is requested, then lay down the glyphs in
759: // opaque mode.
760:
761: if (((flAccel = pstro->flAccel) & SO_ZERO_BEARINGS) &&
762: ((flAccel & (SO_HORIZONTAL | SO_VERTICAL | SO_REVERSED)) == SO_HORIZONTAL) &&
763: (flAccel & SO_CHAR_INC_EQUAL_BM_BASE) &&
764: (prclOpaque != NULL))
765: {
766: // If the Opaque rect and the string rect match then
767: // were done. If not then we have to fill in the strips
768: // (top, bottom, left, and right) around the text.
769:
770: culRcl = 0;
771:
772: // Top fragment
773:
774: if (pstro->rclBkGround.top > prclOpaque->top)
775: {
776: arclTmp[culRcl].top = prclOpaque->top;
777: arclTmp[culRcl].left = prclOpaque->left;
778: arclTmp[culRcl].right = prclOpaque->right;
779: arclTmp[culRcl++].bottom = pstro->rclBkGround.top;
780: }
781:
782: // Left fragment
783:
784: if (pstro->rclBkGround.left > prclOpaque->left)
785: {
786: arclTmp[culRcl].top = pstro->rclBkGround.top;
787: arclTmp[culRcl].left = prclOpaque->left;
788: arclTmp[culRcl].right = pstro->rclBkGround.left;
789: arclTmp[culRcl++].bottom = pstro->rclBkGround.bottom;
790: }
791:
792: // Right fragment
793:
794: if (pstro->rclBkGround.right < prclOpaque->right)
795: {
796: arclTmp[culRcl].top = pstro->rclBkGround.top;
797: arclTmp[culRcl].right = prclOpaque->right;
798: arclTmp[culRcl].left = pstro->rclBkGround.right;
799: arclTmp[culRcl++].bottom = pstro->rclBkGround.bottom;
800: }
801:
802: // Bottom fragment
803:
804: if (pstro->rclBkGround.bottom < prclOpaque->bottom)
805: {
806: arclTmp[culRcl].bottom = prclOpaque->bottom;
807: arclTmp[culRcl].left = prclOpaque->left;
808: arclTmp[culRcl].right = prclOpaque->right;
809: arclTmp[culRcl++].top = pstro->rclBkGround.bottom;
810: }
811:
812: // Fill any fringe rectangles we found
813:
814: for (i = 0; i < culRcl; i++)
815: {
816: bOpaqueRect(ppdev, &(arclTmp[i]), prclClip, pboOpaque);
817: }
818:
819: // Set the mix mode for opaque text.
820:
821: mix = (mix & 0x0F) | (R2_COPYPEN << 8);
822: b = bSetS3TextColorAndMix(ppdev, mix, pboFore, pboOpaque);
823: if (b == FALSE)
824: return (b);
825: }
826: else
827: {
828: // Take care of any opaque rectangles.
829:
830: if (prclOpaque != NULL)
831: {
832: bOpaqueRect(ppdev, prclOpaque, prclClip, pboOpaque);
833: }
834:
835: jBackgroundRop = R2_NOP;
836:
837: // Take care of the glyph attributes, color and mix.
838:
839: mix = (mix & 0x0F) | (jBackgroundRop << 8);
840: b = bSetS3TextColorAndMix(ppdev, mix, pboFore, pboOpaque);
841: if (b == FALSE)
842: return (b);
843: }
844:
845: rclClip = *prclClip;
846: rclClip.bottom;
847: rclClip.right;
848: vSetS3ClipRect(ppdev, &rclClip);
849:
850: // Test and setup for a mono-spaced font.
851:
852: if ((ulCharInc = pstro->ulCharInc) != 0)
853: fl |= MONO_SPACED_FONT;
854:
855: // Setup the Command Word for the S3.
856:
857: S3Cmd = RECTANGLE_FILL | BUS_SIZE_8 |
858: WAIT | DRAWING_DIR_TBLRXM | DRAW |
859: LAST_PIXEL_ON | MULTIPLE_PIXELS | WRITE;
860:
861: FIFOWAIT(FIFO_2_EMPTY)
862:
863: // Enable the write mask for all planes.
864: // and set the S3 for CPU Data.
865:
866: TEST_AND_SET_WRT_MASK(0xFF);
867: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | CPU_DATA));
868:
869: // Get the Glyph Handles.
870:
871: if ((pstro->pgp) == NULL)
872: STROBJ_vEnumStart(pstro);
873:
874: do
875: {
876: if (pstro->pgp == NULL)
877: {
878: bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp);
879: }
880: else
881: {
882: pgp = pstro->pgp;
883: cGlyphs = pstro->cGlyphs;
884: bMoreGlyphs = FALSE;
885: }
886:
887: // For mono space fonts this is non-zero.
888:
889: if (fl & MONO_SPACED_FONT)
890: {
891: xMonoPosition = pgp[0].ptl.x;
892: yMonoStart = pgp[0].ptl.y;
893: }
894:
895: for (iGlyph = 0; iGlyph < cGlyphs; iGlyph++)
896: {
897: // Get a pointer to the GlyphBits.
898:
899: pgb = pgp[iGlyph].pgdf->pgb;
900:
901: // Adjust the placement of the glyph.
902: // If this is a mono-spaced font set the blt height & width only
903: // once for the string.
904:
905: if (fl & MONO_SPACED_FONT)
906: {
907: ptl.x = xMonoPosition + pgb->ptlOrigin.x;
908: ptl.y = yMonoStart + pgb->ptlOrigin.y;
909: xMonoPosition += ulCharInc;
910:
911: if (!(fl & MONO_SIZE_VALID))
912: {
913: fl |= MONO_SIZE_VALID;
914:
915: // Calculate the number of bytes in this glyph.
916:
917: cyGlyph = pgb->sizlBitmap.cy;
918:
919: GlyphBmPitchInBytes = CJ_SCAN(pgb->sizlBitmap.cx);
920: cjGlyph = GlyphBmPitchInBytes * cyGlyph;
921:
922: TFIFOWAIT(FIFO_2_EMPTY);
923: OUTPW(RECT_WIDTH, pgb->sizlBitmap.cx - 1);
924: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cyGlyph - 1));
925: }
926:
927: FIFOWAIT(FIFO_3_EMPTY)
928: }
929: else
930: {
931: ptl.x = pgp[iGlyph].ptl.x + pgb->ptlOrigin.x;
932: ptl.y = pgp[iGlyph].ptl.y + pgb->ptlOrigin.y;
933:
934: // Calculate the number of bytes in this glyph.
935:
936: cyGlyph = pgb->sizlBitmap.cy;
937:
938: GlyphBmPitchInBytes = CJ_SCAN(pgb->sizlBitmap.cx);
939: cjGlyph = GlyphBmPitchInBytes * cyGlyph;
940:
941: FIFOWAIT(FIFO_5_EMPTY)
942:
943: // Set up for the image transfer.
944:
945: OUTPW(RECT_WIDTH, pgb->sizlBitmap.cx - 1);
946: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cyGlyph - 1));
947: }
948:
949: // If a character is way off to the left then continue
950:
951: if ((ptl.x < 0) && ((ptl.x + pgb->sizlBitmap.cx) < 0))
952: continue;
953:
954: // Yes, believe it or not we have to check for chipping on the right also.
955:
956: if ((ptl.x > (LONG) ppdev->cxScreen) && ((ptl.x + pgb->sizlBitmap.cx) > (LONG) ppdev->cxScreen))
957: continue;
958:
959: // Set up for the image transfer.
960:
961: OUTPW(CUR_X, LOWORD(ptl.x));
962: OUTPW(CUR_Y, LOWORD(ptl.y));
963:
964: GPWAIT();
965:
966: OUTPW(CMD, S3Cmd);
967:
968: CHECK_DATA_READY;
969:
970: vDataPortOutB(ppdev, pgb->aj, cjGlyph);
971:
972: CHECK_DATA_COMPLETE;
973:
974: }
975:
976: } while(bMoreGlyphs);
977:
978: return (TRUE);
979:
980: }
981:
982:
983: /*****************************************************************************
984: * S3 Solid Opaque Rect.
985: *
986: * Returns TRUE if the Opaque Rect was handled.
987: ****************************************************************************/
988: BOOL bOpaqueRect(
989: PPDEV ppdev,
990: RECTL *prclOpaque,
991: RECTL *prclBounds,
992: BRUSHOBJ *pboOpaque)
993: {
994: INT width, height;
995: WORD S3Cmd;
996: ULONG iSolidColor;
997: RECTL rclClipped;
998: BOOL bClipRequired;
999:
1000: DISPDBG((4, "S3.DLL!bOpaqueRect - Entry\n"));
1001:
1002: rclClipped = *prclOpaque;
1003:
1004: // First handle the trivial rejection.
1005:
1006: bClipRequired = bIntersectTest(&rclClipped, prclBounds);
1007:
1008: // define the clipped target rectangle.
1009:
1010: if (bClipRequired)
1011: {
1012: rclClipped.left = max (rclClipped.left, prclBounds->left);
1013: rclClipped.top = max (rclClipped.top, prclBounds->top);
1014: rclClipped.right = min (rclClipped.right, prclBounds->right);
1015: rclClipped.bottom = min (rclClipped.bottom, prclBounds->bottom);
1016: }
1017: else
1018: return (TRUE);
1019:
1020: // Set the color
1021:
1022: iSolidColor = pboOpaque->iSolidColor;
1023: if (iSolidColor == -1)
1024: return(FALSE);
1025:
1026: width = (rclClipped.right - rclClipped.left) - 1;
1027: height = (rclClipped.bottom - rclClipped.top) - 1;
1028:
1029: if (width >= 0 && height >= 0)
1030: {
1031:
1032: FIFOWAIT(FIFO_8_EMPTY)
1033:
1034: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | OVERPAINT);
1035: TEST_AND_SET_FRGD_COLOR(LOWORD(iSolidColor));
1036: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES));
1037: OUTPW(CUR_X, LOWORD(rclClipped.left));
1038: OUTPW(CUR_Y, LOWORD(rclClipped.top));
1039: OUTPW(RECT_WIDTH, width);
1040: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | height));
1041:
1042: S3Cmd = RECTANGLE_FILL | DRAWING_DIR_TBLRXM | DRAW |
1043: DIR_TYPE_XY | LAST_PIXEL_ON |
1044: MULTIPLE_PIXELS | WRITE;
1045:
1046: OUTPW(CMD, S3Cmd);
1047: }
1048:
1049: return (TRUE);
1050: }
1051:
1052:
1053:
1054: /******************************************************************************
1055: * bSetS3TextColorAndMix - Setup the S3's Text Colors and mix modes
1056: *
1057: * Note: We will always set the mode to transparent. We will assume the
1058: * opaque rectangle will take care of any opaqueing we may need.
1059: *****************************************************************************/
1060: BOOL bSetS3TextColorAndMix(
1061: PPDEV ppdev,
1062: MIX mix,
1063: BRUSHOBJ *pboFore,
1064: BRUSHOBJ *pboOpaque)
1065: {
1066: ULONG ulForeSolidColor, ulBackSolidColor;
1067: BYTE jS3ForeMix, jS3BackMix;
1068:
1069: // Pickup all the glyph attributes.
1070:
1071: jS3ForeMix = Rop2ToS3Rop[(mix & 0xF) - R2_BLACK];
1072: ulForeSolidColor = pboFore->iSolidColor;
1073:
1074: jS3BackMix = Rop2ToS3Rop[((mix >> 8) & 0xF) - R2_BLACK];
1075: ulBackSolidColor = pboOpaque->iSolidColor;
1076:
1077: // For now let the engine handle the non-solid brush cases. !!!
1078: // We should use S3 when we get some more time !!!
1079:
1080: if (ulForeSolidColor == -1 || ulBackSolidColor == -1)
1081: return(FALSE);
1082:
1083: FIFOWAIT(FIFO_4_EMPTY)
1084:
1085: // Set the S3 Attributes.
1086:
1087: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | jS3ForeMix);
1088: TEST_AND_SET_FRGD_COLOR(LOWORD(ulForeSolidColor));
1089:
1090: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | jS3BackMix);
1091: TEST_AND_SET_BKGD_COLOR(LOWORD(ulBackSolidColor));
1092:
1093: return (TRUE);
1094:
1095: }
1096:
1097: /*****************************************************************************
1098: * pCacheFont - Make sure the glyphs we need in this font are cached.
1099: * Return a pointer to the array of glyph caches.
1100: *
1101: * if there is an error, return NULL.
1102: ****************************************************************************/
1103: PCACHEDGLYPH pCacheFont(
1104: PPDEV ppdev,
1105: STROBJ *pstro,
1106: FONTOBJ *pfo,
1107: PCACHEDFONT *ppCachedFont)
1108: {
1109: FONTINFO fi;
1110: PCACHEDFONT pCachedFont;
1111: ULONG cFntGlyphs;
1112: UINT nSize;
1113:
1114: BOOL bFoundBit, bEven;
1115: ULONG mask, mask1;
1116: INT i, j;
1117:
1118: DISPDBG((3, "S3.DLL!pCacheFont - Entry\n"));
1119:
1120: // Allocate a Font Cache node.
1121:
1122: pCachedFont = (PCACHEDFONT) LocalAlloc(LPTR, sizeof(CACHEDFONT));
1123: if (pCachedFont == NULL)
1124: {
1125: DISPDBG((1, "S3.DLL!pCacheFont - LocalAlloc of pCachedFont failed\n"));
1126: return(NULL);
1127: }
1128:
1129: // Add this font to the beginning of the font list.
1130:
1131: pCachedFont->pcfNext = pCachedFontsRoot;
1132: pCachedFontsRoot = pCachedFont;
1133:
1134: // Set the font ID for the font.
1135:
1136: pCachedFont->iUniq = pfo->iUniq;
1137:
1138: // Allocate the glyph cache.
1139:
1140: FONTOBJ_vGetInfo(pfo, sizeof(FONTINFO), &fi);
1141: cFntGlyphs = fi.cGlyphsSupported;
1142:
1143: // This is where we clamp the size of the Font structures we are allocating.
1144:
1145: if (cFntGlyphs > MAX_GLYPHS_TO_ALLOC)
1146: cFntGlyphs = MAX_GLYPHS_TO_ALLOC;
1147:
1148: // Round up to the next power of 2.
1149:
1150: bFoundBit = FALSE;
1151: mask = 0x80000000;
1152: for (i = 32; i != 0 && !bFoundBit; i--)
1153: {
1154: if (cFntGlyphs & mask)
1155: {
1156: bFoundBit = TRUE;
1157: mask1 = mask >> 1;
1158: bEven = TRUE;
1159: for (j = i - 1; j != 0; j--)
1160: {
1161: if (cFntGlyphs & mask1 )
1162: {
1163: bEven = FALSE;
1164: break;
1165: }
1166: mask1 >>= 1;
1167: }
1168: }
1169: else
1170: mask >>= 1;
1171: }
1172:
1173: if (bEven)
1174: cFntGlyphs = mask;
1175: else
1176: cFntGlyphs = mask << 1;
1177:
1178: // Get the font info.
1179:
1180: pCachedFont->cGlyphs = cFntGlyphs - 1;
1181:
1182: // Allocate memory for the CachedGlyphs of this font.
1183:
1184: nSize = cFntGlyphs * sizeof(CACHEDGLYPH);
1185:
1186: pCachedFont->pCachedGlyphs = (PCACHEDGLYPH) LocalAlloc(LPTR, nSize);
1187: if (pCachedFont->pCachedGlyphs == NULL)
1188: {
1189: DISPDBG((1, "S3.DLL!pCacheFont - LocalAlloc of pCachedGlyphs failed\n"));
1190: pCachedFont->cGlyphs = 0;
1191: return(NULL);
1192: }
1193:
1194: pCachedFont->pCachedGlyphs[0].hg = (HGLYPH)-1;
1195:
1196: // Return the pointer to the cached font. This is required
1197: // by the collision handling code.
1198:
1199: *ppCachedFont = pCachedFont;
1200:
1201: return(pCachedFont->pCachedGlyphs);
1202:
1203: }
1204:
1205:
1206: /*****************************************************************************
1207: * bAllocateGlyph - Allocate and initialize the cached glyph
1208: ****************************************************************************/
1209: BOOL bAllocateGlyph(
1210: PPDEV ppdev,
1211: HGLYPH hg,
1212: GLYPHBITS *pgb,
1213: PCACHEDGLYPH pcg)
1214: {
1215: BOOL b;
1216: ULONG cyGlyph, GlyphBmPitchInPels, GlyphBmPitchInBytes;
1217: XYZPOINTL xyzGlyph;
1218: WORD Cmd;
1219:
1220: DISPDBG((3, "S3.DLL!bAllocateGlyph - Entry\n"));
1221:
1222: cyGlyph = pgb->sizlBitmap.cy;
1223:
1224: GlyphBmPitchInBytes = CJ_SCAN(pgb->sizlBitmap.cx);
1225: GlyphBmPitchInPels = GlyphBmPitchInBytes * 8;
1226:
1227: // Allocate memory for the glyph data on the S3.
1228:
1229: b = bAllocGlyphMemory(ppdev, &(pgb->sizlBitmap), &xyzGlyph);
1230: if (b == FALSE)
1231: {
1232: DISPDBG((1, "S3.DLL!bAllocateGlyph - hCpAlloc failed\n"));
1233: return(FALSE);
1234: }
1235:
1236: // Initialize the Glyph Cache node.
1237:
1238: pcg->fl |= VALID_GLYPH;
1239: pcg->hg = hg;
1240: pcg->pcgCollisionLink = END_COLLISIONS;
1241: pcg->ptlOrigin = pgb->ptlOrigin;
1242: pcg->sizlBitmap = pgb->sizlBitmap;
1243: pcg->BmPitchInPels = GlyphBmPitchInPels;
1244: pcg->BmPitchInBytes = GlyphBmPitchInBytes;
1245: pcg->xyzGlyph = xyzGlyph;
1246:
1247: // Initialize the Glyph Cache data in S3 memory.
1248:
1249: Cmd = RECTANGLE_FILL | BUS_SIZE_8 | WAIT |
1250: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY |
1251: LAST_PIXEL_ON | MULTIPLE_PIXELS | WRITE;
1252:
1253: // Setup the S3 chip.
1254:
1255: FIFOWAIT(FIFO_5_EMPTY);
1256:
1257: TEST_AND_SET_FRGD_MIX(LOGICAL_1);
1258: TEST_AND_SET_BKGD_MIX(LOGICAL_0);
1259: TEST_AND_SET_WRT_MASK(LOWORD(xyzGlyph.z));
1260: OUTPW(CUR_X, xyzGlyph.x);
1261: OUTPW(CUR_Y, xyzGlyph.y);
1262:
1263: FIFOWAIT(FIFO_4_EMPTY);
1264:
1265: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | CPU_DATA));
1266: OUTPW(RECT_WIDTH, GlyphBmPitchInPels - 1);
1267: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cyGlyph - 1));
1268: GPWAIT();
1269: OUTPW(CMD, Cmd);
1270:
1271: CHECK_DATA_READY;
1272:
1273: // Now transfer the data.
1274:
1275: vDataPortOutB(ppdev, pgb->aj, GlyphBmPitchInBytes * cyGlyph);
1276:
1277: CHECK_DATA_COMPLETE;
1278:
1279: // Need to reset the write mask.
1280:
1281: FIFOWAIT(FIFO_1_EMPTY);
1282:
1283: TEST_AND_SET_WRT_MASK(0xFF);
1284:
1285: return (TRUE);
1286: }
1287:
1288:
1289: /****************************************************************************
1290: * vBlowCache - Blow Away the Cache
1291: ***************************************************************************/
1292: VOID vBlowCache(PPDEV ppdev)
1293: {
1294: PCACHEDFONT pcf;
1295: PCACHEDGLYPH pcg, pcgNext;
1296: INT nGlyphs, i;
1297:
1298: DISPDBG((2, "S3.DLL!vBlowCache - Entry\n"));
1299:
1300: // Traverse the CachedFonts list.
1301: // Free the collision nodes, and invalidate the cached glyphs
1302:
1303: for (pcf = pCachedFontsRoot; pcf != NULL; pcf = pcf->pcfNext)
1304: {
1305: // If there are any collision nodes for this glyph
1306: // free them.
1307:
1308: nGlyphs = pcf->cGlyphs+1;
1309:
1310: for (i = 0; i < nGlyphs; i++)
1311: {
1312: pcg = &(pcf->pCachedGlyphs[i]);
1313: pcg = pcg->pcgCollisionLink;
1314: for (; pcg != NULL; pcg = pcgNext)
1315: {
1316: pcgNext = pcg->pcgCollisionLink;
1317: LocalFree(pcg);
1318: }
1319: pcf->pCachedGlyphs[i].pcgCollisionLink = NULL;
1320:
1321: }
1322:
1323: // Invalidate all the glyphs in the glyph array.
1324:
1325: pcg = pcf->pCachedGlyphs;
1326: for (i = 0; i < nGlyphs; i++)
1327: {
1328: pcg[i].hg = (HGLYPH) -1;
1329: pcg[i].fl &= ~VALID_GLYPH;
1330: }
1331: }
1332:
1333: // Now ReInitialize the S3 Heap.
1334:
1335: memset((PVOID)ppdev->ajGlyphAllocBitVector,
1336: 0, CACHED_GLYPHS_ROWS * GLYPHS_PER_ROW);
1337:
1338: return;
1339: }
1340:
1341: /******************************************************************************
1342: * bAllocGlyphMemory -
1343: *
1344: * Allocate the some memory for the glyph.
1345: *
1346: *
1347: * return: TRUE - if memory was allocated.
1348: * FALSE - if there was no more memory.
1349: *
1350: *****************************************************************************/
1351: BOOL bAllocGlyphMemory(
1352: PPDEV ppdev,
1353: PSIZEL psizlGlyph,
1354: PXYZPOINTL pxyzGlyph)
1355: {
1356: BOOL bFound;
1357: INT iPlane, iRow, iGlyph;
1358: BYTE jPlaneBitVector;
1359:
1360:
1361: // Search the bit vector
1362:
1363: bFound = FALSE;
1364: for (iPlane = 0; iPlane < 8; iPlane++)
1365: {
1366: jPlaneBitVector = (BYTE) iPlaneBits[iPlane];
1367:
1368: for (iRow = 0; iRow < CACHED_GLYPHS_ROWS; iRow++)
1369: {
1370: for (iGlyph = 0; iGlyph < GLYPHS_PER_ROW; iGlyph++)
1371: {
1372: if (!(ppdev->ajGlyphAllocBitVector[iRow][iGlyph] & jPlaneBitVector))
1373: {
1374: bFound = TRUE;
1375: ppdev->ajGlyphAllocBitVector[iRow][iGlyph] |=
1376: jPlaneBitVector;
1377:
1378: pxyzGlyph->z = jPlaneBitVector;
1379: pxyzGlyph->x = iGlyph * GLYPH_CACHE_CX;
1380: pxyzGlyph->y = (iRow * GLYPH_CACHE_CY) + GLYPH_CACHE_Y;
1381:
1382: DISPDBG((5, "S3.DLL!bAllocGlyphMemory\n"));
1383: DISPDBG((5, "\t pxyzGlyph->z: %0x\n", pxyzGlyph->z));
1384: DISPDBG((5, "\t pxyzGlyph->x: %d\n", pxyzGlyph->x));
1385: DISPDBG((5, "\t pxyzGlyph->y: %d\n", pxyzGlyph->y));
1386:
1387: return (bFound);
1388: }
1389: }
1390: }
1391: }
1392:
1393: return (bFound);
1394: }
1395:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.