![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to brush.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / print / pscript|
Return to brush.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 root 1: //--------------------------------------------------------------------------
2: //
3: // Module Name: BRUSH.C
4: //
5: // Brief Description: This module contains the PSCRIPT driver's brush
6: // realization routines.
7: //
8: // Author: Kent Settle (kentse)
9: // Created: 13-Dec-1990
10: //
11: // Copyright (c) 1990 - 1992 Microsoft Corporation
12: //
13: //--------------------------------------------------------------------------
14:
15: #include "pscript.h"
16: #include "enable.h"
17:
18: #ifdef INDEX_PAL
19: #define RGBMASK 0x00FFFFFF
20: #endif
21:
22: //--------------------------------------------------------------------------
23: //
24: // BOOL DrvRealizeBrush(pbo, psoTarget, psoPattern, psoMask, pxlo)
25: // BRUSHOBJ *pbo;
26: // SURFOBJ *psoTarget;
27: // SURFOBJ *psoPattern;
28: // SURFOBJ *psoMask;
29: // XLATEOBJ *pxlo;
30: //
31: // Requests the driver to realize a pattern defined by psoPattern for
32: // the surface defined by psoTarget. A realized brush contains the
33: // information and accelerators the driver needs to fill an area with
34: // a pattern. This information is defined by the driver and used only
35: // by the driver. The driver's realization of the brush should be
36: // written into the buffer allocated by calling BRUSHOBJ_pvAllocRBrush.
37: //
38: // This function is required for a driver that does any drawing to any
39: // surface.
40: //
41: // Parameters:
42: // pbo:
43: // Points to the BRUSHOBJ which is being realized. All the other
44: // parameters, except for psoTarget, can actually be queried from
45: // this object. We provide them as an optimization. pbo is best used
46: // only as a parameter for BRUSHOBJ_pvAllocRBrush, which allocates
47: // the memory for the realized brush.
48: //
49: // psoTarget:
50: // The object for the surface the brush is to be realized for. This
51: // surface will either be the physical surface for the device, or a
52: // device format bitmap.
53: //
54: // psoPattern:
55: // The surface describing the pattern for the brush. For a raster
56: // device this will always represent a bitmap. For a vector device
57: // this will always be one of the pattern surfaces returned by
58: // DrvEnablePDEV.
59: //
60: // psoMask:
61: // If this argument is not NULL, it provides a transparency mask for
62: // the brush. This is a one bit per pel bitmap having the same
63: // extent as the pattern. A mask bit of zero means that the pel is
64: // considered a background pel for the brush (In transparent
65: // background mode, the background pels would be left unaffected in a
66: // fill.)
67: //
68: // Plotters can ignore this argument as they are never expected to draw
69: // background information.
70: //
71: // pxlo:
72: // An XLATEOBJ which tells how to interpret the colors in the pattern.
73: // An XLATEOBJ service routine can be called to translate the colors to
74: // device color indices. Vector devices should translate color 0
75: // through the XLATEOBJ to get the foreground color for the brush.
76: //
77: // Returns:
78: // TRUE if the brush was successfully realized. Otherwise, FALSE
79: // and an error code is logged.
80: //
81: // History:
82: // 13-Dec-1990 -by- Kent Settle (kentse)
83: // Wrote it.
84: //
85: // 16-Feb-1993 Tue 12:28:06 updated -by- Daniel Chou (danielc)
86: // Re-write so it takc iHatch rather go through the suface handle to
87: // check what type of pattern.
88: //--------------------------------------------------------------------------
89:
90: BOOL DrvRealizeBrush(pbo, psoTarget, psoPattern, psoMask, pxlo, iHatch)
91: BRUSHOBJ *pbo;
92: SURFOBJ *psoTarget;
93: SURFOBJ *psoPattern;
94: SURFOBJ *psoMask;
95: XLATEOBJ *pxlo;
96: ULONG iHatch;
97: {
98: ULONG cbTotal, cbBits, cbColorTable;
99: PBYTE pbSrc, pbTarg;
100: DEVBRUSH *pBrush;
101: PDEVDATA pdev;
102: #ifdef INDEX_PAL
103: BOOL bDitherColor;
104: #endif
105:
106: UNREFERENCED_PARAMETER(psoMask);
107:
108: // get the pointer to our DEVDATA structure and make sure it is ours.
109:
110: pdev = (PDEVDATA) psoTarget->dhpdev;
111:
112: if (bValidatePDEV(pdev) == FALSE)
113: {
114: RIP("PSCRIPT!DrvRealizeBrush: invalid pdev.\n");
115: SetLastError(ERROR_INVALID_PARAMETER);
116: return(FALSE);
117: }
118:
119: #ifdef INDEX_PAL
120: // see if this is just a solid color to realize.
121:
122: bDitherColor = FALSE;
123:
124: if (iHatch & RB_DITHERCOLOR)
125: {
126: bDitherColor = TRUE;
127: cbBits = 0;
128: }
129: else if (iHatch >= HS_DDI_MAX)
130: #else
131: if (iHatch >= HS_DDI_MAX)
132: #endif
133: {
134: // we have a bitmap for the pattern.
135: // determine the size of the bitmap, remembering that the
136: // bitmaps are DWORD (32 bit) bounded.
137:
138: // how many pels per scanline?
139:
140: cbBits = psoPattern->sizlBitmap.cx;
141:
142: // times how many bits per pel.
143:
144: switch (psoPattern->iBitmapFormat)
145: {
146: case BMF_1BPP:
147: break;
148:
149: case BMF_4BPP:
150: cbBits *= 4;
151: break;
152:
153: case BMF_8BPP:
154: cbBits *= 8;
155: break;
156:
157: case BMF_16BPP:
158: cbBits *= 16;
159: break;
160:
161: case BMF_24BPP:
162: cbBits *= 24;
163: break;
164:
165: case BMF_32BPP:
166: cbBits *= 32;
167: break;
168: }
169:
170: // cbBits now equals the number of bits per scanline.
171: // convert it to the number of bytes per scanline, taking into
172: // account that scanlines are padded out to 32 bit boundaries.
173:
174: cbBits = (((cbBits + 31) / 32) * 4);
175:
176: // now that we have the number of bytes per scanline, get the
177: // total number of bytes.
178:
179: cbBits *= psoPattern->sizlBitmap.cy;
180: }
181: else
182: {
183: // we have one of the predefined patterns.
184:
185: cbBits = 0;
186: }
187:
188: // leave room for the color table.
189:
190: #ifdef INDEX_PAL
191: if (bDitherColor)
192: cbColorTable = 0;
193: else
194: #endif
195: cbColorTable = (pxlo->cEntries * sizeof(ULONG));
196:
197: // allocate new brush.
198:
199: cbTotal = sizeof(DEVBRUSH) + cbBits + cbColorTable;
200: pBrush = BRUSHOBJ_pvAllocRbrush(pbo, cbTotal);
201:
202: if (!pBrush)
203: {
204: RIP("PSCRIPT!DrvRealizeBrush: brush allocation failed.\n");
205: return(FALSE);
206: }
207:
208: // fill in the DEVBRUSH information.
209:
210: #ifdef INDEX_PAL
211: if (bDitherColor)
212: pBrush->iSolidColor = (iHatch & RGBMASK);
213: else
214: {
215: pBrush->iSolidColor = NOT_SOLID_COLOR;
216: pBrush->iPatIndex = iHatch;
217: pBrush->cXlate = pxlo->cEntries;
218: pBrush->offsetXlate = sizeof(DEVBRUSH) + cbBits;
219:
220: pbTarg = (PBYTE)((DEVBRUSH *)pBrush) + pBrush->offsetXlate;
221:
222: CopyMemory(pbTarg, (PBYTE)pxlo->pulXlate, cbColorTable);
223:
224: if (iHatch >= HS_DDI_MAX)
225: {
226: // we have a bitmap for the pattern. fill in the appropriate
227: // information in the DEVBRUSH, including the bitmap itself.
228:
229: pBrush->sizlBitmap = psoPattern->sizlBitmap;
230: pBrush->iFormat = (ULONG)psoPattern->iBitmapFormat;
231: pBrush->flBitmap = (FLONG)psoPattern->fjBitmap;
232:
233: // get a pointer to the pattern bits.
234:
235: pbSrc = (PBYTE) psoPattern->pvBits;
236:
237: // get a pointer to the destination in the brush.
238:
239: pbTarg = (PBYTE)((DEVBRUSH *)pBrush)->ajBits;
240:
241: // copy the bits from the pattern surface to the brush.
242:
243: memcpy(pbTarg, pbSrc, cbBits);
244: }
245: }
246: #else
247: pBrush->iPatIndex = iHatch;
248: pBrush->cXlate = pxlo->cEntries;
249: pBrush->offsetXlate = sizeof(DEVBRUSH) + cbBits;
250:
251: pbTarg = (PBYTE)((DEVBRUSH *)pBrush) + pBrush->offsetXlate;
252:
253: CopyMemory(pbTarg, (PBYTE)pxlo->pulXlate, cbColorTable);
254:
255: if (iHatch >= HS_DDI_MAX)
256: {
257: // we have a bitmap for the pattern. fill in the appropriate
258: // information in the DEVBRUSH, including the bitmap itself.
259:
260: pBrush->sizlBitmap = psoPattern->sizlBitmap;
261: pBrush->iFormat = (ULONG)psoPattern->iBitmapFormat;
262: pBrush->flBitmap = (FLONG)psoPattern->fjBitmap;
263:
264: // get a pointer to the pattern bits.
265:
266: pbSrc = (PBYTE) psoPattern->pvBits;
267:
268: // get a pointer to the destination in the brush.
269:
270: pbTarg = (PBYTE)((DEVBRUSH *)pBrush)->ajBits;
271:
272: // copy the bits from the pattern surface to the brush.
273:
274: memcpy(pbTarg, pbSrc, cbBits);
275: }
276: #endif
277: // set the pointer to our brush in the BRUSHOBJ. REMEMBER,
278: // the engine will take care of discarding this memory, so
279: // we don't have to.
280:
281: pbo->pvRbrush = (PVOID)pBrush;
282:
283: return(TRUE);
284: }
285:
286: #ifdef INDEX_PAL
287: //--------------------------------------------------------------------------
288: // ULONG DrvDitherColor(dhpdev, iMode, rgb, pul)
289: // DHPDEV dhpdev;
290: // ULONG iMode;
291: // ULONG rgb;
292: // ULONG *pul;
293: //
294: // Returns:
295: // DCR_HALFTONE - tells the engine to halftone a brush for me.
296: //
297: // History:
298: // 31-May-1993 -by- Kent Settle (kentse)
299: // Wrote it.
300: //--------------------------------------------------------------------------
301:
302: ULONG DrvDitherColor(dhpdev, iMode, rgb, pul)
303: DHPDEV dhpdev;
304: ULONG iMode;
305: ULONG rgb;
306: ULONG *pul;
307: {
308: return(DCR_HALFTONE);
309: }
310: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.