![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to paint.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 paint.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256 |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: paint.c
3: *
4: * Copyright (c) 1992 Microsoft Corporation
5: \**************************************************************************/
6:
7: #include "driver.h"
8:
9: /******************************Public*Data*********************************\
10: * MIX translation table
11: *
12: * Translates a mix 1-16, into an old style Rop 0-255.
13: *
14: \**************************************************************************/
15:
16: BYTE gaMix[] =
17: {
18: 0xFF, // R2_WHITE - Allow rop = gaMix[mix & 0x0F]
19: 0x00, // R2_BLACK
20: 0x05, // R2_NOTMERGEPEN
21: 0x0A, // R2_MASKNOTPEN
22: 0x0F, // R2_NOTCOPYPEN
23: 0x50, // R2_MASKPENNOT
24: 0x55, // R2_NOT
25: 0x5A, // R2_XORPEN
26: 0x5F, // R2_NOTMASKPEN
27: 0xA0, // R2_MASKPEN
28: 0xA5, // R2_NOTXORPEN
29: 0xAA, // R2_NOP
30: 0xAF, // R2_MERGENOTPEN
31: 0xF0, // R2_COPYPEN
32: 0xF5, // R2_MERGEPENNOT
33: 0xFA, // R2_MERGEPEN
34: 0xFF // R2_WHITE
35: };
36:
37: /******************************Public*Routine******************************\
38: * vTrgTrap(ppdev, ptrap, mix, iColor)
39: *
40: * Blit to a trapezoid.
41: *
42: \**************************************************************************/
43:
44: VOID vTrgTrap
45: (
46: PPDEV ppdev,
47: TRAPEZOID *ptrap,
48: MIX mix,
49: RBRUSH_COLOR rbc,
50: POINTL *pptlBrush,
51: PFNFILL pfnFill
52: )
53: {
54: DDAENUM ddae;
55: RECTL rcl[MAX_DDA_RECTS], *prcl;
56: ULONG culrcl;
57: LONG *px;
58: LONG yRow;
59:
60: if (!DDAOBJ_bEnum(ppdev->pdda, (PVOID) ptrap, sizeof(ddae),
61: (DDALIST *) &ddae, JD_ENUM_TRAPEZOID))
62: return;
63:
64: do {
65: culrcl = 0;
66: prcl = rcl;
67: px = &ddae.axPairs[0];
68:
69: // Accumulate the rectangles for this trapezoid enumeration burst,
70: // then send them to the solid filler as a group
71: for (yRow = ddae.yTop; yRow < ddae.yBottom; yRow++) {
72: if (*px < *(px+1)) {
73: prcl->top = yRow;
74: prcl->left = *px;
75: prcl->bottom = yRow + 1;
76: prcl++->right = *(px+1);
77: culrcl++;
78: }
79:
80: px += 2;
81:
82: }
83:
84: // Draw the rectangles, if there are any
85: if (culrcl > 0) {
86: (*pfnFill)(ppdev, culrcl, rcl, mix, rbc, pptlBrush);
87: }
88:
89: } while (DDAOBJ_bEnum(ppdev->pdda, (PVOID) NULL, sizeof(ddae),
90: (DDALIST *) &ddae, JD_ENUM_TRAPEZOID));
91: }
92:
93: /******************************Public*Routine******************************\
94: * bPaintRgn
95: *
96: * Paint the clipping region with the specified color and mode
97: *
98: \**************************************************************************/
99:
100: BOOL bPaintRgn
101: (
102: SURFOBJ *pso,
103: CLIPOBJ *pco,
104: MIX mix,
105: RBRUSH_COLOR rbc,
106: POINTL *pptlBrush,
107: PFNFILL pfnFill
108: )
109: {
110: BBENUM bben;
111: BBENUMTRAP bbent;
112: PPDEV ppdev;
113: ULONG iRT;
114: BOOL bMore;
115:
116: // Get the target surface information.
117:
118: ppdev = (PPDEV) pso->dhsurf;
119:
120: switch(pco->iMode) {
121:
122: case TC_RECTANGLES:
123:
124: // Rectangular clipping can be handled without enumeration.
125: // Note that trivial clipping is not possible, since the clipping
126: // region defines the area to fill
127:
128: if (pco->iDComplexity == DC_RECT)
129: {
130: (*pfnFill)(ppdev, 1, &pco->rclBounds, mix, rbc, pptlBrush);
131:
132: } else {
133:
134: // Enumerate all the rectangles and draw them
135:
136: CLIPOBJ_cEnumStart(pco,TRUE,CT_RECTANGLES,CD_ANY,BB_RECT_LIMIT);
137:
138: do {
139: bMore = CLIPOBJ_bEnum(pco, sizeof(bben), (PVOID) &bben);
140:
141: (*pfnFill)(ppdev, bben.c, &bben.arcl[0], mix, rbc, pptlBrush);
142:
143: } while (bMore);
144: }
145:
146: return(TRUE);
147:
148: case TC_TRAPEZOIDS:
149:
150: // Enumerate all the trapezoids and draw them
151:
152: CLIPOBJ_cEnumStart(pco,TRUE,CT_TRAPEZOIDS,CD_ANY,BB_RECT_LIMIT);
153:
154: do {
155: bMore = CLIPOBJ_bEnum(pco, sizeof(bbent), (PVOID) &bbent);
156:
157: for (iRT = 0; iRT < bbent.c; iRT++)
158: vTrgTrap(ppdev, &bbent.atrap[iRT], mix, rbc, pptlBrush, pfnFill);
159:
160: } while (bMore);
161:
162: return(TRUE);
163:
164: default:
165: RIP("bPaintRgn: unhandled TC_xxx\n");
166: return(FALSE);
167: }
168: }
169:
170:
171: /**************************************************************************\
172: * DrvPaint
173: *
174: * Paint the clipping region with the specified brush
175: *
176: \**************************************************************************/
177:
178: BOOL DrvPaint
179: (
180: SURFOBJ *pso,
181: CLIPOBJ *pco,
182: BRUSHOBJ *pbo,
183: POINTL *pptlBrush,
184: MIX mix
185: )
186: {
187: ROP4 rop4;
188: RBRUSH_COLOR rbc;
189: PFNFILL pfnFill;
190:
191: // If this adapter supports planar mode and the foreground and background
192: // mixes are the same,
193: // LATER or if there's no brush mask
194: // then see if we can use the brush accelerators
195: // LATER handle non-planar also
196:
197: if ((((PPDEV) pso->dhsurf)->fl & DRIVER_PLANAR_CAPABLE) &&
198: ((mix & 0xFF) == ((mix >> 8) & 0xFF))) {
199:
200: switch (mix & 0xFF) {
201: case 0:
202: break;
203:
204: // vTrgBlt can only handle solid color fills where if the
205: // destination is inverted, no other action is also required
206:
207: case R2_MASKNOTPEN:
208: case R2_NOTCOPYPEN:
209: case R2_XORPEN:
210: case R2_MASKPEN:
211: case R2_NOTXORPEN:
212: case R2_MERGENOTPEN:
213: case R2_COPYPEN:
214: case R2_MERGEPEN:
215: case R2_NOTMERGEPEN:
216: case R2_MASKPENNOT:
217: case R2_NOTMASKPEN:
218: case R2_MERGEPENNOT:
219:
220: // vTrgBlt can only handle solid color fills
221:
222: if (pbo->iSolidColor != 0xffffffff)
223: {
224: rbc.iSolidColor = pbo->iSolidColor;
225: pfnFill = vTrgBlt;
226: }
227: else
228: {
229: rbc.prb = (RBRUSH*) pbo->pvRbrush;
230: if (rbc.prb == NULL)
231: {
232: rbc.prb = (RBRUSH*) BRUSHOBJ_pvGetRbrush(pbo);
233: if (rbc.prb == NULL)
234: {
235: // If we haven't realized the brush, punt the call:
236:
237: break;
238: }
239: }
240: if (!(rbc.prb->fl & RBRUSH_BLACKWHITE) &&
241: ((mix & 0xff) != R2_COPYPEN))
242: {
243: // Only black/white brushes can handle ROPs other
244: // than COPYPEN:
245:
246: break;
247: }
248:
249: if (rbc.prb->fl & RBRUSH_NCOLOR)
250: pfnFill = vColorPat;
251: else
252: pfnFill = vMonoPat;
253: }
254:
255: return(bPaintRgn(pso, pco, mix, rbc, pptlBrush, pfnFill));
256:
257: // Rops that are implicit solid colors
258:
259: case R2_NOT:
260: case R2_WHITE:
261: case R2_BLACK:
262:
263: // Brush color parameter doesn't matter for these rops
264:
265: return(bPaintRgn(pso, pco, mix, rbc, NULL, vTrgBlt));
266:
267: case R2_NOP:
268: return(TRUE);
269:
270: default:
271: break;
272: }
273: }
274:
275: rop4 = (gaMix[(mix >> 8) & 0x0F]) << 8;
276: rop4 |= ((ULONG) gaMix[mix & 0x0F]);
277:
278: return(DrvBitBlt(
279: pso,
280: (SURFOBJ *) NULL,
281: (SURFOBJ *) NULL,
282: pco,
283: (XLATEOBJ *) NULL,
284: &pco->rclBounds,
285: (POINTL *) NULL,
286: (POINTL *) NULL,
287: pbo,
288: pptlBrush,
289: rop4));
290: }
291:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.