![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bankmgr.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 bankmgr.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256 |
1.1 root 1: /*****************************************************************************\
2: * Smart 256 Colour Bank Manager
3: *
4: * Copyright (c) 1992 Microsoft Corporation
5: \*****************************************************************************/
6:
7: #include "driver.h"
8:
9: /*****************************************************************************\
10: * pcoBankStart - Start the bank enumeration using the clip object.
11: *
12: * Used when the destination is the screen and we can't do the clipping
13: * ourselves (as we can for blt's).
14: \*****************************************************************************/
15:
16: CLIPOBJ* pcoBankStart(
17: PPDEV ppdev,
18: RECTL* prclScans,
19: SURFOBJ* pso,
20: CLIPOBJ* pco)
21: {
22: LONG iTopScan = max(0, prclScans->top);
23:
24: // Adjust for those weird cases where we're asked to start enumerating
25: // below the bottom of the screen:
26:
27: iTopScan = min(iTopScan, (LONG) ppdev->cyScreen - 1);
28:
29: // Map in the bank:
30:
31: if (iTopScan < ppdev->rcl1WindowClip.top ||
32: iTopScan >= ppdev->rcl1WindowClip.bottom)
33: {
34: ppdev->pfnBankControl(ppdev, iTopScan, JustifyTop);
35: }
36:
37: // Remember what the last scan is that we're going to, and
38: // make sure we only try to go as far as we need to. It could
39: // happen that when get a prclScans bigger than the screen:
40:
41: ppdev->iLastScan = min(prclScans->bottom, (LONG) ppdev->cyScreen);
42:
43: pso->pvScan0 = ppdev->pvBitmapStart;
44:
45: if (pco == NULL)
46: {
47: // The call may have come down to us as having no clipping, but
48: // we have to clip to the banks, so use our own clip object:
49:
50: pco = ppdev->pcoNull;
51: pco->rclBounds = ppdev->rcl1WindowClip;
52: }
53: else
54: {
55: // Save the engine's clip object data that we'll be tromping on:
56:
57: ppdev->rclSaveBounds = pco->rclBounds;
58: ppdev->iSaveDComplexity = pco->iDComplexity;
59: ppdev->fjSaveOptions = pco->fjOptions;
60:
61: // Let engine know it has to pay attention to the rclBounds of the
62: // clip object:
63:
64: pco->fjOptions |= OC_BANK_CLIP;
65:
66: if (pco->iDComplexity == DC_TRIVIAL)
67: pco->iDComplexity = DC_RECT;
68:
69: // Use the bank bounds if they are tighter than the existing
70: // bounds. We don't have to check the left case here because we
71: // know that ppdev->rcl1WindowClip.left == 0.
72:
73: if (pco->rclBounds.top <= ppdev->rcl1WindowClip.top)
74: pco->rclBounds.top = ppdev->rcl1WindowClip.top;
75:
76: if (pco->rclBounds.right >= ppdev->rcl1WindowClip.right)
77: pco->rclBounds.right = ppdev->rcl1WindowClip.right;
78:
79: if (pco->rclBounds.bottom >= ppdev->rcl1WindowClip.bottom)
80: pco->rclBounds.bottom = ppdev->rcl1WindowClip.bottom;
81: }
82:
83: return(pco);
84: }
85:
86: /*****************************************************************************\
87: * bBankEnum - Continue the bank enumeration.
88: \*****************************************************************************/
89:
90: BOOL bBankEnum(PPDEV ppdev, SURFOBJ* pso, CLIPOBJ* pco)
91: {
92: // If we're on the first portion of a broken raster, get the next:
93:
94: LONG yNewTop = ppdev->rcl1WindowClip.bottom;
95:
96: if (ppdev->flBank & BANK_BROKEN_RASTER1)
97: ppdev->pfnBankNext(ppdev);
98:
99: else if (ppdev->rcl1WindowClip.bottom < ppdev->iLastScan)
100: ppdev->pfnBankControl(ppdev, yNewTop, JustifyTop);
101:
102: else
103: {
104: // Okay, that was the last bank, so restore our structures:
105:
106: if (pco != ppdev->pcoNull)
107: {
108: pco->rclBounds = ppdev->rclSaveBounds;
109: pco->iDComplexity = ppdev->iSaveDComplexity;
110: pco->fjOptions = ppdev->fjSaveOptions;
111: }
112:
113: return(FALSE);
114: }
115:
116: // Adjust the pvScan0 because we've moved the window to view
117: // a different area:
118:
119: pso->pvScan0 = ppdev->pvBitmapStart;
120:
121: if (pco == ppdev->pcoNull)
122: {
123: // If were given a NULL clip object originally, we don't have
124: // to worry about clipping to ppdev->rclSaveBounds:
125:
126: pco->rclBounds.top = yNewTop;
127: pco->rclBounds.left = ppdev->rcl1WindowClip.left;
128: pco->rclBounds.bottom = ppdev->rcl1WindowClip.bottom;
129: pco->rclBounds.right = ppdev->rcl1WindowClip.right;
130: }
131: else
132: {
133: // Use the bank bounds if they are tighter than the bounds
134: // we were originally given:
135:
136: pco->rclBounds = ppdev->rclSaveBounds;
137:
138: if (pco->rclBounds.top <= yNewTop)
139: pco->rclBounds.top = yNewTop;
140:
141: if (pco->rclBounds.left <= ppdev->rcl1WindowClip.left)
142: pco->rclBounds.left = ppdev->rcl1WindowClip.left;
143:
144: if (pco->rclBounds.right >= ppdev->rcl1WindowClip.right)
145: pco->rclBounds.right = ppdev->rcl1WindowClip.right;
146:
147: if (pco->rclBounds.bottom >= ppdev->rcl1WindowClip.bottom)
148: pco->rclBounds.bottom = ppdev->rcl1WindowClip.bottom;
149: }
150:
151: return(TRUE);
152: }
153:
154: /***************************************************************************\
155: * vBankStartBltSrc - Start the bank enumeration for when the screen is
156: * the source.
157: \***************************************************************************/
158:
159: VOID vBankStartBltSrc(
160: PPDEV ppdev,
161: SURFOBJ* pso,
162: POINTL* pptlSrc,
163: RECTL* prclDest,
164: POINTL* pptlNewSrc,
165: RECTL* prclNewDest)
166: {
167: LONG xRightSrc;
168: LONG yBottomSrc;
169: LONG iTopScan = max(0, pptlSrc->y);
170:
171: if (iTopScan >= (LONG) ppdev->cyScreen)
172: {
173: // In some instances we may be asked to start on a scan below the screen.
174: // Since we obviously won't be drawing anything, don't bother mapping in
175: // a bank:
176:
177: return;
178: }
179:
180: // Map in the bank:
181:
182: if (iTopScan < ppdev->rcl1WindowClip.top ||
183: iTopScan >= ppdev->rcl1WindowClip.bottom)
184: {
185: ppdev->pfnBankControl(ppdev, iTopScan, JustifyTop);
186: }
187:
188: if (ppdev->rcl1WindowClip.right <= pptlSrc->x)
189: {
190: // We have to watch out for those rare cases where we're starting
191: // on a broken raster and we won't be drawing on the first part:
192:
193: ASSERTVGA(ppdev->flBank & BANK_BROKEN_RASTER1, "Weird start bounds");
194:
195: ppdev->pfnBankNext(ppdev);
196: }
197:
198: pso->pvScan0 = ppdev->pvBitmapStart;
199:
200: // Adjust the source:
201:
202: pptlNewSrc->x = pptlSrc->x;
203: pptlNewSrc->y = pptlSrc->y;
204:
205: // Adjust the destination:
206:
207: prclNewDest->left = prclDest->left;
208: prclNewDest->top = prclDest->top;
209:
210: yBottomSrc = pptlSrc->y + prclDest->bottom - prclDest->top;
211: prclNewDest->bottom = min(ppdev->rcl1WindowClip.bottom, yBottomSrc);
212: prclNewDest->bottom += prclDest->top - pptlSrc->y;
213:
214: xRightSrc = pptlSrc->x + prclDest->right - prclDest->left;
215: prclNewDest->right = min(ppdev->rcl1WindowClip.right, xRightSrc);
216: prclNewDest->right += prclDest->left - pptlSrc->x;
217: }
218:
219: /***************************************************************************\
220: * bBankEnumBltSrc - Continue the bank enumeration for when the screen is
221: * the source.
222: \***************************************************************************/
223:
224: BOOL bBankEnumBltSrc(
225: PPDEV ppdev,
226: SURFOBJ* pso,
227: POINTL* pptlSrc,
228: RECTL* prclDest,
229: POINTL* pptlNewSrc,
230: RECTL* prclNewDest)
231: {
232: LONG xLeftSrc;
233: LONG xRightSrc;
234: LONG yBottomSrc;
235:
236: LONG cx = prclDest->right - prclDest->left;
237: LONG cy = prclDest->bottom - prclDest->top;
238:
239: LONG dx;
240: LONG dy;
241:
242: LONG yBottom = min(pptlSrc->y + cy, (LONG) ppdev->cyScreen);
243: LONG yNewTop = ppdev->rcl1WindowClip.bottom;
244:
245: if (ppdev->flBank & BANK_BROKEN_RASTER1)
246: {
247: ppdev->pfnBankNext(ppdev);
248: if (ppdev->rcl1WindowClip.left >= pptlSrc->x + cx)
249: {
250: if (ppdev->rcl1WindowClip.bottom < yBottom)
251: ppdev->pfnBankNext(ppdev);
252: else
253: {
254: // We're done:
255:
256: return(FALSE);
257: }
258: }
259: }
260: else if (yNewTop < yBottom)
261: {
262: ppdev->pfnBankControl(ppdev, yNewTop, JustifyTop);
263: if (ppdev->rcl1WindowClip.right <= pptlSrc->x)
264: {
265: ASSERTVGA(ppdev->flBank & BANK_BROKEN_RASTER1, "Weird bounds");
266: ppdev->pfnBankNext(ppdev);
267: }
268: }
269: else
270: {
271: // We're done:
272:
273: return(FALSE);
274: }
275:
276: // Adjust the source:
277:
278: pso->pvScan0 = ppdev->pvBitmapStart;
279:
280: pptlNewSrc->x = max(ppdev->rcl1WindowClip.left, pptlSrc->x);
281: pptlNewSrc->y = yNewTop;
282:
283: // Adjust the destination:
284:
285: dy = prclDest->top - pptlSrc->y; // y delta from source to dest
286:
287: prclNewDest->top = yNewTop + dy;
288:
289: yBottomSrc = pptlSrc->y + cy;
290: prclNewDest->bottom = min(ppdev->rcl1WindowClip.bottom, yBottomSrc) + dy;
291:
292: dx = prclDest->left - pptlSrc->x; // x delta from source to dest
293:
294: xLeftSrc = pptlSrc->x;
295: prclNewDest->left = pptlNewSrc->x + dx;
296:
297: xRightSrc = pptlSrc->x + cx;
298: prclNewDest->right = min(ppdev->rcl1WindowClip.right, xRightSrc) + dx;
299:
300: return(TRUE);
301: }
302:
303: /***************************************************************************\
304: * vBankStartBltDest - Start the bank enumeration for when the screen is
305: * the destination.
306: \***************************************************************************/
307:
308: VOID vBankStartBltDest(
309: PPDEV ppdev,
310: SURFOBJ* pso,
311: POINTL* pptlSrc,
312: RECTL* prclDest,
313: POINTL* pptlNewSrc,
314: RECTL* prclNewDest)
315: {
316: LONG iTopScan = max(0, prclDest->top);
317:
318: if (iTopScan >= (LONG) ppdev->cyScreen)
319: {
320: // In some instances we may be asked to start on a scan below the screen.
321: // Since we obviously won't be drawing anything, don't bother mapping in
322: // a bank:
323:
324: return;
325: }
326:
327: // Map in the bank:
328:
329: if (iTopScan < ppdev->rcl1WindowClip.top ||
330: iTopScan >= ppdev->rcl1WindowClip.bottom)
331: {
332: ppdev->pfnBankControl(ppdev, iTopScan, JustifyTop);
333: }
334:
335: if (ppdev->rcl1WindowClip.right <= prclDest->left)
336: {
337: // We have to watch out for those rare cases where we're starting
338: // on a broken raster and we won't be drawing on the first part:
339:
340: ASSERTVGA(ppdev->flBank & BANK_BROKEN_RASTER1, "Weird start bounds");
341: ppdev->pfnBankNext(ppdev);
342: }
343:
344: pso->pvScan0 = ppdev->pvBitmapStart;
345:
346: // Adjust the destination:
347:
348: prclNewDest->left = prclDest->left;
349: prclNewDest->top = prclDest->top;
350: prclNewDest->bottom = min(ppdev->rcl1WindowClip.bottom, prclDest->bottom);
351: prclNewDest->right = min(ppdev->rcl1WindowClip.right, prclDest->right);
352:
353: // Adjust the source if there is one:
354:
355: if (pptlSrc != NULL)
356: *pptlNewSrc = *pptlSrc;
357: }
358:
359: /***************************************************************************\
360: * bBankEnumBltDest - Continue the bank enumeration for when the screen is
361: * the destination.
362: \***************************************************************************/
363:
364: BOOL bBankEnumBltDest(
365: PPDEV ppdev,
366: SURFOBJ* pso,
367: POINTL* pptlSrc,
368: RECTL* prclDest,
369: POINTL* pptlNewSrc,
370: RECTL* prclNewDest)
371: {
372: LONG yBottom = min(prclDest->bottom, (LONG) ppdev->cyScreen);
373: LONG yNewTop = ppdev->rcl1WindowClip.bottom;
374:
375: if (ppdev->flBank & BANK_BROKEN_RASTER1)
376: {
377: ppdev->pfnBankNext(ppdev);
378: if (ppdev->rcl1WindowClip.left >= prclDest->right)
379: {
380: if (ppdev->rcl1WindowClip.bottom < yBottom)
381: ppdev->pfnBankNext(ppdev);
382: else
383: {
384: // We're done:
385:
386: return(FALSE);
387: }
388: }
389: }
390: else if (yNewTop < yBottom)
391: {
392: ppdev->pfnBankControl(ppdev, yNewTop, JustifyTop);
393: if (ppdev->rcl1WindowClip.right <= prclDest->left)
394: {
395: ASSERTVGA(ppdev->flBank & BANK_BROKEN_RASTER1, "Weird bounds");
396: ppdev->pfnBankNext(ppdev);
397: }
398: }
399: else
400: {
401: // We're done:
402:
403: return(FALSE);
404: }
405:
406: pso->pvScan0 = ppdev->pvBitmapStart;
407:
408: // Adjust the destination:
409:
410: prclNewDest->top = yNewTop;
411: prclNewDest->left = max(ppdev->rcl1WindowClip.left, prclDest->left);
412: prclNewDest->bottom = min(ppdev->rcl1WindowClip.bottom, prclDest->bottom);
413: prclNewDest->right = min(ppdev->rcl1WindowClip.right, prclDest->right);
414:
415: // Adjust the source if there is one:
416:
417: if (pptlSrc != NULL)
418: {
419: pptlNewSrc->x = pptlSrc->x + (prclNewDest->left - prclDest->left);
420: pptlNewSrc->y = pptlSrc->y + (prclNewDest->top - prclDest->top);
421: }
422:
423: return(TRUE);
424: }
425:
426:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.