![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stroke.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 / vga|
Return to stroke.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: Stroke.c
3: *
4: * DrvStrokePath for VGA driver
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: \**************************************************************************/
8:
9: #include "driver.h"
10:
11: #include "lines.h"
12:
13: // External calls
14:
15: VOID vSetStrips(ULONG, ULONG);
16: VOID vClearStrips(ULONG);
17:
18: #define MIN(A,B) ((A) < (B) ? (A) : (B))
19:
20: // Prototypes to go to the screen:
21:
22: VOID vStripSolidHorizontal(STRIP*, LINESTATE*, LONG*);
23: VOID vStripSolidHorizontalSet(STRIP*, LINESTATE*, LONG*);
24: VOID vStripSolidVertical(STRIP*, LINESTATE*, LONG*);
25: VOID vStripSolidDiagonalHorizontal(STRIP*, LINESTATE*, LONG*);
26: VOID vStripSolidDiagonalVertical(STRIP*, LINESTATE*, LONG*);
27:
28: VOID vStripStyledHorizontal(STRIP*, LINESTATE*, LONG*);
29: VOID vStripStyledVertical(STRIP*, LINESTATE*, LONG*);
30:
31: VOID vStripMaskedHorizontal(STRIP*, LINESTATE*, LONG*);
32: VOID vStripMaskedVertical(STRIP*, LINESTATE*, LONG*);
33:
34: PFNSTRIP gapfnStripSolidSet[] = {
35:
36: // Special strip drawers for solid lines with SET style ROPs:
37:
38: vStripSolidHorizontalSet,
39: vStripSolidVertical,
40: vStripSolidDiagonalHorizontal,
41: vStripSolidDiagonalVertical
42: };
43:
44: PFNSTRIP gapfnStrip[] = {
45:
46: // The order of these first 3 sets of strip drawers is determined by
47: // the FL_STYLE_MASK bits of the line flags:
48:
49: vStripSolidHorizontal,
50: vStripSolidVertical,
51: vStripSolidDiagonalHorizontal,
52: vStripSolidDiagonalVertical,
53:
54: vStripStyledHorizontal,
55: vStripStyledVertical,
56: NULL, // Diagonal goes here
57: NULL, // Diagonal goes here
58:
59: vStripMaskedHorizontal,
60: vStripMaskedVertical,
61: NULL, // Diagonal goes here
62: NULL, // Diagonal goes here
63: };
64:
65: // Prototypes to go to a device-format bitmap:
66:
67: VOID vBitmapSolidHorizontal(STRIP*, LINESTATE*, LONG*);
68: VOID vBitmapSolidVertical(STRIP*, LINESTATE*, LONG*);
69: VOID vBitmapSolidDiagonal(STRIP*, LINESTATE*, LONG*);
70:
71: VOID vBitmapStyledHorizontal(STRIP*, LINESTATE*, LONG*);
72: VOID vBitmapStyledVertical(STRIP*, LINESTATE*, LONG*);
73:
74: // For two-pass ROPs:
75:
76: VOID vCatchTwoPass(STRIP*, LINESTATE*, LONG*);
77:
78: PFNSTRIP gapfnCatchTwoPass[] = {
79: vCatchTwoPass,
80: vCatchTwoPass,
81: vCatchTwoPass,
82: vCatchTwoPass
83: };
84:
85: // VGA ulVgaMode constants:
86:
87: #define DR_SET 0x00
88: #define DR_AND 0x08
89: #define DR_OR 0x10
90: #define DR_XOR 0x18
91:
92: // Bit flag set if two passes needed:
93:
94: #define DR_2PASS 0x80
95:
96: // Table to convert ROP to usable information:
97:
98: static struct {
99: ULONG ulColorAnd;
100: ULONG ulColorXor;
101: ULONG ulVgaMode;
102: } arop[] = {
103: {0x00, 0xff, DR_SET}, // 1 R2_WHITE
104: {0x00, 0x00, DR_SET}, // 0 R2_BLACK
105: {0xff, 0xff, DR_AND|DR_2PASS}, // DPon R2_NOTMERGEPEN Dest invert + DPna
106: {0xff, 0xff, DR_AND}, // DPna R2_MASKNOTPEN
107: {0xff, 0xff, DR_SET}, // PN R2_NOTCOPYPEN
108: {0xff, 0x00, DR_AND|DR_2PASS}, // PDna R2_MASKPENNOT Dest invert + DPa
109: {0x00, 0xff, DR_XOR}, // Dn R2_NOT Invert dest without pen
110: {0xff, 0x00, DR_XOR}, // DPx R2_XORPEN
111: {0xff, 0xff, DR_OR|DR_2PASS}, // DPan R2_NOTMASKPEN Dest invert + DPno
112: {0xff, 0x00, DR_AND}, // DPa R2_MASKPEN
113: {0xff, 0xff, DR_XOR}, // DPxn R2_NOTXORPEN DPxn == DPnx
114: {0x00, 0x00, DR_OR}, // D R2_NOP Silliness!
115: {0xff, 0xff, DR_OR}, // DPno R2_MERGENOTPEN
116: {0xff, 0x00, DR_SET}, // P R2_COPYPEN
117: {0xff, 0x00, DR_OR|DR_2PASS}, // PDno R2_MERGEPENNOT Dest invert + DPo
118: {0xff, 0x00, DR_OR}, // DPo R2_MERGEPEN
119: };
120:
121: // The gaulAndXorTable contains and-masks and xor-masks for setting
122: // pels to one of four possible values. The and-masks have been
123: // inverted, and are stored in the low byte of each word. The
124: // xor-masks are stored in the high bytes.
125: //
126: // ROP XOR ~AND
127: // -------------------
128: // DDx 00 FF Set to zero
129: // Dn FF 00 Not destination
130: // D 00 00 Leave alone
131: // DDxn FF FF Set to one
132:
133: ULONG gaulAndXorTable[] = {
134: 0x00ff, // Set to zero
135: 0xff00, // Not destination
136: 0x0000, // Leave alone
137: 0xffff // Set to one
138: };
139:
140: ULONG gaulInitMasksLtoR[] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f };
141: ULONG gaulInitMasksRtoL[] = { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe };
142:
143: /******************************Public*Routine******************************\
144: * BOOL DrvStrokePath(pso, ppo, pco, pxo, pbo, pptlBrushOrg, pla, mix)
145: *
146: * Strokes the path.
147: *
148: \**************************************************************************/
149:
150: BOOL DrvStrokePath(
151: SURFOBJ* pso,
152: PATHOBJ* ppo,
153: CLIPOBJ* pco,
154: XFORMOBJ* pxo,
155: BRUSHOBJ* pbo,
156: POINTL* pptlBrushOrg,
157: LINEATTRS* pla,
158: MIX mix)
159: {
160: STYLEPOS aspLtoR[STYLE_MAX_COUNT];
161: STYLEPOS aspRtoL[STYLE_MAX_COUNT];
162: LINESTATE ls;
163: PFNSTRIP* apfn;
164: FLONG fl;
165: PDEVSURF pdsurf;
166: ULONG ulVgaMode;
167:
168: UNREFERENCED_PARAMETER(pxo);
169: UNREFERENCED_PARAMETER(pptlBrushOrg);
170:
171: // Verify that things are as they should be:
172:
173: // ASSERT(pso != (SURFOBJ*) NULL, "DrvStrokePath: surface");
174: // ASSERT(ppo != (PATHOBJ*) NULL, "DrvStrokePath: path");
175: // ASSERT(pco != (CLIPOBJ*) NULL, "DrvStrokePath: clipobj");
176: // ASSERT(pbo != (BRUSHOBJ*) NULL, "DrvStrokePath: brushobj");
177: // ASSERT(pla != (LINEATTRS*) NULL && !(pla->fl & LA_GEOMETRIC),
178: // "DrvStrokePath: lineattrs");
179: // ASSERT(pbo->iSolidColor != 0xffffffff,
180: // "DrvStrokePath: brushobj isn't solid");
181:
182: // Get the device ready:
183:
184: pdsurf = (PDEVSURF) pso->dhsurf;
185: // ASSERT(pdsurf != (PDEVSURF) NULL, "DrvStrokePath: no surface");
186:
187: fl = 0;
188:
189: // Look after styling initialization:
190:
191: if (pla->fl & LA_ALTERNATE)
192: {
193: // ASSERT(pla->pstyle == (FLOAT_LONG*) NULL && pla->cstyle == 0,
194: // "Non-empty style array for PS_ALTERNATE");
195:
196: ls.spTotal = 1;
197: ls.spTotal2 = 2;
198: ls.xyDensity = 1;
199: fl |= (FL_ALTERNATESTYLED | FL_MASKSTYLED);
200: }
201: else if (pla->pstyle != (FLOAT_LONG*) NULL)
202: {
203: PFLOAT_LONG pstyle;
204:
205: // ASSERT(pla->cstyle <= STYLE_MAX_COUNT, "Style array too large");
206:
207: pstyle = &pla->pstyle[pla->cstyle];
208:
209: ls.xyDensity = STYLE_DENSITY;
210: ls.spTotal = 0;
211: while (pstyle-- > pla->pstyle)
212: {
213: ls.spTotal += pstyle->l;
214: }
215: ls.spTotal *= STYLE_DENSITY;
216: ls.spTotal2 = 2 * ls.spTotal;
217:
218: // Compute starting style position (this is guaranteed not to overflow):
219:
220: ls.spNext = HIWORD(pla->elStyleState.l) * STYLE_DENSITY +
221: LOWORD(pla->elStyleState.l);
222:
223: // We optimize the style arrays that are even length and sum to 8. We
224: // also don't have any masked strip drawers for DFBs:
225:
226: if (ls.spTotal == (8 * STYLE_DENSITY) &&
227: (pla->cstyle & 1) == 0)
228: {
229: // Do "masked" styles.
230: // -------------------
231: //
232: // This case is merely an optimization; you can remove it and
233: // all style lines will still work. It just so happens that the
234: // default styles (such as PS_DOT, PS_DASHDOT, etc.) will all
235: // sum to 8, and there are some optimizations we can do on the
236: // VGA for that case.
237: //
238: // We make an 8 bit mask that represents each style unit in the
239: // style array, and we pass this to the "Masked" strip drawers
240: // (instead of calling the "Styled" strip drawers which still
241: // handle the arbitrary styles).
242:
243: LONG ii;
244:
245: ls.ulStyleMaskLtoR = 0;
246: ls.ulStyleMaskRtoL = 0;
247:
248: for (pstyle = pla->pstyle, ii = 8; ii > 0;)
249: {
250: LONG l1 = (pstyle++)->l;
251: LONG l2 = (pstyle++)->l;
252:
253: ls.ulStyleMaskRtoL >>= l1 + l2;
254: ls.ulStyleMaskRtoL |= gaulInitMasksRtoL[l2];
255:
256: ls.ulStyleMaskLtoR <<= l1 + l2;
257: ls.ulStyleMaskLtoR |= gaulInitMasksLtoR[l2];
258:
259: ii -= (l1 + l2);
260: }
261:
262: // Replicate byte and initialize to style position zero:
263:
264: ls.ulStyleMaskLtoR |= (ls.ulStyleMaskLtoR << 8);
265: ls.ulStyleMaskLtoR |= (ls.ulStyleMaskLtoR << 16);
266:
267: ls.ulStyleMaskRtoL |= (ls.ulStyleMaskRtoL << 8);
268: ls.ulStyleMaskRtoL |= (ls.ulStyleMaskRtoL << 16);
269:
270: // Check if we should start with a gap or start with a dash:
271:
272: if (pla->fl & LA_STARTGAP)
273: {
274: ls.ulStyleMaskLtoR = ~ls.ulStyleMaskLtoR;
275: ls.ulStyleMaskRtoL = ~ls.ulStyleMaskRtoL;
276: }
277:
278: // Initialize some other state:
279:
280: fl |= FL_MASKSTYLED;
281: }
282: else
283:
284: // Okay, we've got to do it the slow way:
285:
286: {
287: // Handle Arbitrary Styles
288: // -----------------------
289: //
290: // Because arbitrary styles are new to Win32, many apps won't
291: // know about them and will use the default styles (which will
292: // be handled by the "Masked" optimization case above), and so
293: // this code path won't get exercised too often. (See GDI's
294: // ExtCreatePen API.)
295: //
296: // But you still have to handle them, and do them right!
297:
298: FLOAT_LONG* pstyle;
299: STYLEPOS* pspDown;
300: STYLEPOS* pspUp;
301:
302: fl |= FL_ARBITRARYSTYLED;
303: ls.cStyle = pla->cstyle;
304: ls.aspRtoL = aspRtoL;
305: ls.aspLtoR = aspLtoR;
306:
307: if (pla->fl & LA_STARTGAP)
308: ls.ulStartMask = 0xffffffffL;
309: else
310: ls.ulStartMask = 0L;
311:
312: pstyle = pla->pstyle;
313: pspDown = &ls.aspRtoL[ls.cStyle - 1];
314: pspUp = &ls.aspLtoR[0];
315:
316: // We always draw strips left-to-right, but styles have to be laid
317: // down in the direction of the original line. This means that in
318: // the strip code we have to traverse the style array in the
319: // opposite direction;
320:
321: while (pspDown >= &ls.aspRtoL[0])
322: {
323: // ASSERT(pstyle->l > 0 && pstyle->l <= STYLE_MAX_VALUE,
324: // "Illegal style array value");
325:
326: *pspDown = pstyle->l * STYLE_DENSITY;
327: *pspUp = *pspDown;
328:
329: pspUp++;
330: pspDown--;
331: pstyle++;
332: }
333: }
334: }
335:
336: {
337: ULONG iColor;
338: ULONG iStripIndex;
339:
340: fl |= FL_PHYSICAL_DEVICE;
341:
342: // Compute the pointer to the correct strip drawing table. We
343: // have a special table for solid lines done with VGA mode == SET:
344:
345: iStripIndex = 4 * ((fl & FL_STYLE_MASK) >> FL_STYLE_SHIFT);
346: apfn = &gapfnStrip[iStripIndex];
347:
348: mix &= 0xf;
349: ulVgaMode = arop[mix].ulVgaMode;
350:
351: if (ulVgaMode == DR_SET && iStripIndex == 0)
352: apfn = &gapfnStripSolidSet[0];
353:
354: // Compute the correct color, based on the ROP we're doing:
355:
356: iColor = (pbo->iSolidColor & arop[mix].ulColorAnd)
357: ^ (arop[mix].ulColorXor);
358:
359: if (!(ulVgaMode & DR_2PASS))
360: vSetStrips(iColor, ulVgaMode);
361: else
362: {
363: // If the ROP requires 2 passes, we sneakily change our strip
364: // table pointer to point to only our own routine, and it
365: // handles calling the appropriate strip routines twice:
366:
367: ls.ulVgaMode = ulVgaMode ^ DR_2PASS;
368: ls.iColor = iColor;
369: ls.apfnStrip = apfn;
370: apfn = gapfnCatchTwoPass;
371: }
372: }
373:
374: // Set up to enumerate the path:
375:
376: if (pco->iDComplexity != DC_COMPLEX)
377: {
378: RECTL arclClip[4]; // For rectangular clipping
379: PATHDATA pd;
380: RECTL* prclClip = (RECTL*) NULL;
381: BOOL bMore;
382: ULONG cptfx;
383: POINTFIX ptfxStartFigure;
384: POINTFIX ptfxLast;
385: POINTFIX* pptfxFirst;
386: POINTFIX* pptfxBuf;
387:
388: if (pco->iDComplexity == DC_RECT)
389: {
390: fl |= FL_SIMPLE_CLIP;
391:
392: arclClip[0] = pco->rclBounds;
393:
394: // FL_FLIP_D:
395:
396: arclClip[1].top = pco->rclBounds.left;
397: arclClip[1].left = pco->rclBounds.top;
398: arclClip[1].bottom = pco->rclBounds.right;
399: arclClip[1].right = pco->rclBounds.bottom;
400:
401: // FL_FLIP_V:
402:
403: arclClip[2].top = -pco->rclBounds.bottom + 1;
404: arclClip[2].left = pco->rclBounds.left;
405: arclClip[2].bottom = -pco->rclBounds.top + 1;
406: arclClip[2].right = pco->rclBounds.right;
407:
408: // FL_FLIP_V | FL_FLIP_D:
409:
410: arclClip[3].top = pco->rclBounds.left;
411: arclClip[3].left = -pco->rclBounds.bottom + 1;
412: arclClip[3].bottom = pco->rclBounds.right;
413: arclClip[3].right = -pco->rclBounds.top + 1;
414:
415: prclClip = arclClip;
416: }
417:
418: PATHOBJ_vEnumStart(ppo);
419:
420: do {
421: bMore = PATHOBJ_bEnum(ppo, &pd);
422:
423: cptfx = pd.count;
424: if (cptfx == 0)
425: {
426: // ASSERT(!bMore, "Empty path record in non-empty path");
427: break;
428: }
429:
430: if (pd.flags & PD_BEGINSUBPATH)
431: {
432: ptfxStartFigure = *pd.pptfx;
433: pptfxFirst = pd.pptfx;
434: pptfxBuf = pd.pptfx + 1;
435: cptfx--;
436: }
437: else
438: {
439: pptfxFirst = &ptfxLast;
440: pptfxBuf = pd.pptfx;
441: }
442:
443: if (pd.flags & PD_RESETSTYLE)
444: ls.spNext = 0;
445:
446: // We have to check for cptfx == 0 because the only point in the
447: // subpath may have been the StartFigure point:
448:
449: if (cptfx > 0)
450: {
451: if (!bLines(pdsurf,
452: pptfxFirst,
453: pptfxBuf,
454: (RUN*) NULL,
455: cptfx,
456: &ls,
457: prclClip,
458: apfn,
459: fl))
460: return(FALSE);
461: }
462:
463: ptfxLast = pd.pptfx[pd.count - 1];
464:
465: if (pd.flags & PD_CLOSEFIGURE)
466: {
467: if (!bLines(pdsurf,
468: &ptfxLast,
469: &ptfxStartFigure,
470: (RUN*) NULL,
471: 1,
472: &ls,
473: prclClip,
474: apfn,
475: fl))
476: return(FALSE);
477: }
478: } while (bMore);
479:
480: if (fl & FL_STYLED)
481: {
482: // Save the style state:
483:
484: ULONG ulHigh;
485: ULONG ulLow;
486:
487: // !!! The engine handles unnormalized style states. This can
488: // !!! be removed. Might have to remove some asserts in the
489: // !!! engine.
490:
491: // Masked styles don't normalize the style state. It's a good
492: // thing to do, so let's do it now:
493:
494: if ((ULONG) ls.spNext >= (ULONG) ls.spTotal2)
495: ls.spNext = (ULONG) ls.spNext % (ULONG) ls.spTotal2;
496:
497: ulHigh = ls.spNext / ls.xyDensity;
498: ulLow = ls.spNext % ls.xyDensity;
499:
500: pla->elStyleState.l = MAKELONG(ulLow, ulHigh);
501: }
502: }
503: else
504: {
505: // Local state for path enumeration:
506:
507: BOOL bMore;
508: union {
509: BYTE aj[offsetof(CLIPLINE, arun) + RUN_MAX * sizeof(RUN)];
510: CLIPLINE cl;
511: } cl;
512:
513: fl |= FL_COMPLEX_CLIP;
514:
515: // We use the clip object when non-simple clipping is involved:
516:
517: PATHOBJ_vEnumStartClipLines(ppo, pco, pso, pla);
518:
519: do {
520: bMore = PATHOBJ_bEnumClipLines(ppo, sizeof(cl), &cl.cl);
521: if (cl.cl.c != 0)
522: {
523: if (fl & FL_STYLED)
524: {
525: ls.spComplex = HIWORD(cl.cl.lStyleState) * ls.xyDensity
526: + LOWORD(cl.cl.lStyleState);
527: }
528: if (!bLines(pdsurf,
529: &cl.cl.ptfxA,
530: &cl.cl.ptfxB,
531: &cl.cl.arun[0],
532: cl.cl.c,
533: &ls,
534: (RECTL*) NULL,
535: apfn,
536: fl))
537: return(FALSE);
538: }
539: } while (bMore);
540: }
541:
542: if (fl & FL_PHYSICAL_DEVICE)
543: vClearStrips(ulVgaMode);
544:
545: return(TRUE);
546: }
547:
548: /******************************Public*Routine******************************\
549: * VOID vCatchTwoPass(pstrip, pls, plStripEnd)
550: *
551: * Handles ROPs that cannot be done in a single pass using the VGA
552: * hardware. In order not to have a check in our main drawing loop for
553: * two-pass ROPs, we change the strip function table so that this function
554: * intercepts the call to draw the strips.
555: *
556: * This routine then figures out the appropriate actual strip drawer, and
557: * makes two calls to it: first to invert the destination, then to do the
558: * rest of the ROP.
559: *
560: \**************************************************************************/
561:
562: VOID vCatchTwoPass(STRIP* pstrip, LINESTATE* pls, LONG* plStripEnd)
563: {
564: BYTE* pjScreen = pstrip->pjScreen;
565: BYTE jBitMask = pstrip->jBitMask;
566: BYTE jStyleMask = pstrip->jStyleMask;
567: STYLEPOS* psp = pstrip->psp;
568: STYLEPOS spRemaining = pstrip->spRemaining;
569:
570: // Figure out the actual strip routine we're supposed to call:
571:
572: PFNSTRIP pfn = pls->apfnStrip[(pstrip->flFlips & FL_STRIP_MASK) >>
573: FL_STRIP_SHIFT];
574:
575: // On the first pass, we invert the destination:
576:
577: vSetStrips(0xff, DR_XOR);
578:
579: (*pfn)(pstrip, pls, plStripEnd);
580:
581: // We reset our strip variables for the second pass and handle the rest
582: // of the ROP:
583:
584: pstrip->pjScreen = pjScreen;
585: pstrip->jBitMask = jBitMask;
586: pstrip->jStyleMask = jStyleMask;
587: pstrip->psp = psp;
588: pstrip->spRemaining = spRemaining;
589:
590: vSetStrips(pls->iColor, pls->ulVgaMode);
591:
592: (*pfn)(pstrip, pls, plStripEnd);
593: }
594:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.