![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mfbimggblt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mfb|
Return to mfbimggblt.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mfb |
1.1 root 1: /***********************************************************
2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
4:
5: All Rights Reserved
6:
7: Permission to use, copy, modify, and distribute this software and its
8: documentation for any purpose and without fee is hereby granted,
9: provided that the above copyright notice appear in all copies and that
10: both that copyright notice and this permission notice appear in
11: supporting documentation, and that the names of Digital or MIT not be
12: used in advertising or publicity pertaining to distribution of the
13: software without specific, written prior permission.
14:
15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
21: SOFTWARE.
22:
23: ******************************************************************/
24: /* $Header: mfbimggblt.c,v 1.4 87/09/08 10:03:47 toddb Exp $ */
25: #include "X.h"
26: #include "Xmd.h"
27: #include "Xproto.h"
28: #include "fontstruct.h"
29: #include "dixfontstr.h"
30: #include "gcstruct.h"
31: #include "windowstr.h"
32: #include "scrnintstr.h"
33: #include "pixmapstr.h"
34: #include "regionstr.h"
35: #include "mfb.h"
36: #include "maskbits.h"
37:
38:
39: /*
40: we should eventually special-case fixed-width fonts for ImageText.
41:
42: this works for fonts with glyphs <= 32 bits wide.
43:
44: the clipping calculations are done for worst-case fonts.
45: we make no assumptions about the heights, widths, or bearings
46: of the glyphs. if we knew that the glyphs are all the same height,
47: we could clip the tops and bottoms per clipping box, rather
48: than per character per clipping box. if we knew that the glyphs'
49: left and right bearings were wlle-behaved, we could clip a single
50: character at the start, output until the last unclipped
51: character, and then clip the last one. this is all straightforward
52: to determine based on max-bounds and min-bounds from the font.
53: there is some inefficiency introduced in the per-character
54: clipping to make what's going on clearer.
55:
56: (it is possible, for example, for a font to be defined in which the
57: next-to-last character in a font would be clipped out, but the last
58: one wouldn't. the code below deals with this.)
59:
60: Image text looks at the bits in the glyph and the fg and bg in the
61: GC. it paints a rectangle, as defined in the protocol dcoument,
62: and the paints the characters.
63:
64: to avoid source proliferation, this file is compiled
65: three times:
66: MFBIMAGEGLYPHBLT OPEQ
67: mfbImageGlyphBltWhite |=
68: mfbImageGlyphBltBlack &=~
69:
70: the register allocations for startmask and endmask may not
71: be the right thing. are there two other deserving candidates?
72: xoff, pdst, pglyph, and tmpSrc seem like the right things, though.
73: */
74:
75: void
76: MFBIMAGEGLYPHBLT(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
77: DrawablePtr pDrawable;
78: GC *pGC;
79: int x, y;
80: unsigned int nglyph;
81: CharInfoPtr *ppci; /* array of character info */
82: unsigned char *pglyphBase; /* start of array of glyphs */
83: {
84: ExtentInfoRec info; /* used by QueryGlyphExtents() */
85: BoxRec bbox; /* string's bounding box */
86: xRectangle backrect;/* backing rectangle to paint.
87: in the general case, NOT necessarily
88: the same as the string's bounding box
89: */
90:
91: CharInfoPtr pci;
92: int xorg, yorg; /* origin of drawable in bitmap */
93: int widthDst; /* width of dst in longwords */
94:
95: /* these keep track of the character origin */
96: unsigned int *pdstBase;
97: /* points to longword with character origin */
98: int xchar; /* xorigin of char (mod 32) */
99:
100: /* these are used for placing the glyph */
101: register int xoff; /* x offset of left edge of glyph (mod 32) */
102: register unsigned int *pdst;
103: /* pointer to current longword in dst */
104:
105: int w; /* width of glyph in bits */
106: int h; /* height of glyph */
107: int widthGlyph; /* width of glyph, in bytes */
108: register unsigned char *pglyph;
109: /* pointer to current row of glyph */
110:
111: /* used for putting down glyph */
112: register int startmask;
113: register int endmask;
114:
115: int nFirst; /* bits of glyph in current longword */
116: register unsigned int tmpSrc;
117: /* for getting bits from glyph */
118: void (* oldFillArea)();
119: /* we might temporarily usurp this
120: field in devPriv */
121:
122: if (!(pGC->planemask & 1))
123: return;
124:
125: if (pDrawable->type == DRAWABLE_WINDOW)
126: {
127: xorg = ((WindowPtr)pDrawable)->absCorner.x;
128: yorg = ((WindowPtr)pDrawable)->absCorner.y;
129: pdstBase = (unsigned int *)
130: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate);
131: widthDst = (int)
132: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2;
133: }
134: else
135: {
136: xorg = 0;
137: yorg = 0;
138: pdstBase = (unsigned int *)(((PixmapPtr)pDrawable)->devPrivate);
139: widthDst = (int)(((PixmapPtr)pDrawable)->devKind) >> 2;
140: }
141:
142: QueryGlyphExtents(pGC->font, ppci, nglyph, &info);
143:
144: backrect.x = x;
145: backrect.y = y - pGC->font->pFI->fontAscent;
146: backrect.width = info.overallWidth;
147: backrect.height = pGC->font->pFI->fontAscent +
148: pGC->font->pFI->fontDescent;
149:
150: x += xorg;
151: y += yorg;
152:
153: bbox.x1 = x + info.overallLeft;
154: bbox.x2 = x + info.overallRight;
155: bbox.y1 = y - info.overallAscent;
156: bbox.y2 = y + info.overallDescent;
157:
158: /* UNCLEAN CODE
159: we know the mfbPolyFillRect uses only three fields in
160: devPriv, two of which (ppPixmap and ropFillArea) are
161: irrelevant for solid filling, so we just poke the FillArea
162: field. the GC is now in an inconsistent state, but we'll fix
163: it as soon as PolyFillRect returns. fortunately, the server
164: is single threaded.
165:
166: NOTE:
167: if you are not using the standard mfbFillRectangle code, you
168: need to poke any fields in the GC the rectangle stuff need
169: (probably alu, fgPixel, and fillStyle) and in devPriv
170: (probably rop or ropFillArea.) You could just call ValidateGC,
171: but that is usually not a cheap thing to do.
172: */
173:
174: oldFillArea = ((mfbPrivGC *)(pGC->devPriv))->FillArea;
175:
176: /* pcc doesn't like this. why?
177: ((mfbPrivGC *)(pGC->devPriv))->FillArea =
178: (pGC->bgPixel ? mfbSolidWhiteArea : mfbSolidBlackArea);
179: */
180: if (pGC->bgPixel)
181: ((mfbPrivGC *)(pGC->devPriv))->FillArea = mfbSolidWhiteArea;
182: else
183: ((mfbPrivGC *)(pGC->devPriv))->FillArea = mfbSolidBlackArea;
184:
185: mfbPolyFillRect(pDrawable, pGC, 1, &backrect);
186: ((mfbPrivGC *)(pGC->devPriv))->FillArea = oldFillArea;
187:
188: /* the faint-hearted can open their eyes now */
189: switch ((*pGC->pScreen->RectIn)(
190: ((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, &bbox))
191: {
192: case rgnOUT:
193: break;
194: case rgnIN:
195: pdstBase = pdstBase + (widthDst * y) + (x >> 5);
196: xchar = x & 0x1f;
197:
198: while(nglyph--)
199: {
200: pci = *ppci;
201: pglyph = pglyphBase + pci->byteOffset;
202: w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
203: h = pci->metrics.ascent + pci->metrics.descent;
204: widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
205:
206: /* start at top scanline of glyph */
207: pdst = pdstBase - (pci->metrics.ascent * widthDst);
208:
209: /* find correct word in scanline and x offset within it
210: for left edge of glyph
211: */
212: xoff = xchar + pci->metrics.leftSideBearing;
213: if (xoff > 31)
214: {
215: pdst++;
216: xoff &= 0x1f;
217: }
218: else if (xoff < 0)
219: {
220: xoff += 32;
221: pdst--;
222: }
223:
224: if ((xoff + w) <= 32)
225: {
226: /* glyph all in one longword */
227: maskpartialbits(xoff, w, startmask);
228: while (h--)
229: {
230: getleftbits(pglyph, w, tmpSrc);
231: *pdst OPEQ (SCRRIGHT(tmpSrc, xoff) & startmask);
232: pglyph += widthGlyph;
233: pdst += widthDst;
234: }
235: }
236: else
237: {
238: /* glyph crosses longword boundary */
239: mask32bits(xoff, w, startmask, endmask);
240: nFirst = 32 - xoff;
241: while (h--)
242: {
243: getleftbits(pglyph, w, tmpSrc);
244: *pdst OPEQ (SCRRIGHT(tmpSrc, xoff) & startmask);
245: *(pdst+1) OPEQ (SCRLEFT(tmpSrc, nFirst) & endmask);
246: pglyph += widthGlyph;
247: pdst += widthDst;
248: }
249: } /* glyph crosses longwords boundary */
250:
251: /* update character origin */
252: x += pci->metrics.characterWidth;
253: xchar += pci->metrics.characterWidth;
254: if (xchar > 31)
255: {
256: xchar -= 32;
257: pdstBase++;
258: }
259: else if (xchar < 0)
260: {
261: xchar += 32;
262: pdstBase--;
263: }
264: ppci++;
265: } /* while nglyph-- */
266: break;
267: case rgnPART:
268: {
269: TEXTPOS *ppos;
270: int nbox;
271: BoxPtr pbox;
272: int xpos; /* x position of char origin */
273: int i;
274: BoxRec clip;
275: int leftEdge, rightEdge;
276: int topEdge, bottomEdge;
277: int glyphRow; /* first row of glyph not wholly
278: clipped out */
279: int glyphCol; /* leftmost visible column of glyph */
280:
281: if(!(ppos = (TEXTPOS *)ALLOCATE_LOCAL(nglyph * sizeof(TEXTPOS))))
282: return;
283:
284: pdstBase = pdstBase + (widthDst * y) + (x >> 5);
285: xpos = x;
286: xchar = xpos & 0x1f;
287:
288: for (i=0; i<nglyph; i++)
289: {
290: pci = ppci[i];
291:
292: ppos[i].xpos = xpos;
293: ppos[i].xchar = xchar;
294: ppos[i].leftEdge = xpos + pci->metrics.leftSideBearing;
295: ppos[i].rightEdge = xpos + pci->metrics.rightSideBearing;
296: ppos[i].topEdge = y - pci->metrics.ascent;
297: ppos[i].bottomEdge = y + pci->metrics.descent;
298: ppos[i].pdstBase = pdstBase;
299: ppos[i].widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
300:
301: xpos += pci->metrics.characterWidth;
302: xchar += pci->metrics.characterWidth;
303: if (xchar > 31)
304: {
305: xchar &= 0x1f;
306: pdstBase++;
307: }
308: else if (xchar < 0)
309: {
310: xchar += 32;
311: pdstBase--;
312: }
313: }
314:
315: pbox = ((mfbPrivGC *)(pGC->devPriv))->pCompositeClip->rects;
316: nbox = ((mfbPrivGC *)(pGC->devPriv))->pCompositeClip->numRects;
317:
318: /* HACK ALERT
319: since we continue out of the loop below so often, it
320: is easier to increment pbox at the top than at the end.
321: don't try this at home.
322: */
323: pbox--;
324: while(nbox--)
325: {
326: pbox++;
327: clip.x1 = max(bbox.x1, pbox->x1);
328: clip.y1 = max(bbox.y1, pbox->y1);
329: clip.x2 = min(bbox.x2, pbox->x2);
330: clip.y2 = min(bbox.y2, pbox->y2);
331: if ((clip.x2<=clip.x1) || (clip.y2<=clip.y1))
332: continue;
333:
334: for(i=0; i<nglyph; i++)
335: {
336: pci = ppci[i];
337: xchar = ppos[i].xchar;
338:
339: /* clip the left and right edges */
340: if (ppos[i].leftEdge < clip.x1)
341: leftEdge = clip.x1;
342: else
343: leftEdge = ppos[i].leftEdge;
344:
345: if (ppos[i].rightEdge > clip.x2)
346: rightEdge = clip.x2;
347: else
348: rightEdge = ppos[i].rightEdge;
349:
350: w = rightEdge - leftEdge;
351: if (w <= 0)
352: continue;
353:
354: /* clip the top and bottom edges */
355: if (ppos[i].topEdge < clip.y1)
356: topEdge = clip.y1;
357: else
358: topEdge = ppos[i].topEdge;
359:
360: if (ppos[i].bottomEdge > clip.y2)
361: bottomEdge = clip.y2;
362: else
363: bottomEdge = ppos[i].bottomEdge;
364:
365: h = bottomEdge - topEdge;
366: if (h <= 0)
367: continue;
368:
369: glyphRow = (topEdge - y) + pci->metrics.ascent;
370: widthGlyph = ppos[i].widthGlyph;
371: pglyph = pglyphBase + pci->byteOffset;
372: pglyph += (glyphRow * widthGlyph);
373:
374: pdst = ppos[i].pdstBase - ((y-topEdge) * widthDst);
375:
376: glyphCol = (leftEdge - ppos[i].xpos) -
377: (pci->metrics.leftSideBearing);
378: xoff = xchar + (leftEdge - ppos[i].xpos);
379: if (xoff > 31)
380: {
381: xoff &= 0x1f;
382: pdst++;
383: }
384: else if (xoff < 0)
385: {
386: xoff += 32;
387: pdst--;
388: }
389:
390: if ((xoff + w) <= 32)
391: {
392: maskpartialbits(xoff, w, startmask);
393: while (h--)
394: {
395: getshiftedleftbits(pglyph, glyphCol, w, tmpSrc);
396: *pdst OPEQ (SCRRIGHT(tmpSrc, xoff) & startmask);
397: pglyph += widthGlyph;
398: pdst += widthDst;
399: }
400: }
401: else
402: {
403: mask32bits(xoff, w, startmask, endmask);
404: nFirst = 32 - xoff;
405: while (h--)
406: {
407: getshiftedleftbits(pglyph, glyphCol, w, tmpSrc);
408: *pdst OPEQ (SCRRIGHT(tmpSrc, xoff) & startmask);
409: *(pdst+1) OPEQ (SCRLEFT(tmpSrc, nFirst) & endmask);
410: pglyph += widthGlyph;
411: pdst += widthDst;
412: }
413: }
414: } /* for each glyph */
415: } /* while nbox-- */
416: DEALLOCATE_LOCAL(ppos);
417: break;
418: }
419: default:
420: break;
421: }
422: }
423:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.