![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mivaltree.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 / mi|
Return to mivaltree.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mi |
1.1 root 1: /*
2: * mivaltree.c --
3: * Functions for recalculating window clip lists. Main function
4: * is miValidateTree.
5: *
6: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
7: * and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
8: *
9: * All Rights Reserved
10: *
11: * Permission to use, copy, modify, and distribute this software and its
12: * documentation for any purpose and without fee is hereby granted,
13: * provided that the above copyright notice appear in all copies and that
14: * both that copyright notice and this permission notice appear in
15: * supporting documentation, and that the names of Digital or MIT not be
16: * used in advertising or publicity pertaining to distribution of the
17: * software without specific, written prior permission.
18: *
19: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
20: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
21: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
22: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
23: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
24: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
25: * SOFTWARE.
26: *
27: ******************************************************************/
28:
29: /*
30: * Aug '86: Susan Angebranndt -- original code
31: * July '87: Adam de Boor -- substantially modified and commented
32: */
33:
34: #ifndef lint
35: static char rcsid[] =
36: "$Header: mivaltree.c,v 1.36 87/09/11 07:20:34 toddb Exp $ SPRITE (Berkeley)";
37: #endif lint
38:
39: #include "X.h"
40: #include "scrnintstr.h"
41: #include "windowstr.h"
42: #include "mi.h"
43: #include "region.h"
44:
45: static RegionPtr exposed = NullRegion;
46:
47: /*-
48: *-----------------------------------------------------------------------
49: * miComputeClips --
50: * Recompute the clipList, borderClip, exposed and borderExposed
51: * regions for pParent and its children. Only viewable windows are
52: * taken into account.
53: *
54: * Results:
55: * None.
56: *
57: * Side Effects:
58: * clipList, borderClip, exposed and borderExposed are altered.
59: * A VisibilityNotify event may be generated on the parent window.
60: *
61: *-----------------------------------------------------------------------
62: */
63: static void
64: miComputeClips (pParent, pScreen, universe)
65: register WindowPtr pParent;
66: register ScreenPtr pScreen;
67: register RegionPtr universe;
68: {
69: int dx,
70: dy;
71: RegionPtr childUniverse;
72: register WindowPtr pChild;
73: int oldVis;
74: BoxPtr borderSize;
75:
76:
77: childUniverse = (RegionPtr)NULL;
78:
79: /*
80: * Figure out the new visibility of this window.
81: * The extent of the universe should be the same as the extent of
82: * the borderSize region. If the window is unobscured, this rectangle
83: * will be completely inside the universe (the universe will cover it
84: * completely). If the window is completely obscured, none of the
85: * universe will cover the rectangle.
86: */
87: borderSize = (* pScreen->RegionExtents) (pParent->borderSize);
88:
89: oldVis = pParent->visibility;
90: switch ((* pScreen->RectIn) (universe, borderSize))
91: {
92: case rgnIN:
93: pParent->visibility = VisibilityUnobscured;
94: break;
95: case rgnPART:
96: pParent->visibility = VisibilityPartiallyObscured;
97: break;
98: default:
99: pParent->visibility = VisibilityFullyObscured;
100: break;
101: }
102: if (oldVis != pParent->visibility)
103: SendVisibilityNotify(pParent);
104:
105: /*
106: * To calculate exposures correctly, we have to translate the old
107: * borderClip and clipList regions to the window's new location so there
108: * is a correspondence between pieces of the new and old clipping regions.
109: */
110: dx = pParent->absCorner.x - pParent->oldAbsCorner.x;
111: dy = pParent->absCorner.y - pParent->oldAbsCorner.y;
112:
113: if (dx || dy)
114: {
115: /*
116: * If the window has moved, the border will *not* be copied, so we
117: * empty the old border clip to force exposure of the whole thing.
118: * We translate the old clipList because that will be exposed or copied
119: * if gravity is right.
120: */
121: (* pScreen->RegionEmpty) (pParent->borderClip);
122: (* pScreen->TranslateRegion) (pParent->clipList, dx, dy);
123: pParent->oldAbsCorner = pParent->absCorner;
124: }
125: else if (pParent->borderWidth)
126: {
127: /*
128: * If the window has shrunk, we have to be careful about figuring the
129: * exposure of the right and bottom borders -- they should be exposed
130: * if the window shrank on that side and they aren't being obscured
131: * by a sibling -- so we add those edges to the borderExposed region.
132: * This is all necessary because sometimes what was the internal window
133: * in the old borderClip will overlap the new border and cause the
134: * right and bottom edges of the new border not to appear in the
135: * borderExposed region and it's a royal pain to figure out what to
136: * remove from the old borderClip.
137: * XXX: Isn't there a nicer way to do this?
138: */
139: BoxPtr oldExtents;
140: BoxPtr newExtents;
141: BoxPtr windowExtents;
142:
143: oldExtents = (* pScreen->RegionExtents) (pParent->borderClip);
144: newExtents = (* pScreen->RegionExtents) (universe);
145: windowExtents = (* pScreen->RegionExtents) (pParent->borderSize);
146:
147: if ((* pScreen->RegionNotEmpty) (universe) &&
148: (* pScreen->RegionNotEmpty) (pParent->borderClip) &&
149: ((newExtents->x2 < oldExtents->x2) ||
150: (newExtents->y2 < oldExtents->y2)))
151: {
152: BoxRec borderBox;
153: RegionPtr borderRegion;
154:
155: borderRegion = (* pScreen->RegionCreate) (NULL, 1);
156:
157: if (newExtents->x2 < oldExtents->x2)
158: {
159: /*
160: * Add the right edge.
161: */
162: borderBox.x1 = windowExtents->x2 - pParent->borderWidth;
163: borderBox.y1 = windowExtents->y1;
164: borderBox.x2 = windowExtents->x2;
165: borderBox.y2 = windowExtents->y2;
166: (* pScreen->RegionReset) (borderRegion, &borderBox);
167: (* pScreen->Union) (pParent->borderExposed,
168: pParent->borderExposed,
169: borderRegion);
170: }
171: if (newExtents->y2 < oldExtents->y2)
172: {
173: /*
174: * Add the bottom edge.
175: */
176: borderBox.x1 = windowExtents->x1;
177: borderBox.y1 = windowExtents->y2 - pParent->borderWidth;
178: borderBox.x2 = windowExtents->x2;
179: borderBox.y2 = windowExtents->y2;
180: (* pScreen->RegionReset) (borderRegion, &borderBox);
181: (* pScreen->Union) (pParent->borderExposed,
182: pParent->borderExposed,
183: borderRegion);
184: }
185: (* pScreen->RegionDestroy) (borderRegion);
186:
187: /*
188: * To make sure we don't expose a border that's supposed to
189: * be clipped, clip the regions we just added to borderExposed...
190: */
191: (* pScreen->Intersect) (pParent->borderExposed, universe,
192: pParent->borderExposed);
193: }
194: }
195:
196: /*
197: * Since the borderClip must not be clipped by the children, we do
198: * the border exposure first...
199: *
200: * 'universe' is the window's borderClip. To figure the exposures, remove
201: * the area that used to be exposed (the old borderClip) from the new.
202: * This leaves a region of pieces that weren't exposed before. Border
203: * exposures accumulate until they're taken care of.
204: */
205: (* pScreen->Subtract) (exposed, universe, pParent->borderClip);
206: (* pScreen->Subtract) (exposed, exposed, pParent->winSize);
207:
208: (* pScreen->Union) (pParent->borderExposed, pParent->borderExposed,
209: exposed);
210:
211: (* pScreen->RegionCopy) (pParent->borderClip, universe);
212:
213: /*
214: * To get the right clipList for the parent, and to make doubly sure
215: * that no child overlaps the parent's border, we remove the parent's
216: * border from the universe before proceeding.
217: */
218: (* pScreen->Intersect) (universe, universe, pParent->winSize);
219:
220: for (pChild = pParent->firstChild; pChild; pChild = pChild->nextSib)
221: {
222: if (pChild->viewable)
223: {
224: /*
225: * If the child is viewable, we want to remove its extents from
226: * the current universe, but we only re-clip it if it's been
227: * marked.
228: */
229: if (pChild->marked)
230: {
231: /*
232: * Figure out the new universe from the child's perspective and
233: * recurse.
234: */
235: if (childUniverse == NullRegion)
236: {
237: childUniverse = (* pScreen->RegionCreate) (NULL, 1);
238: }
239: (* pScreen->Intersect) (childUniverse, universe,
240: pChild->borderSize);
241: miComputeClips (pChild, pScreen, childUniverse);
242: }
243: /*
244: * Once the child has been processed, we remove its extents from
245: * the current universe, thus denying its space to any other
246: * sibling.
247: */
248: (* pScreen->Subtract) (universe, universe, pChild->borderSize);
249: }
250: else
251: {
252: pChild->marked = 0;
253: if ((* pScreen->RegionNotEmpty) (pChild->borderClip))
254: {
255: /*
256: * If the child isn't viewable, it has no business taking up
257: * clipping space, so we nuke all its clipping regions. There
258: * was a problem with UnmapGravity where the clipList wouldn't
259: * get nuked, so drawing operations succeeded while the window
260: * was unmapped...
261: */
262: (* pScreen->RegionEmpty) (pChild->borderClip);
263: (* pScreen->RegionEmpty) (pChild->clipList);
264: (* pScreen->RegionEmpty) (pChild->exposed);
265: (* pScreen->RegionEmpty) (pChild->borderExposed);
266: pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;
267: }
268: }
269: }
270:
271: /*
272: * 'universe' now contains the new clipList for the parent window.
273: *
274: * To figure the exposure of the window we subtract the old clip from the
275: * new, just as for the border. Again, exposures accumulate.
276: */
277: (* pScreen->Subtract) (exposed, universe, pParent->clipList);
278:
279: (* pScreen->Union) (pParent->exposed, pParent->exposed, exposed);
280:
281: /*
282: * One last thing: backing storage. We have to find out what parts of
283: * the window are about to be obscured. We can just subtract the universe
284: * from the old clipList and get the areas that were in the old but aren't
285: * in the new and, hence, are about to be obscured.
286: */
287: if (pParent->backStorage && (pParent->backingStore != NotUseful))
288: {
289: (* pScreen->Subtract) (exposed, pParent->clipList, universe);
290: (* pScreen->Union) (pParent->backStorage->obscured,
291: pParent->backStorage->obscured,
292: exposed);
293: }
294:
295: (* pScreen->RegionCopy) (pParent->clipList, universe);
296:
297: pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
298: pParent->marked = 0;
299:
300: if (childUniverse)
301: (* pScreen->RegionDestroy) (childUniverse);
302: }
303:
304: /*-
305: *-----------------------------------------------------------------------
306: * miValidateTree --
307: * Recomputes the clip list for pParent and all its inferiors.
308: *
309: * Results:
310: * Always returns 1.
311: *
312: * Side Effects:
313: * The clipList, borderClip, exposed, and borderExposed regions for
314: * each marked window are altered.
315: *
316: * Notes:
317: * This routine assumes that all affected windows have had their
318: * marked fields set true and their winSize and borderSize regions
319: * adjusted to correspond to their new positions. The borderClip and
320: * clipList regions should not have been touched.
321: *
322: * The top-most level is treated differently from all lower levels
323: * because pParent is unchanged. For the top level, we merge the
324: * regions taken up by the marked children back into the clipList
325: * for pParent, thus forming a region from which the marked children
326: * can claim their areas. For lower levels, where the old clipList
327: * and borderClip are invalid, we can't do this and have to do the
328: * extra operations done in miComputeClips, but this is much faster
329: * e.g. when only one child has moved...
330: *
331: *-----------------------------------------------------------------------
332: */
333: /*ARGSUSED*/
334: int
335: miValidateTree (pParent, pChild, top, anyMarked)
336: WindowPtr pParent; /* Parent to validate */
337: WindowPtr pChild; /* First child of pParent that was
338: * affected */
339: Bool top; /* TRUE if at top level. UNUSED */
340: Bool anyMarked; /* TRUE if any windows were marked. */
341: {
342: RegionPtr totalClip; /* Total clipping region available to
343: * the marked children. pParent's clipList
344: * merged with the borderClips of all
345: * the marked children. */
346: RegionPtr childClip; /* The new borderClip for the current
347: * child */
348: register ScreenPtr pScreen;
349: register WindowPtr pWin;
350:
351: if (!anyMarked)
352: {
353: return (1);
354: }
355: pScreen = pParent->drawable.pScreen;
356:
357: if (exposed == NullRegion)
358: {
359: exposed = (* pScreen->RegionCreate) (NULL, 1);
360: }
361:
362: totalClip = (* pScreen->RegionCreate) (NULL, 1);
363: childClip = (* pScreen->RegionCreate) (NULL, 1);
364:
365: /*
366: * Preserve the parent's old clipList to make calculating exposures
367: * easier.
368: */
369: (* pScreen->RegionCopy) (totalClip, pParent->clipList);
370:
371: if (pChild == NullWindow)
372: {
373: pChild = pParent->firstChild;
374: }
375:
376: /*
377: * First merge in the child windows at their old places.
378: */
379: for (pWin = pChild; pWin != NullWindow; pWin = pWin->nextSib)
380: {
381: if (pWin->marked)
382: {
383: (* pScreen->Union) (totalClip, totalClip, pWin->borderClip);
384: }
385: }
386:
387: /*
388: * Now go through the children of the root and figure their new
389: * borderClips from the totalClip, passing that off to miComputeClips
390: * to handle recursively. Once that's done, we remove the child
391: * from the totalClip to clip any siblings below it.
392: */
393: for (pWin = pChild; pWin != NullWindow; pWin = pWin->nextSib)
394: {
395: if (pWin->viewable)
396: {
397: if (pWin->marked)
398: {
399: (* pScreen->Intersect) (childClip, totalClip, pWin->borderSize);
400: miComputeClips (pWin, pScreen, childClip);
401: (* pScreen->Subtract) (totalClip, totalClip, pWin->borderSize);
402: }
403: }
404: else
405: {
406: /*
407: * Make sure the child is no longer marked (Windows being unmapped
408: * are marked but unviewable...)
409: */
410: pWin->marked = 0;
411: if ((* pScreen->RegionNotEmpty) (pWin->borderClip))
412: {
413: /*
414: * If the child isn't viewable, it has no business taking up
415: * clipping space, so we nuke all its clipping regions. There
416: * was a problem with UnmapGravity where the clipList wouldn't
417: * get nuked, so drawing operations succeeded while the window
418: * was unmapped...
419: */
420: (* pScreen->RegionEmpty) (pChild->borderClip);
421: (* pScreen->RegionEmpty) (pChild->clipList);
422: (* pScreen->RegionEmpty) (pChild->exposed);
423: (* pScreen->RegionEmpty) (pChild->borderExposed);
424: pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;
425: }
426: }
427: }
428:
429: /*
430: * totalClip contains the new clipList for the parent. Figure out
431: * exposures and obscures as per miComputeClips and reset the parent's
432: * clipList.
433: */
434: (* pScreen->Subtract) (exposed, totalClip, pParent->clipList);
435: (* pScreen->Union) (pParent->exposed, pParent->exposed, exposed);
436:
437: if (pParent->backStorage && (pParent->backingStore != NotUseful))
438: {
439: (* pScreen->Subtract) (exposed, pParent->clipList, totalClip);
440: (* pScreen->Union) (pParent->backStorage->obscured,
441: pParent->backStorage->obscured,
442: exposed);
443: }
444:
445: (* pScreen->RegionCopy) (pParent->clipList, totalClip);
446: pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
447: pParent->marked = 0;
448:
449: (* pScreen->RegionDestroy) (childClip);
450:
451: WindowsRestructured();
452:
453: (* pScreen->RegionDestroy) (totalClip);
454:
455: return (1);
456: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.