![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mfbwindow.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 mfbwindow.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mfb |
1.1 root 1: /* $Header: mfbwindow.c,v 1.2 87/09/03 13:48:44 toddb Exp $ */
2: /***********************************************************
3: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
4: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
5:
6: All Rights Reserved
7:
8: Permission to use, copy, modify, and distribute this software and its
9: documentation for any purpose and without fee is hereby granted,
10: provided that the above copyright notice appear in all copies and that
11: both that copyright notice and this permission notice appear in
12: supporting documentation, and that the names of Digital or MIT not be
13: used in advertising or publicity pertaining to distribution of the
14: software without specific, written prior permission.
15:
16: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
17: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
18: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
19: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
21: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
22: SOFTWARE.
23:
24: ******************************************************************/
25:
26: #include "X.h"
27: #include "scrnintstr.h"
28: #include "windowstr.h"
29: #include "mfb.h"
30: #include "mistruct.h"
31: #include "regionstr.h"
32:
33: extern WindowRec WindowTable[];
34:
35: Bool mfbCreateWindow(pWin)
36: register WindowPtr pWin;
37: {
38: register mfbPrivWin *pPrivWin;
39:
40: pWin->ClearToBackground = miClearToBackground;
41: pWin->PaintWindowBackground = mfbPaintWindowNone;
42: pWin->PaintWindowBorder = mfbPaintWindowPR;
43:
44: pWin->CopyWindow = mfbCopyWindow;
45: if(!(pPrivWin = (mfbPrivWin *)Xalloc(sizeof(mfbPrivWin))))
46: return (FALSE);
47: pWin->devPrivate = (pointer)pPrivWin;
48: pPrivWin->pRotatedBorder = NullPixmap;
49: pPrivWin->pRotatedBackground = NullPixmap;
50: pPrivWin->fastBackground = 0;
51: pPrivWin->fastBorder = 0;
52:
53: /* backing store stuff
54: is this ever called with backing store turned on ???
55: */
56: if ((pWin->backingStore == WhenMapped) ||
57: (pWin->backingStore == Always))
58: {
59: }
60: else
61: {
62: }
63: return (TRUE);
64: }
65:
66: /* This always returns true, because Xfree can't fail. It might be possible
67: * on some devices for Destroy to fail */
68: Bool
69: mfbDestroyWindow(pWin)
70: WindowPtr pWin;
71: {
72: register mfbPrivWin *pPrivWin;
73:
74: pPrivWin = (mfbPrivWin *)(pWin->devPrivate);
75:
76: /* mfbDestroyPixmap() deals with any NULL pointers */
77: mfbDestroyPixmap(pPrivWin->pRotatedBorder);
78: mfbDestroyPixmap(pPrivWin->pRotatedBackground);
79: Xfree(pWin->devPrivate);
80: return (TRUE);
81: }
82:
83: Bool mfbMapWindow(pWindow)
84: WindowPtr pWindow;
85: {
86: return (TRUE);
87: }
88:
89: /* (x, y) is the upper left corner of the window on the screen
90: do we really need to pass this? (is it a;ready in pWin->absCorner?)
91: we only do the rotation for pixmaps that are 32 bits wide (padded
92: or otherwise.)
93: mfbChangeWindowAttributes() has already put a copy of the pixmap
94: in pPrivWin->pRotated*
95: */
96:
97: Bool
98: mfbPositionWindow(pWin, x, y)
99: register WindowPtr pWin;
100: int x, y;
101: {
102: register mfbPrivWin *pPrivWin;
103:
104: pPrivWin = (mfbPrivWin *)(pWin->devPrivate);
105: if (IS_VALID_PIXMAP(pWin->backgroundTile) &&
106: (pPrivWin->fastBackground != 0))
107: {
108: mfbXRotatePixmap(pPrivWin->pRotatedBackground,
109: pWin->absCorner.x - pPrivWin->oldRotate.x);
110: mfbYRotatePixmap(pPrivWin->pRotatedBackground,
111: pWin->absCorner.y - pPrivWin->oldRotate.y);
112: }
113:
114: if (IS_VALID_PIXMAP(pWin->borderTile) &&
115: (pPrivWin->fastBorder != 0))
116: {
117: mfbXRotatePixmap(pPrivWin->pRotatedBorder,
118: pWin->absCorner.x - pPrivWin->oldRotate.x);
119: mfbYRotatePixmap(pPrivWin->pRotatedBorder,
120: pWin->absCorner.y - pPrivWin->oldRotate.y);
121: }
122: if ( (IS_VALID_PIXMAP(pWin->borderTile) &&
123: (pPrivWin->fastBorder != 0))
124: ||
125: (IS_VALID_PIXMAP(pWin->backgroundTile) &&
126: (pPrivWin->fastBackground != 0)))
127: {
128: pPrivWin->oldRotate.x = pWin->absCorner.x;
129: pPrivWin->oldRotate.y = pWin->absCorner.y;
130: }
131: /* Again, we have no failure modes indicated by any of the routines
132: * we've called, so we have to assume it worked */
133: return (TRUE);
134: }
135:
136: Bool
137: mfbUnmapWindow(pWindow, x, y)
138: WindowPtr pWindow;
139: int x, y;
140: {
141: return (TRUE);
142: }
143:
144: /* UNCLEAN!
145: this code calls the bitblt helper code directly.
146:
147: mfbCopyWindow copies only the parts of the destination that are
148: visible in the source.
149: */
150:
151:
152: void
153: mfbCopyWindow(pWin, ptOldOrg, prgnSrc)
154: WindowPtr pWin;
155: DDXPointRec ptOldOrg;
156: RegionPtr prgnSrc;
157: {
158: DDXPointPtr pptSrc;
159: register DDXPointPtr ppt;
160: RegionPtr prgnDst;
161: register BoxPtr pbox;
162: register int dx, dy;
163: register int i, nbox;
164: WindowPtr pwinRoot;
165:
166: pwinRoot = &WindowTable[pWin->drawable.pScreen->myNum];
167:
168: prgnDst = (* pWin->drawable.pScreen->RegionCreate)(NULL,
169: pWin->borderClip->numRects);
170:
171: dx = ptOldOrg.x - pWin->absCorner.x;
172: dy = ptOldOrg.y - pWin->absCorner.y;
173: (* pWin->drawable.pScreen->TranslateRegion)(prgnSrc, -dx, -dy);
174: (* pWin->drawable.pScreen->Intersect)(prgnDst, pWin->borderClip, prgnSrc);
175:
176: pbox = prgnDst->rects;
177: nbox = prgnDst->numRects;
178: if(!(pptSrc = (DDXPointPtr )ALLOCATE_LOCAL( prgnDst->numRects *
179: sizeof(DDXPointRec))))
180: return;
181: ppt = pptSrc;
182:
183: for (i=0; i<nbox; i++, ppt++, pbox++)
184: {
185: ppt->x = pbox->x1 + dx;
186: ppt->y = pbox->y1 + dy;
187: }
188:
189: mfbDoBitblt(pwinRoot, pwinRoot, GXcopy, prgnDst, pptSrc);
190: DEALLOCATE_LOCAL(pptSrc);
191: (* pWin->drawable.pScreen->RegionDestroy)(prgnDst);
192: }
193:
194:
195:
196: /* swap in correct PaintWindow* routine. If we can use a fast output
197: routine (i.e. the pixmap is paddable to 32 bits), also pre-rotate a copy
198: of it in devPrivate.
199: */
200: Bool
201: mfbChangeWindowAttributes(pWin, mask)
202: register WindowPtr pWin;
203: register int mask;
204: {
205: register int index;
206: register mfbPrivWin *pPrivWin;
207:
208: pPrivWin = (mfbPrivWin *)(pWin->devPrivate);
209: while(mask)
210: {
211: index = ffs(mask) -1;
212: mask &= ~(index = 1 << index);
213: switch(index)
214: {
215: case CWBackingStore:
216: /*
217: if ((pWin->backingStore == WhenMapped) ||
218: (pWin->backingStore == Always))
219: {
220: }
221: else
222: {
223: }
224: */
225: break;
226:
227: case CWBackPixmap:
228: switch((int)pWin->backgroundTile)
229: {
230: case None:
231: pWin->PaintWindowBackground = mfbPaintWindowNone;
232: pPrivWin->fastBackground = 0;
233: break;
234: case ParentRelative:
235: pWin->PaintWindowBackground = mfbPaintWindowPR;
236: pPrivWin->fastBackground = 0;
237: break;
238: case USE_BACKGROUND_PIXEL:
239: pWin->PaintWindowBackground = mfbPaintWindowSolid;
240: pPrivWin->fastBackground = 0;
241: break;
242: default:
243: if(mfbPadPixmap(pWin->backgroundTile))
244: {
245: pPrivWin->fastBackground = 1;
246: pPrivWin->oldRotate.x = pWin->absCorner.x;
247: pPrivWin->oldRotate.y = pWin->absCorner.y;
248: if (pPrivWin->pRotatedBackground)
249: mfbDestroyPixmap(pPrivWin->pRotatedBackground);
250: pPrivWin->pRotatedBackground =
251: mfbCopyPixmap(pWin->backgroundTile);
252: mfbXRotatePixmap(pPrivWin->pRotatedBackground,
253: pWin->absCorner.x);
254: mfbYRotatePixmap(pPrivWin->pRotatedBackground,
255: pWin->absCorner.y);
256: pWin->PaintWindowBackground = mfbPaintWindow32;
257: }
258: else
259: {
260: pPrivWin->fastBackground = 0;
261: pWin->PaintWindowBackground = miPaintWindow;
262: }
263: break;
264: }
265: break;
266:
267: case CWBackPixel:
268: pWin->PaintWindowBackground = mfbPaintWindowSolid;
269: pPrivWin->fastBackground = 0;
270: break;
271:
272: case CWBorderPixmap:
273: switch((int)pWin->borderTile)
274: {
275: case None:
276: pWin->PaintWindowBorder = mfbPaintWindowNone;
277: pPrivWin->fastBorder = 0;
278: break;
279: case ParentRelative:
280: pWin->PaintWindowBorder = mfbPaintWindowPR;
281: pPrivWin->fastBorder = 0;
282: break;
283: case USE_BORDER_PIXEL:
284: pWin->PaintWindowBorder = mfbPaintWindowSolid;
285: pPrivWin->fastBorder = 0;
286: break;
287: default:
288: if(mfbPadPixmap(pWin->borderTile))
289: {
290: pPrivWin->fastBorder = 1;
291: pPrivWin->oldRotate.x = pWin->absCorner.x;
292: pPrivWin->oldRotate.y = pWin->absCorner.y;
293: if (pPrivWin->pRotatedBorder)
294: mfbDestroyPixmap(pPrivWin->pRotatedBorder);
295: pPrivWin->pRotatedBorder =
296: mfbCopyPixmap(pWin->borderTile);
297: mfbXRotatePixmap(pPrivWin->pRotatedBorder,
298: pWin->absCorner.x);
299: mfbYRotatePixmap(pPrivWin->pRotatedBorder,
300: pWin->absCorner.y);
301: pWin->PaintWindowBorder = mfbPaintWindow32;
302: }
303: else
304: {
305: pPrivWin->fastBorder = 0;
306: pWin->PaintWindowBorder = miPaintWindow;
307: }
308: break;
309: }
310: break;
311: case CWBorderPixel:
312: pWin->PaintWindowBorder = mfbPaintWindowSolid;
313: pPrivWin->fastBorder = 0;
314: break;
315:
316: }
317: }
318: /* Again, we have no failure modes indicated by any of the routines
319: * we've called, so we have to assume it worked */
320: return (TRUE);
321: }
322:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.