![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to window.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 / dix|
Return to window.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix |
1.1 root 1: /***********************************************************
2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
4:
5: All Rights Reserved
6:
7: Permission to use, copy, modify, and distribute this software and its
8: documentation for any purpose and without fee is hereby granted,
9: provided that the above copyright notice appear in all copies and that
10: both that copyright notice and this permission notice appear in
11: supporting documentation, and that the names of Digital or MIT not be
12: used in advertising or publicity pertaining to distribution of the
13: software without specific, written prior permission.
14:
15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
21: SOFTWARE.
22:
23: ******************************************************************/
24:
25: /* $Header: window.c,v 1.170 87/09/07 18:56:00 rws Exp $ */
26:
27: #include "X.h"
28: #define NEED_REPLIES
29: #define NEED_EVENTS
30: #include "Xproto.h"
31: #include "misc.h"
32: #include "scrnintstr.h"
33: #include "os.h"
34: #include "regionstr.h"
35: #include "windowstr.h"
36: #include "input.h"
37: #include "resource.h"
38: #include "colormapst.h"
39: #include "cursorstr.h"
40: #include "dixstruct.h"
41: #include "gcstruct.h"
42: #include "servermd.h"
43:
44: /******
45: * Window stuff for server
46: *
47: * CreateRootWindow, CreateWindow, ChangeWindowAttributes,
48: * GetWindowAttributes, DeleteWindow, DestroySubWindows,
49: * HandleSaveSet, ReparentWindow, MapWindow, MapSubWindows,
50: * UnmapWindow, UnmapSubWindows, ConfigureWindow, CirculateWindow,
51: *
52: ******/
53:
54: static long _back[16] = {0x88888888, 0x22222222, 0x44444444, 0x11111111,
55: 0x88888888, 0x22222222, 0x44444444, 0x11111111,
56: 0x88888888, 0x22222222, 0x44444444, 0x11111111,
57: 0x88888888, 0x22222222, 0x44444444, 0x11111111};
58:
59: typedef struct _ScreenSaverStuff {
60: WindowPtr pWindow;
61: XID wid;
62: XID cid;
63: BYTE blanked;
64: } ScreenSaverStuffRec;
65:
66: #define SCREEN_IS_BLANKED 0
67: #define SCREEN_IS_TILED 1
68: #define SCREEN_ISNT_SAVED 2
69:
70: #define DONT_USE_GRAVITY 0
71: #define USE_GRAVITY 1
72:
73: extern int ScreenSaverBlanking, ScreenSaverAllowExposures;
74: int screenIsSaved = FALSE;
75:
76: static ScreenSaverStuffRec savedScreenInfo[MAXSCREENS];
77:
78: extern WindowRec WindowTable[];
79: extern void (* ReplySwapVector[256]) ();
80:
81: static void ResizeChildrenWinSize();
82:
83: #define INPUTONLY_LEGAL_MASK (CWWinGravity | CWEventMask | \
84: CWDontPropagate | CWOverrideRedirect | CWCursor )
85:
86: /******
87: * PrintWindowTree
88: * For debugging only
89: ******/
90:
91: int
92: PrintChildren(p1, indent)
93: WindowPtr p1;
94: int indent;
95: {
96: WindowPtr p2;
97: int i;
98:
99: while (p1)
100: {
101: p2 = p1->firstChild;
102: for (i=0; i<indent; i++) ErrorF( " ");
103: ErrorF( "%x\n", p1->wid);
104: miprintRects(p1->clipList);
105: PrintChildren(p2, indent+4);
106: p1 = p1->nextSib;
107: }
108: }
109:
110: PrintWindowTree()
111: {
112: int i;
113: WindowPtr pWin, p1;
114:
115: for (i=0; i<screenInfo.numScreens; i++)
116: {
117: ErrorF( "WINDOW %d\n", i);
118: pWin = &WindowTable[i];
119: miprintRects(pWin->clipList);
120: p1 = pWin->firstChild;
121: PrintChildren(p1, 4);
122: }
123: }
124:
125:
126: /*****
127: * WalkTree
128: * Walk the window tree, for SCREEN, preforming FUNC(pWin, data) on
129: * each window. If FUNC returns WT_WALKCHILDREN, traverse the children,
130: * if it returns WT_DONTWALKCHILDREN, dont. If it returns WT_STOPWALKING
131: * exit WalkTree. Does depth-first traverse.
132: *****/
133:
134: int
135: TraverseTree(pWin, func, data)
136: WindowPtr pWin;
137: int (*func)();
138: pointer data;
139: {
140: int result;
141: WindowPtr pChild;
142:
143: if (pWin == 0)
144: return(WT_NOMATCH);
145: result = (* func)(pWin, data);
146:
147: if (result == WT_STOPWALKING)
148: return(WT_STOPWALKING);
149:
150: if (result == WT_WALKCHILDREN)
151: for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib)
152: if (TraverseTree(pChild, func,data) == WT_STOPWALKING)
153: return(WT_STOPWALKING);
154:
155: return(WT_NOMATCH);
156: }
157:
158: int
159: WalkTree(pScreen, func, data)
160: ScreenPtr pScreen;
161: int (* func)();
162: char *data;
163: {
164: WindowPtr pWin;
165:
166: pWin = &WindowTable[pScreen->myNum];
167: return(TraverseTree(pWin, func, data));
168: }
169:
170: /*****
171: * DoObscures(pWin)
172: *
173: *****/
174:
175: static void
176: DoObscures(pWin)
177: WindowPtr pWin;
178: {
179: WindowPtr pSib;
180:
181: if (pWin->backStorage == 0 || (pWin->backingStore == NotUseful))
182: return ;
183: if ((* pWin->drawable.pScreen->RegionNotEmpty)(pWin->backStorage->obscured))
184: {
185: (*pWin->backStorage->SaveDoomedAreas)( pWin );
186: (* pWin->drawable.pScreen->RegionEmpty)(pWin->backStorage->obscured);
187: }
188: pSib = pWin->firstChild;
189: while (pSib)
190: {
191: DoObscures(pSib);
192: pSib = pSib->nextSib;
193: }
194: }
195:
196: /*****
197: * HandleExposures(pWin)
198: * starting at pWin, draw background in any windows that have exposure
199: * regions, translate the regions, restore any backing store,
200: * and then send any regions stille xposed to the client
201: *****/
202:
203: /* NOTE
204: the order of painting and restoration needs to be different,
205: to avoid an extra repaint of the background. --rgd
206: */
207:
208: void
209: HandleExposures(pWin)
210: WindowPtr pWin;
211: {
212: WindowPtr pSib;
213:
214: if ((* pWin->drawable.pScreen->RegionNotEmpty)(pWin->borderExposed))
215: {
216: (*pWin->PaintWindowBorder)(pWin, pWin->borderExposed, PW_BORDER);
217: (* pWin->drawable.pScreen->RegionEmpty)(pWin->borderExposed);
218: }
219: (* pWin->drawable.pScreen->WindowExposures)(pWin);
220: pSib = pWin->firstChild;
221: while (pSib)
222: {
223: HandleExposures(pSib);
224: pSib = pSib->nextSib;
225: }
226: }
227:
228: extern int NotImplemented();
229:
230: static void
231: InitProcedures(pWin)
232: WindowPtr pWin;
233: {
234: #ifdef DEBUG
235: void (**j) ();
236: for (j = &pWin->PaintWindowBackground;
237: j < &pWin->ClearToBackground; j++ )
238: *j = (void (*) ())NotImplemented;
239: #endif /* DEBUG */
240:
241: }
242:
243: static void
244: SetWindowToDefaults(pWin, pScreen)
245: WindowPtr pWin;
246: ScreenPtr pScreen;
247: {
248: pWin->prevSib = NullWindow;
249: pWin->firstChild = NullWindow;
250: pWin->lastChild = NullWindow;
251:
252: pWin->userProps = (PropertyPtr)NULL;
253:
254: pWin->backingStore = NotUseful;
255: pWin->backStorage = (BackingStorePtr) NULL;
256:
257: pWin->mapped = 0; /* off */
258: pWin->realized = 0; /* off */
259: pWin->viewable = 0;
260: pWin->overrideRedirect = FALSE;
261: pWin->saveUnder = FALSE;
262:
263: pWin->bitGravity = ForgetGravity;
264: pWin->winGravity = NorthWestGravity;
265: pWin->backingBitPlanes = -1;
266: pWin->backingPixel = 0;
267:
268: pWin->eventMask = 0;
269: pWin->dontPropagateMask = 0;
270: pWin->allEventMasks = 0;
271: pWin->deliverableEvents = 0;
272:
273: pWin->otherClients = (pointer)NULL;
274: pWin->passiveGrabs = (pointer)NULL;
275: pWin->colormap = (Colormap)CopyFromParent;
276:
277: pWin->exposed = (* pScreen->RegionCreate)(NULL, 1);
278: pWin->borderExposed = (* pScreen->RegionCreate)(NULL, 1);
279:
280: }
281:
282: static void
283: MakeRootCursor(pWin)
284: WindowPtr pWin;
285: {
286: unsigned char *srcbits, *mskbits;
287: int i;
288: if (rootCursor)
289: {
290: pWin->cursor = rootCursor;
291: rootCursor->refcnt++;
292: }
293: else
294: {
295: CursorMetricRec cm;
296: cm.width=32;
297: cm.height=16;
298: cm.xhot=8;
299: cm.yhot=8;
300:
301: srcbits = (unsigned char *)Xalloc( PixmapBytePad(32, 1)*16);
302: mskbits = (unsigned char *)Xalloc( PixmapBytePad(32, 1)*16);
303: for (i=0; i<PixmapBytePad(32, 1)*16; i++)
304: {
305: srcbits[i] = mskbits[i] = 0xff;
306: }
307: pWin->cursor = AllocCursor( srcbits, mskbits, &cm,
308: ~0, ~0, ~0, 0, 0, 0);
309: }
310: }
311:
312: static void
313: MakeRootTile(pWin)
314: WindowPtr pWin;
315: {
316: ScreenPtr pScreen = pWin->drawable.pScreen;
317: GCPtr pGC;
318:
319: pWin->backgroundTile = (*pScreen->CreatePixmap)(pScreen, 16, 16,
320: pScreen->rootDepth);
321:
322: pGC = GetScratchGC(pScreen->rootDepth, pScreen);
323:
324: {
325: CARD32 attributes[3];
326:
327: attributes[0] = pScreen->whitePixel;
328: attributes[1] = pScreen->blackPixel;
329: attributes[2] = FALSE;
330:
331: ChangeGC(pGC, GCForeground | GCBackground | GCGraphicsExposures,
332: attributes, 3);
333: }
334:
335: ValidateGC(pWin->backgroundTile, pGC);
336:
337: (*pGC->PutImage)(pWin->backgroundTile, pGC, 1,
338: 0, 0, 16, 16, 0, XYBitmap, _back);
339:
340: FreeScratchGC(pGC);
341:
342: }
343:
344: /*****
345: * CreateRootWindow
346: * Makes a window at initialization time for specified screen
347: *****/
348:
349: int
350: CreateRootWindow(screen)
351: int screen;
352: {
353: WindowPtr pWin;
354: BoxRec box;
355: ScreenPtr pScreen;
356:
357: savedScreenInfo[screen].pWindow = NULL;
358: savedScreenInfo[screen].wid = FakeClientID(0);
359: savedScreenInfo[screen].cid = FakeClientID(0);
360: screenIsSaved = SCREEN_SAVER_OFF;
361:
362: pWin = &WindowTable[screen];
363: pScreen = &screenInfo.screen[screen];
364: InitProcedures(pWin);
365:
366: pWin->drawable.pScreen = pScreen;
367: pWin->drawable.type = DRAWABLE_WINDOW;
368:
369: pWin->drawable.depth = pScreen->rootDepth;
370:
371: pWin->parent = NullWindow;
372: SetWindowToDefaults(pWin, pScreen);
373:
374: pWin->colormap = pScreen->defColormap;
375:
376: pWin->nextSib = NullWindow;
377:
378: MakeRootCursor(pWin);
379:
380: pWin->client = serverClient; /* since belongs to server */
381: pWin->wid = FakeClientID(0);
382:
383: pWin->clientWinSize.x = pWin->clientWinSize.y = 0;
384: pWin->clientWinSize.height = screenInfo.screen[screen].height;
385: pWin->clientWinSize.width = screenInfo.screen[screen].width;
386: pWin->absCorner.x = pWin->absCorner.y = 0;
387: pWin->oldAbsCorner.x = pWin->oldAbsCorner.y = 0;
388:
389: box.x1 = 0;
390: box.y1 = 0;
391: box.x2 = screenInfo.screen[screen].width ;
392: box.y2 = screenInfo.screen[screen].height;
393: pWin->clipList = (* pScreen->RegionCreate)(&box, 1);
394: pWin->winSize = (* pScreen->RegionCreate)(&box, 1);
395: pWin->borderSize = (* pScreen->RegionCreate)(&box, 1);
396: pWin->borderClip = (* pScreen->RegionCreate)(&box, 1);
397:
398: pWin->class = InputOutput;
399: pWin->visual = pScreen->rootVisual;
400:
401: pWin->backgroundPixel = pScreen->whitePixel;
402:
403: pWin->borderPixel = pScreen->blackPixel;
404: pWin->borderWidth = 0;
405:
406: AddResource(pWin->wid, RT_WINDOW, pWin, DeleteWindow, RC_CORE);
407:
408: MakeRootTile(pWin);
409: pWin->borderTile = (PixmapPtr)USE_BORDER_PIXEL;
410:
411: /* re-validate GC for use with root Window */
412:
413: (*pScreen->CreateWindow)(pWin);
414: MapWindow(pWin, DONT_HANDLE_EXPOSURES, BITS_DISCARDED,
415: DONT_SEND_NOTIFICATION, serverClient);
416:
417: /* We SHOULD check for an error value here XXX */
418: (*pScreen->ChangeWindowAttributes)(pWin, CWBackPixmap | CWBorderPixel);
419:
420: (*pWin->PaintWindowBackground)(pWin, pWin->clipList, PW_BACKGROUND);
421: EventSelectForWindow(pWin, serverClient, 0);
422: return(Success);
423: }
424:
425: /*****
426: * CreateWindow
427: * Makes a window in response to client request
428: * XXX What about depth of inputonly windows -- should be 0
429: *****/
430:
431: WindowPtr
432: CreateWindow(wid, pParent, x, y, w, h, bw, class, vmask, vlist,
433: depth, client, visual, error)
434: Window wid;
435: WindowPtr pParent; /* already looked up in table to do error checking*/
436: short x,y;
437: unsigned short w, h, bw;
438: int class;
439: int vmask;
440: long *vlist;
441: int depth;
442: ClientPtr client;
443: VisualID visual;
444: int *error;
445: {
446: WindowPtr pWin;
447: ScreenPtr pScreen;
448: BoxRec box;
449: xEvent event;
450: int idepth, ivisual;
451: Bool fOK;
452: DepthPtr pDepth;
453:
454: if ((class != InputOnly) && (pParent->class == InputOnly))
455: {
456: *error = BadMatch;
457: return (WindowPtr)NULL;
458: }
459:
460: if ((class == InputOnly) && ((bw != 0) || (depth != 0)))
461: {
462: *error = BadMatch;
463: return (WindowPtr)NULL;
464: }
465:
466: pScreen = pParent->drawable.pScreen;
467: /* Find out if the depth and visual are acceptable for this Screen */
468: fOK = FALSE;
469: if ((class == InputOutput && depth == 0) ||
470: (class == InputOnly) || (class == CopyFromParent))
471: depth = pParent->drawable.depth;
472:
473: if (visual == CopyFromParent)
474: visual = pParent->visual;
475: else
476: {
477: for(idepth = 0; idepth < pScreen->numDepths; idepth++)
478: {
479: pDepth = (DepthPtr) &pScreen->allowedDepths[idepth];
480: if (depth == pDepth->depth)
481: {
482: for (ivisual = 0; ivisual < pDepth->numVids; ivisual++)
483: {
484: if (visual == pDepth->vids[ivisual])
485: fOK = TRUE;
486: }
487: }
488: }
489: if (fOK == 0)
490: {
491: *error = BadMatch;
492: return (WindowPtr)NULL;
493: }
494: }
495:
496: pWin = (WindowPtr ) Xalloc( sizeof(WindowRec) );
497: if (pWin == (WindowPtr) NULL)
498: {
499: *error = BadAlloc;
500: return (WindowPtr)NULL;
501: }
502: InitProcedures(pWin);
503: pWin->drawable = pParent->drawable;
504: if (class == InputOutput)
505: pWin->drawable.depth = depth;
506: else if (class == InputOnly)
507: pWin->drawable.type = (short) UNDRAWABLE_WINDOW;
508:
509: pWin->wid = wid;
510: pWin->client = client;
511: pWin->visual = visual;
512:
513: SetWindowToDefaults(pWin, pScreen);
514:
515: pWin->cursor = (CursorPtr)None;
516:
517: if (class == CopyFromParent)
518: pWin->class = pParent->class;
519: else
520: pWin->class = class;
521:
522: pWin->borderWidth = (int) bw;
523: pWin->backgroundTile = (PixmapPtr)None;
524: pWin->backgroundPixel = pScreen->whitePixel;
525:
526: if ((pWin->drawable.depth != pParent->drawable.depth) &&
527: (((vmask & (CWBorderPixmap | CWBorderPixel)) == 0 )))
528: {
529: Xfree(pWin);
530: *error = BadMatch;
531: return (WindowPtr)NULL;
532: }
533: if ((vmask & (CWBorderPixmap | CWBorderPixel)) != 0)
534: /* it will just get fixed in ChangeWindowAttributes */
535: pWin->borderTile = (PixmapPtr)NULL;
536: else
537: { /* this is WRONG!! XXX */
538: /* should be actually copied */
539: pWin->borderTile = pParent->borderTile;
540: if (IS_VALID_PIXMAP(pParent->borderTile))
541: pParent->borderTile->refcnt++;
542: }
543: pWin->borderPixel = pParent->borderPixel;
544: pWin->visibility = VisibilityFullyObscured;
545:
546: pWin->clientWinSize.x = x + bw;
547: pWin->clientWinSize.y = y + bw;
548: pWin->clientWinSize.height = h;
549: pWin->clientWinSize.width = w;
550: pWin->absCorner.x = pWin->oldAbsCorner.x = pParent->absCorner.x + x + bw;
551: pWin->absCorner.y = pWin->oldAbsCorner.y = pParent->absCorner.y + y + bw;
552:
553: /* set up clip list correctly for unobscured WindowPtr */
554: pWin->clipList = (* pScreen->RegionCreate)(NULL, 1);
555: pWin->borderClip = (* pScreen->RegionCreate)(NULL, 1);
556: box.x1 = pWin->absCorner.x;
557: box.y1 = pWin->absCorner.y;
558: box.x2 = box.x1 + w;
559: box.y2 = box.y1 + h;
560: pWin->winSize = (* pScreen->RegionCreate)(&box, 1);
561: (* pScreen->Intersect)(pWin->winSize, pWin->winSize, pParent->winSize);
562: if (bw)
563: {
564: box.x1 -= bw;
565: box.y1 -= bw;
566: box.x2 += bw;
567: box.y2 += bw;
568: pWin->borderSize = (* pScreen->RegionCreate)(&box, 1);
569: (* pScreen->Intersect)(pWin->borderSize, pWin->borderSize,
570: pParent->winSize);
571: }
572: else
573: {
574: pWin->borderSize = (* pScreen->RegionCreate)(NULL, 1);
575: (* pScreen->RegionCopy)(pWin->borderSize, pWin->winSize);
576: }
577:
578: pWin->parent = pParent;
579: if ((screenIsSaved == SCREEN_SAVER_ON)
580: && (pParent == &WindowTable[pScreen->myNum])
581: && (pParent->firstChild)
582: && (savedScreenInfo[pScreen->myNum].blanked == SCREEN_IS_TILED))
583: {
584: WindowPtr pFirst = pParent->firstChild;
585: pWin->nextSib = pFirst->nextSib;
586: if (pFirst->nextSib)
587: pFirst->nextSib->prevSib = pWin;
588: else
589: pParent->lastChild = pWin;
590: pFirst->nextSib = pWin;
591: pWin->prevSib = pFirst;
592: }
593: else
594: {
595: pWin->nextSib = pParent->firstChild;
596: if (pParent->firstChild)
597: pParent->firstChild->prevSib = pWin;
598: else
599: pParent->lastChild = pWin;
600: pParent->firstChild = pWin;
601: }
602:
603: /* We SHOULD check for an error value here XXX */
604: (*pScreen->CreateWindow)(pWin);
605: /* We SHOULD check for an error value here XXX */
606: (*pScreen->PositionWindow)(pWin, pWin->absCorner.x, pWin->absCorner.y);
607: if ((vmask & CWEventMask) == 0)
608: EventSelectForWindow(pWin, client, 0);
609:
610: if (vmask)
611: *error = ChangeWindowAttributes(pWin, vmask, vlist, pWin->client);
612: else
613: *error = Success;
614:
615: WindowHasNewCursor( pWin);
616:
617: event.u.u.type = CreateNotify;
618: event.u.createNotify.window = wid;
619: event.u.createNotify.parent = pParent->wid;
620: event.u.createNotify.x = x;
621: event.u.createNotify.y = y;
622: event.u.createNotify.width = w;
623: event.u.createNotify.height = h;
624: event.u.createNotify.borderWidth = bw;
625: event.u.createNotify.override = pWin->overrideRedirect;
626: DeliverEvents(pWin->parent, &event, 1, NullWindow);
627:
628: return pWin;
629: }
630:
631: static void
632: FreeWindowResources(pWin)
633: WindowPtr pWin;
634: {
635: ScreenPtr pScreen;
636: void (* proc)();
637:
638: pScreen = pWin->drawable.pScreen;
639:
640: DeleteWindowFromAnySaveSet(pWin);
641: DeleteWindowFromAnySelections(pWin);
642: DeleteWindowFromAnyEvents(pWin, TRUE);
643: proc = pScreen->RegionDestroy;
644: (* proc)(pWin->clipList);
645: (* proc)(pWin->winSize);
646: (* proc)(pWin->borderClip);
647: (* proc)(pWin->borderSize);
648: (* proc)(pWin->exposed);
649: (* proc)(pWin->borderExposed);
650: if (pWin->backStorage)
651: {
652: (* proc)(pWin->backStorage->obscured);
653: Xfree(pWin->backStorage);
654: }
655: (* pScreen->DestroyPixmap)(pWin->borderTile);
656: (* pScreen->DestroyPixmap)(pWin->backgroundTile);
657:
658: if (pWin->cursor != (CursorPtr)None)
659: FreeCursor( pWin->cursor, 0);
660:
661: DeleteAllWindowProperties(pWin);
662: /* We SHOULD check for an error value here XXX */
663: (* pScreen->DestroyWindow)(pWin);
664: }
665:
666: static void
667: CrushTree(pWin)
668: WindowPtr pWin;
669: {
670: WindowPtr pSib;
671: xEvent event;
672:
673: if (pWin == (WindowPtr) NULL)
674: return;
675: while (pWin)
676: {
677: CrushTree(pWin->firstChild);
678:
679: event.u.u.type = DestroyNotify;
680: event.u.destroyNotify.window = pWin->wid;
681: DeliverEvents(pWin, &event, 1, NullWindow);
682:
683: FreeResource(pWin->wid, RC_CORE);
684: pSib = pWin->nextSib;
685: pWin->realized = FALSE;
686: pWin->viewable = FALSE;
687: (* pWin->drawable.pScreen->UnrealizeWindow)(pWin);
688: FreeWindowResources(pWin);
689: Xfree(pWin);
690: pWin = pSib;
691: }
692: }
693:
694: /*****
695: * DeleteWindow
696: * Deletes child of window then window itself
697: *****/
698:
699: DeleteWindow(pWin, wid)
700: WindowPtr pWin;
701: int wid;
702: {
703: WindowPtr pParent;
704: xEvent event;
705:
706: UnmapWindow(pWin, HANDLE_EXPOSURES, SEND_NOTIFICATION, FALSE);
707:
708: CrushTree(pWin->firstChild);
709:
710: event.u.u.type = DestroyNotify;
711: event.u.destroyNotify.window = pWin->wid;
712: DeliverEvents(pWin, &event, 1, NullWindow);
713:
714: pParent = pWin->parent;
715: FreeWindowResources(pWin);
716: if (pParent)
717: {
718: if (pParent->firstChild == pWin)
719: pParent->firstChild = pWin->nextSib;
720: if (pParent->lastChild == pWin)
721: pParent->lastChild = pWin->prevSib;
722: if (pWin->nextSib)
723: pWin->nextSib->prevSib = pWin->prevSib;
724: if (pWin->prevSib)
725: pWin->prevSib->nextSib = pWin->nextSib;
726: Xfree(pWin);
727: }
728: }
729:
730: DestroySubwindows(pWin, client)
731: WindowPtr pWin;
732: ClientPtr client;
733: {
734: WindowPtr pChild, pSib;
735: xEvent event;
736:
737: if ((pChild = pWin->lastChild) == (WindowPtr) NULL)
738: return;
739: while (pChild)
740: {
741: pSib = pChild->prevSib;
742: /* a little lazy evaluation, don't send exposes until all deleted */
743: if (pSib != (WindowPtr) NULL)
744: {
745: event.u.u.type = UnmapNotify;
746: event.u.unmapNotify.window = pWin->wid;
747: event.u.unmapNotify.fromConfigure = xFalse;
748: DeliverEvents(pWin, &event, 1, NullWindow);
749: }
750: else
751: {
752: pChild->nextSib = (WindowPtr)NULL;
753: UnmapWindow(pChild, HANDLE_EXPOSURES, SEND_NOTIFICATION, FALSE);
754: }
755: CrushTree(pChild->firstChild);
756:
757: event.u.u.type = DestroyNotify;
758: event.u.destroyNotify.window = pChild->wid;
759: DeliverEvents(pChild, &event, 1, NullWindow);
760:
761: FreeResource(pChild->wid, RC_CORE);
762: FreeWindowResources(pChild);
763: Xfree(pChild);
764: pChild = pSib;
765: }
766: pWin->firstChild = (WindowPtr )NULL;
767: }
768:
769:
770: /*****
771: * ChangeWindowAttributes
772: *
773: * The value-mask specifies which attributes are to be changed; the
774: * value-list contains one value for each one bit in the mask, from least
775: * to most significant bit in the mask.
776: *****/
777:
778: int
779: ChangeWindowAttributes(pWin, vmask, vlist, client)
780: WindowPtr pWin;
781: unsigned int vmask;
782: long *vlist;
783: ClientPtr client;
784: {
785: int index;
786: long *pVlist;
787: PixmapPtr pPixmap;
788: Pixmap pixID;
789: CursorPtr pCursor;
790: Cursor cursorID;
791: int result;
792: ScreenPtr pScreen;
793: unsigned int vmaskCopy = 0;
794: int error;
795:
796: if ((pWin->class == InputOnly) && (vmask & (~INPUTONLY_LEGAL_MASK)))
797: return BadMatch;
798:
799: error = Success;
800: pScreen = pWin->drawable.pScreen;
801: pVlist = vlist;
802: while (vmask)
803: {
804: index = ffs(vmask) - 1;
805: vmask &= ~(index = (1 << index));
806: switch (index)
807: {
808: case CWBackPixmap:
809: pixID = (Pixmap )*pVlist;
810: pVlist++;
811: if (pixID == None)
812: {
813: (* pScreen->DestroyPixmap)(pWin->backgroundTile);
814: if (pWin->parent == (WindowPtr) NULL)
815: MakeRootTile(pWin);
816: else
817: pWin->backgroundTile = (PixmapPtr)NULL;
818: }
819: else if (pixID == ParentRelative)
820: {
821: (* pScreen->DestroyPixmap)(pWin->backgroundTile);
822: if (pWin->parent == (WindowPtr) NULL)
823: MakeRootTile(pWin);
824: else
825: pWin->backgroundTile = (PixmapPtr)ParentRelative;
826: /* Note that the parent's backgroundTile's refcnt is NOT
827: * incremented. */
828: }
829: else
830: {
831: pPixmap = (PixmapPtr)LookupID(pixID, RT_PIXMAP, RC_CORE);
832: if (pPixmap != (PixmapPtr) NULL)
833: {
834: if ((pPixmap->drawable.depth != pWin->drawable.depth) ||
835: (pPixmap->drawable.pScreen != pScreen))
836: {
837: error = BadMatch;
838: goto PatchUp;
839: }
840: (* pScreen->DestroyPixmap)(pWin->backgroundTile);
841: pWin->backgroundTile = pPixmap;
842: pPixmap->refcnt++;
843: }
844: else
845: {
846: error = BadPixmap;
847: goto PatchUp;
848: }
849: }
850: break;
851: case CWBackPixel:
852: pWin->backgroundPixel = (CARD32 ) *pVlist;
853: (* pScreen->DestroyPixmap)(pWin->backgroundTile);
854: pWin->backgroundTile = (PixmapPtr)USE_BACKGROUND_PIXEL;
855: /* background pixel overrides background pixmap,
856: so don't let the ddx layer see both bits */
857: vmaskCopy &= ~CWBackPixmap;
858: pVlist++;
859: break;
860: case CWBorderPixmap:
861: pixID = (Pixmap ) *pVlist;
862: pVlist++;
863: if (pixID == CopyFromParent)
864: {
865: GCPtr pGC;
866: PixmapPtr parentPixmap;
867: if ((pWin->parent == (WindowPtr) NULL) || (pWin->parent &&
868: (pWin->drawable.depth !=
869: pWin->parent->drawable.depth)))
870: {
871: error = BadMatch;
872: goto PatchUp;
873: }
874: (* pScreen->DestroyPixmap)(pWin->borderTile);
875: parentPixmap = pWin->parent->borderTile;
876: if (parentPixmap == (PixmapPtr)USE_BORDER_PIXEL)
877: {
878: pWin->borderTile = (PixmapPtr)USE_BORDER_PIXEL;
879: pWin->borderPixel = pWin->parent->borderPixel;
880: }
881: else
882: {
883: CARD32 attribute;
884:
885: pPixmap = (* pWin->drawable.pScreen->CreatePixmap)
886: (pWin->drawable.pScreen, parentPixmap->width,
887: parentPixmap->height, pWin->drawable.depth);
888: pGC = GetScratchGC(pWin->drawable.depth,
889: pWin->drawable.pScreen);
890:
891: attribute = GXcopy;
892: ChangeGC(pGC, GCFunction, &attribute, 1);
893: ValidateGC(pPixmap, pGC);
894:
895: (* pGC->CopyArea)(parentPixmap, pPixmap, pGC, 0, 0,
896: parentPixmap->width,
897: parentPixmap->height,
898: pWin->drawable.depth,
899: 0, 0);
900: pWin->borderTile = pPixmap;
901: FreeScratchGC(pGC);
902: }
903: }
904: else
905: {
906: pPixmap = (PixmapPtr)LookupID(pixID, RT_PIXMAP, RC_CORE);
907: if (pPixmap)
908: {
909: if ((pPixmap->drawable.depth != pWin->drawable.depth) ||
910: (pPixmap->drawable.pScreen != pScreen))
911: {
912: error = BadMatch;
913: goto PatchUp;
914: }
915: (* pScreen->DestroyPixmap)(pWin->borderTile);
916: pWin->borderTile = pPixmap;
917: pPixmap->refcnt++;
918: }
919: else
920: {
921: error = BadPixmap;
922: goto PatchUp;
923: }
924: }
925: break;
926: case CWBorderPixel:
927: pWin->borderPixel = (CARD32) *pVlist;
928: (* pScreen->DestroyPixmap)(pWin->borderTile);
929: pWin->borderTile = (PixmapPtr)USE_BORDER_PIXEL;
930: /* border pixel overrides border pixmap,
931: so don't let the ddx layer see both bits */
932: vmaskCopy &= ~CWBorderPixmap;
933: pVlist++;
934: break;
935: case CWBitGravity:
936: pWin->bitGravity = (CARD8 )*pVlist;
937: pVlist++;
938: break;
939: case CWWinGravity:
940: pWin->winGravity = (CARD8 )*pVlist;
941: pVlist++;
942: break;
943: case CWBackingStore:
944: pWin->backingStore = (CARD8 )*pVlist;
945: pVlist++;
946: break;
947: case CWBackingPlanes:
948: pWin->backingBitPlanes = (CARD32) *pVlist;
949: pVlist++;
950: break;
951: case CWBackingPixel:
952: pWin->backingPixel = (CARD32)*pVlist;
953: pVlist++;
954: break;
955: case CWSaveUnder:
956: pWin->saveUnder = (Bool) *pVlist;
957: pVlist++;
958: break;
959: case CWEventMask:
960: result = EventSelectForWindow(pWin, client, (long )*pVlist);
961: if (result)
962: {
963: error = result;
964: goto PatchUp;
965: }
966: pVlist++;
967: break;
968: case CWDontPropagate:
969: result = EventSuppressForWindow(pWin, client, (long )*pVlist);
970: if (result)
971: {
972: error = result;
973: goto PatchUp;
974: }
975: pVlist++;
976: break;
977: case CWOverrideRedirect:
978: pWin->overrideRedirect = (Bool ) *pVlist;
979: pVlist++;
980: break;
981: case CWColormap:
982: {
983: Colormap cmap;
984: ColormapPtr pCmap;
985: xEvent xE;
986: WindowPtr pWinT;
987:
988: cmap = (Colormap ) *pVlist;
989: pWinT = pWin;
990: while(cmap == CopyFromParent)
991: {
992: if(pWinT->parent)
993: {
994: if (pWinT->parent->colormap != CopyFromParent)
995: {
996: cmap = pWinT->parent->colormap;
997: }
998: else
999: pWinT = pWinT->parent;
1000: }
1001: else
1002: {
1003: error = BadMatch;
1004: goto PatchUp;
1005: }
1006: }
1007: pCmap = (ColormapPtr)LookupID(cmap, RT_COLORMAP, RC_CORE);
1008: if (pCmap)
1009: {
1010: if (pCmap->pVisual->vid == pWin->visual)
1011: {
1012: pWin->colormap = (Colormap ) cmap;
1013: xE.u.u.type = ColormapNotify;
1014: xE.u.colormap.new = TRUE;
1015: xE.u.colormap.state = IsMapInstalled(cmap, pWin);
1016: TraverseTree(pWin, TellNewMap, &xE);
1017: }
1018: else
1019: {
1020: error = BadMatch;
1021: goto PatchUp;
1022: }
1023: }
1024: else
1025: {
1026: error = BadColor;
1027: goto PatchUp;
1028: }
1029: pVlist++;
1030: break;
1031: }
1032: case CWCursor:
1033: cursorID = (Cursor ) *pVlist;
1034: pVlist++;
1035: /*
1036: * install the new
1037: */
1038: if ( cursorID == None)
1039: {
1040: if ( pWin->cursor != None)
1041: FreeCursor( pWin->cursor);
1042: if (pWin == &WindowTable[pWin->drawable.pScreen->myNum])
1043: MakeRootCursor( pWin);
1044: else
1045: pWin->cursor = (CursorPtr)None;
1046: }
1047: else
1048: {
1049: pCursor = (CursorPtr)LookupID(cursorID, RT_CURSOR, RC_CORE);
1050: if (pCursor)
1051: {
1052: if ( pWin->cursor != None)
1053: FreeCursor( pWin->cursor);
1054: pWin->cursor = pCursor;
1055: pWin->cursor->refcnt++;
1056: }
1057: else
1058: {
1059: error = BadCursor;
1060: goto PatchUp;
1061: }
1062: }
1063: WindowHasNewCursor( pWin);
1064: break;
1065: default: break;
1066: }
1067: vmaskCopy |= index;
1068: }
1069: PatchUp:
1070: /* We SHOULD check for an error value here XXX */
1071: (*pScreen->ChangeWindowAttributes)(pWin, vmaskCopy);
1072:
1073: /*
1074: If the border pixel changed, redraw the border.
1075: Note that this has to be done AFTER pScreen->ChangeWindowAttributes
1076: for the tile to be rotated, and the correct function selected.
1077: */
1078: if ((vmaskCopy & (CWBorderPixel | CWBorderPixmap))
1079: && pWin->viewable && pWin->borderWidth)
1080: {
1081: (* pScreen->Subtract)(pWin->borderExposed, pWin->borderClip,
1082: pWin->winSize);
1083: (*pWin->PaintWindowBorder)(pWin, pWin->borderExposed, PW_BORDER);
1084: (* pScreen->RegionEmpty)(pWin->borderExposed);
1085: }
1086: return error;
1087: }
1088:
1089:
1090: /*****
1091: * GetWindowAttributes
1092: * Notice that this is different than ChangeWindowAttributes
1093: *****/
1094:
1095: GetWindowAttributes(pWin, client)
1096: WindowPtr pWin;
1097: ClientPtr client;
1098: {
1099: xGetWindowAttributesReply wa;
1100: WindowPtr pWinT;
1101:
1102: wa.type = X_Reply;
1103: wa.bitGravity = pWin->bitGravity;
1104: wa.winGravity = pWin->winGravity;
1105: wa.backingStore = pWin->backingStore;
1106: wa.length = (sizeof(xGetWindowAttributesReply) -
1107: sizeof(xGenericReply)) >> 2;
1108: wa.sequenceNumber = client->sequence;
1109: wa.backingBitPlanes = pWin->backingBitPlanes;
1110: wa.backingPixel = pWin->backingPixel;
1111: wa.saveUnder = (BOOL)pWin->saveUnder;
1112: wa.override = pWin->overrideRedirect;
1113: if (!pWin->mapped)
1114: wa.mapState = IsUnmapped;
1115: else if (pWin->realized)
1116: wa.mapState = IsViewable;
1117: else
1118: wa.mapState = IsUnviewable;
1119:
1120: pWinT = pWin;
1121: while (pWinT->colormap == (Colormap)CopyFromParent)
1122: pWinT = pWinT->parent;
1123: wa.colormap = pWinT->colormap;
1124: wa.mapInstalled = IsMapInstalled(wa.colormap, pWin);
1125:
1126: wa.yourEventMask = EventMaskForClient(pWin, client, &wa.allEventMasks);
1127: wa.doNotPropagateMask = pWin->dontPropagateMask ;
1128: wa.class = pWin->class;
1129: wa.visualID = pWin->visual;
1130:
1131: WriteReplyToClient(client, sizeof(xGetWindowAttributesReply), &wa);
1132: }
1133:
1134:
1135: static WindowPtr
1136: MoveWindowInStack(pWin, pNextSib)
1137: WindowPtr pWin, pNextSib;
1138: {
1139: WindowPtr pParent = pWin->parent;
1140: WindowPtr pFirstChange = pWin; /* highest window where list changes */
1141:
1142: if (pWin->nextSib != pNextSib)
1143: {
1144: if (!pNextSib) /* move to bottom */
1145: {
1146: if (pParent->firstChild == pWin)
1147: pParent->firstChild = pWin->nextSib;
1148: /* if (pWin->nextSib) */ /* is always True: pNextSib == NULL
1149: * and pWin->nextSib != pNextSib
1150: * therefore pWin->nextSib != NULL */
1151: pFirstChange = pWin->nextSib;
1152: pWin->nextSib->prevSib = pWin->prevSib;
1153: /* else pFirstChange = pWin; */
1154: if (pWin->prevSib)
1155: pWin->prevSib->nextSib = pWin->nextSib;
1156: pParent->lastChild->nextSib = pWin;
1157: pWin->prevSib = pParent->lastChild;
1158: pWin->nextSib = (WindowPtr )NULL;
1159: pParent->lastChild = pWin;
1160: }
1161: else if (pParent->firstChild == pNextSib) /* move to top */
1162: {
1163: pFirstChange = pWin;
1164: if (pParent->lastChild == pWin)
1165: pParent->lastChild = pWin->prevSib;
1166: if (pWin->nextSib)
1167: pWin->nextSib->prevSib = pWin->prevSib;
1168: if (pWin->prevSib)
1169: pWin->prevSib->nextSib = pWin->nextSib;
1170: pWin->nextSib = pParent->firstChild;
1171: pWin->prevSib = (WindowPtr ) NULL;
1172: pNextSib->prevSib = pWin;
1173: pParent->firstChild = pWin;
1174: }
1175: else /* move in middle of list */
1176: {
1177: WindowPtr pOldNext = pWin->nextSib;
1178:
1179: pFirstChange = (WindowPtr )NULL;
1180: if (pParent->firstChild == pWin)
1181: pFirstChange = pParent->firstChild = pWin->nextSib;
1182: if (pParent->lastChild == pWin) {
1183: pFirstChange = pWin;
1184: pParent->lastChild = pWin->prevSib;
1185: }
1186: if (pWin->nextSib)
1187: pWin->nextSib->prevSib = pWin->prevSib;
1188: if (pWin->prevSib)
1189: pWin->prevSib->nextSib = pWin->nextSib;
1190: pWin->nextSib = pNextSib;
1191: pWin->prevSib = pNextSib->prevSib;
1192: if (pNextSib->prevSib)
1193: pNextSib->prevSib->nextSib = pWin;
1194: pNextSib->prevSib = pWin;
1195: if (!pFirstChange) { /* do we know it yet? */
1196: pFirstChange = pParent->firstChild; /* no, search from top */
1197: while ((pFirstChange != pWin) && (pFirstChange != pOldNext))
1198: pFirstChange = pFirstChange->nextSib;
1199: }
1200: }
1201: }
1202:
1203: return( pFirstChange );
1204: }
1205:
1206: static void
1207: MoveWindow(pWin, x, y, pNextSib)
1208: WindowPtr pWin;
1209: short x,y;
1210: WindowPtr pNextSib;
1211: {
1212: WindowPtr pParent;
1213: Bool WasMapped = (Bool)(pWin->realized);
1214: BoxRec box;
1215: short oldx, oldy, bw;
1216: RegionPtr oldRegion;
1217: DDXPointRec oldpt;
1218: Bool anyMarked;
1219: register ScreenPtr pScreen;
1220: BoxPtr pBox;
1221: WindowPtr windowToValidate = pWin;
1222:
1223: /* if this is a root window, can't be moved */
1224: if (!(pParent = pWin->parent))
1225: return ;
1226: pScreen = pWin->drawable.pScreen;
1227: bw = pWin->borderWidth;
1228:
1229: oldx = pWin->absCorner.x;
1230: oldy = pWin->absCorner.y;
1231: oldpt.x = oldx;
1232: oldpt.y = oldy;
1233: if (WasMapped)
1234: {
1235: oldRegion = (* pScreen->RegionCreate)(NULL, 1);
1236: (* pScreen->RegionCopy)(oldRegion, pWin->borderClip);
1237: pBox = (* pScreen->RegionExtents)(pWin->borderSize);
1238: anyMarked = MarkSiblingsBelowMe(pWin, pBox);
1239: }
1240: pWin->clientWinSize.x = x + bw;
1241: pWin->clientWinSize.y = y + bw;
1242: pWin->oldAbsCorner.x = oldx;
1243: pWin->oldAbsCorner.y = oldy;
1244: pWin->absCorner.x = pParent->absCorner.x + x +bw;
1245: pWin->absCorner.y = pParent->absCorner.y + y + bw;
1246:
1247: box.x1 = pWin->absCorner.x;
1248: box.y1 = pWin->absCorner.y;
1249: box.x2 = box.x1 + pWin->clientWinSize.width;
1250: box.y2 = box.y1+ pWin->clientWinSize.height;
1251: (* pScreen->RegionReset)(pWin->winSize, &box);
1252: (* pScreen->Intersect)(pWin->winSize, pWin->winSize, pParent->winSize);
1253:
1254: if (bw)
1255: {
1256: box.x1 -= bw;
1257: box.y1 -= bw;
1258: box.x2 += bw;
1259: box.y2 += bw;
1260: (* pScreen->RegionReset)(pWin->borderSize, &box);
1261: (* pScreen->Intersect)(pWin->borderSize, pWin->borderSize,
1262: pParent->winSize);
1263: }
1264: else
1265: (* pScreen->RegionCopy)(pWin->borderSize, pWin->winSize);
1266:
1267: (* pScreen->PositionWindow)(pWin,pWin->absCorner.x, pWin->absCorner.y);
1268:
1269: windowToValidate = MoveWindowInStack(pWin, pNextSib);
1270:
1271: ResizeChildrenWinSize(pWin, FALSE, 0, 0, DONT_USE_GRAVITY);
1272: if (WasMapped)
1273: {
1274:
1275: anyMarked = MarkSiblingsBelowMe(windowToValidate, pBox) || anyMarked;
1276:
1277: (* pScreen->ValidateTree)(pParent, (WindowPtr)NULL, TRUE, anyMarked);
1278:
1279: DoObscures(pParent);
1280: if (pWin->backgroundTile == (PixmapPtr)ParentRelative)
1281: (* pScreen->RegionCopy)(pWin->exposed, pWin->clipList);
1282: else
1283: {
1284: /*
1285: * Why subtract borderSize from parent's exposures? parent
1286: * exposures aren't supposed to extend into children!
1287: */
1288: (* pWin->CopyWindow)(pWin, oldpt, oldRegion);
1289: (* pScreen->Subtract)(pParent->exposed, pParent->exposed,
1290: pWin->borderSize);
1291:
1292: }
1293: (* pScreen->RegionDestroy)(oldRegion);
1294: HandleExposures(pParent);
1295: }
1296: }
1297:
1298: static void
1299: ResizeChildrenWinSize(pWin, XYSame, dw, dh, useGravity)
1300: WindowPtr pWin;
1301: Bool XYSame;
1302: int dw, dh;
1303: Bool useGravity;
1304: {
1305: WindowPtr pSib;
1306: RegionPtr parentReg;
1307: BoxRec box;
1308: register short x, y, cwsx, cwsy;
1309: Bool unmap = FALSE;
1310: register ScreenPtr pScreen;
1311: xEvent event;
1312:
1313: pScreen = pWin->drawable.pScreen;
1314: parentReg = pWin->winSize;
1315: pSib = pWin->firstChild;
1316: x = pWin->absCorner.x;
1317: y = pWin->absCorner.y;
1318:
1319: while (pSib)
1320: {
1321: cwsx = pSib->clientWinSize.x;
1322: cwsy = pSib->clientWinSize.y;
1323: if (useGravity == USE_GRAVITY)
1324: {
1325: switch (pSib->winGravity)
1326: {
1327: case UnmapGravity:
1328: unmap = TRUE;
1329: case NorthWestGravity:
1330: break;
1331: case NorthGravity:
1332: cwsx += dw/2;
1333: break;
1334: case NorthEastGravity:
1335: cwsx += dw;
1336: break;
1337: case WestGravity:
1338: cwsy += dh/2;
1339: break;
1340: case CenterGravity:
1341: cwsx += dw/2;
1342: cwsy += dh/2;
1343: break;
1344: case EastGravity:
1345: cwsx += dw;
1346: cwsy += dh/2;
1347: break;
1348: case SouthWestGravity:
1349: cwsy += dh;
1350: break;
1351: case SouthGravity:
1352: cwsx += dw/2;
1353: cwsy += dh;
1354: break;
1355: case SouthEastGravity:
1356: cwsx += dw;
1357: cwsy += dh;
1358: break;
1359: case StaticGravity: /* XXX */
1360: break;
1361: default:
1362: break;
1363: }
1364: }
1365:
1366: event.u.u.type = GravityNotify;
1367: event.u.gravity.window = pSib->wid;
1368: event.u.gravity.x = cwsx;
1369: event.u.gravity.y = cwsy;
1370: DeliverEvents (pSib, &event, 1, NullWindow);
1371:
1372: box.x1 = x + cwsx;
1373: box.y1 = y + cwsy;
1374: box.x2 = box.x1 + pSib->clientWinSize.width;
1375: box.y2 = box.y1 + pSib->clientWinSize.height;
1376:
1377: pSib->oldAbsCorner.x = pSib->absCorner.x;
1378: pSib->oldAbsCorner.y = pSib->absCorner.y;
1379: pSib->absCorner.x = x + cwsx;
1380: pSib->absCorner.y = y + cwsy;
1381:
1382: (* pScreen->RegionReset)(pSib->winSize, &box);
1383: (* pScreen->Intersect)(pSib->winSize, pSib->winSize,
1384: parentReg);
1385:
1386: if (pSib->borderWidth)
1387: {
1388: box.x1 -= pSib->borderWidth;
1389: box.y1 -= pSib->borderWidth;
1390: box.x2 += pSib->borderWidth;
1391: box.y2 += pSib->borderWidth;
1392: (* pScreen->RegionReset)(pSib->borderSize, &box);
1393: (* pScreen->Intersect)(pSib->borderSize,
1394: pSib->borderSize, parentReg);
1395: }
1396: else
1397: (* pScreen->RegionCopy)(pSib->borderSize, pSib->winSize);
1398: (* pScreen->PositionWindow)(pSib, pSib->absCorner.x, pSib->absCorner.y);
1399: pSib->marked = 1;
1400: if (pSib->firstChild)
1401: ResizeChildrenWinSize(pSib, XYSame, 0, 0, DONT_USE_GRAVITY);
1402: if (unmap)
1403: {
1404: UnmapWindow(pSib, DONT_HANDLE_EXPOSURES, SEND_NOTIFICATION, TRUE);
1405: unmap = FALSE;
1406: }
1407: pSib = pSib->nextSib;
1408: }
1409: }
1410:
1411: static int
1412: ExposeAll(pWin, pScreen)
1413: WindowPtr pWin;
1414: ScreenPtr pScreen;
1415: {
1416: if (!pWin)
1417: return(WT_NOMATCH);
1418: if (pWin->mapped)
1419: {
1420: (* pScreen->RegionCopy)(pWin->exposed, pWin->clipList);
1421: return (WT_WALKCHILDREN);
1422: }
1423: else
1424: return(WT_NOMATCH);
1425: }
1426:
1427:
1428:
1429: static void
1430: SlideAndSizeWindow(pWin, x, y, w, h, pSib)
1431: WindowPtr pWin;
1432: short x,y;
1433: unsigned short w, h;
1434: WindowPtr pSib;
1435: {
1436: WindowPtr pParent;
1437: Bool WasMapped = (Bool)(pWin->realized);
1438: BoxRec box;
1439: unsigned short width = pWin->clientWinSize.width,
1440: height = pWin->clientWinSize.height;
1441: short oldx = pWin->absCorner.x,
1442: oldy = pWin->absCorner.y,
1443: bw = pWin->borderWidth;
1444: short dw, dh;
1445: Bool XYSame = FALSE;
1446: DDXPointRec oldpt;
1447: RegionPtr oldRegion;
1448: Bool anyMarked;
1449: register ScreenPtr pScreen;
1450: BoxPtr pBox;
1451: WindowPtr pFirstChange;
1452:
1453: /* if this is a root window, can't be resized */
1454: if (!(pParent = pWin->parent))
1455: return ;
1456:
1457: pScreen = pWin->drawable.pScreen;
1458: if (WasMapped)
1459: {
1460: if ((pWin->bitGravity != ForgetGravity) ||
1461: (pWin->backgroundTile == (PixmapPtr)ParentRelative))
1462: oldRegion = NotClippedByChildren(pWin);
1463: pBox = (* pScreen->RegionExtents)(pWin->borderSize);
1464: anyMarked = MarkSiblingsBelowMe(pWin, pBox);
1465: }
1466: pWin->clientWinSize.x = x + bw;
1467: pWin->clientWinSize.y = y + bw;
1468: pWin->clientWinSize.height = h;
1469: pWin->clientWinSize.width = w;
1470: XYSame = ((pParent->absCorner.x + x == pWin->absCorner.x)
1471: && (pParent->absCorner.y + y == pWin->absCorner.y));
1472: pWin->oldAbsCorner.x = oldx;
1473: pWin->oldAbsCorner.y = oldy;
1474: oldpt.x = oldx;
1475: oldpt.y = oldy;
1476:
1477: pWin->absCorner.x = pParent->absCorner.x + x + bw;
1478: pWin->absCorner.y = pParent->absCorner.y + y + bw;
1479:
1480: box.x1 = pWin->absCorner.x;
1481: box.y1 = pWin->absCorner.y;
1482: box.x2 = pWin->absCorner.x + w;
1483: box.y2 = pWin->absCorner.y + h;
1484: (* pScreen->RegionReset)(pWin->winSize, &box);
1485: (* pScreen->Intersect)(pWin->winSize, pWin->winSize, pParent->winSize);
1486:
1487: if (pWin->borderWidth)
1488: {
1489: box.x1 -= bw;
1490: box.y1 -= bw;
1491: box.x2 += bw;
1492: box.y2 += bw;
1493: (* pScreen->RegionReset)(pWin->borderSize, &box);
1494: (* pScreen->Intersect)(pWin->borderSize, pWin->borderSize,
1495: pParent->winSize);
1496: }
1497: else
1498: (* pScreen->RegionCopy)(pWin->borderSize, pWin->winSize);
1499:
1500: dw = w - width;
1501: dh = h - height;
1502: ResizeChildrenWinSize(pWin, XYSame, dw, dh, USE_GRAVITY);
1503:
1504: /* let the hardware adjust background and border pixmaps, if any */
1505: (* pScreen->PositionWindow)(pWin, pWin->absCorner.x, pWin->absCorner.y);
1506:
1507: pFirstChange = MoveWindowInStack(pWin, pSib);
1508:
1509: if (WasMapped)
1510: {
1511: RegionPtr pRegion;
1512:
1513: anyMarked = MarkSiblingsBelowMe(pFirstChange, pBox) || anyMarked;
1514:
1515: if ((pWin->bitGravity == ForgetGravity) ||
1516: (pWin->backgroundTile == (PixmapPtr)ParentRelative))
1517: {
1518: (* pScreen->ValidateTree)(pParent, pFirstChange, TRUE, anyMarked);
1519: /* CopyWindow will step on borders, so re-paint them */
1520: (* pScreen->Subtract)(pWin->borderExposed,
1521: pWin->borderClip, pWin->winSize);
1522: TraverseTree(pWin, ExposeAll, pScreen);
1523: DoObscures(pParent);
1524: HandleExposures(pParent);
1525: }
1526: else
1527: {
1528: pRegion = (* pScreen->RegionCreate)(NULL, 1);
1529: (* pScreen->RegionCopy)(pRegion, pWin->clipList);
1530:
1531: x = pWin->absCorner.x;
1532: y = pWin->absCorner.y;
1533: switch (pWin->bitGravity)
1534: {
1535: case NorthWestGravity:
1536: break;
1537: case NorthGravity:
1538: x += dw/2;
1539: break;
1540: case NorthEastGravity:
1541: x += dw;
1542: break;
1543: case WestGravity:
1544: y += dh/2;
1545: break;
1546: case CenterGravity:
1547: x += dw/2;
1548: y += dh/2;
1549: break;
1550: case EastGravity:
1551: x += dw;
1552: y += dh/2;
1553: break;
1554: case SouthWestGravity:
1555: y += dh;
1556: break;
1557: case SouthGravity:
1558: x += dw/2;
1559: y += dh;
1560: break;
1561: case SouthEastGravity:
1562: x += dw;
1563: y += dh;
1564: break;
1565: case StaticGravity:
1566: x = oldx;
1567: y = oldy;
1568: break;
1569: default:
1570: break;
1571: }
1572:
1573: (* pScreen->ValidateTree)(pParent, pFirstChange, TRUE, anyMarked);
1574: DoObscures(pParent);
1575: if (pWin->backStorage && (pWin->backingStore != NotUseful))
1576: {
1577: ErrorF("Going to translate backing store %d %d\n",
1578: oldx - x, oldy - y);
1579: (* pWin->backStorage->TranslateBackingStore) (pWin,
1580: oldx - x, oldy - y);
1581: }
1582: oldpt.x = oldx - x + pWin->absCorner.x;
1583: oldpt.y = oldy - y + pWin->absCorner.y;
1584: (* pWin->CopyWindow)(pWin, oldpt, oldRegion);
1585:
1586:
1587: /* Note that oldRegion is *translated* by CopyWindow */
1588:
1589: /*
1590: * We've taken care of those spots in oldRegion so they needn't
1591: * be re-exposed...
1592: */
1593: (* pScreen->Subtract)(pWin->exposed, pWin->clipList, oldRegion);
1594: (* pScreen->RegionDestroy)(pRegion);
1595:
1596: /* CopyWindow will step on borders, so repaint them */
1597: (* pScreen->Subtract)(pWin->borderExposed,
1598: pWin->borderClip, pWin->winSize);
1599:
1600: HandleExposures(pParent);
1601: (* pScreen->RegionDestroy)(oldRegion);
1602: }
1603: }
1604: }
1605:
1606: static void
1607: ChangeBorderWidth(pWin, width)
1608: WindowPtr pWin;
1609: int width;
1610: {
1611: WindowPtr pParent;
1612: BoxRec box;
1613: BoxPtr pBox;
1614: int oldwidth;
1615: Bool anyMarked;
1616: register ScreenPtr pScreen;
1617: RegionPtr oldRegion;
1618: DDXPointRec oldpt;
1619: Bool WasMapped = (Bool)(pWin->realized);
1620:
1621: oldwidth = pWin->borderWidth;
1622: if (oldwidth == width)
1623: return ;
1624: pScreen = pWin->drawable.pScreen;
1625: pParent = pWin->parent;
1626: pWin->borderWidth = width;
1627:
1628: oldpt.x = pWin->absCorner.x;
1629: oldpt.y = pWin->absCorner.y;
1630: pWin->oldAbsCorner.x = oldpt.x;
1631: pWin->oldAbsCorner.y = oldpt.y;
1632:
1633: pWin->clientWinSize.x += width - oldwidth;
1634: pWin->clientWinSize.y += width - oldwidth;
1635: pWin->absCorner.x += width - oldwidth;
1636: pWin->absCorner.y += width - oldwidth;
1637:
1638: if (WasMapped)
1639: {
1640: oldRegion = (* pScreen->RegionCreate)(NULL, 1);
1641: (* pScreen->RegionCopy)(oldRegion, pWin->borderClip);
1642: }
1643:
1644:
1645: box.x1 = pWin->absCorner.x;
1646: box.y1 = pWin->absCorner.y;
1647: box.x2 = box.x1 + pWin->clientWinSize.width;
1648: box.y2 = box.y1 + pWin->clientWinSize.height;
1649: (* pScreen->RegionReset)(pWin->winSize, &box);
1650: (* pScreen->Intersect)(pWin->winSize, pWin->winSize, pParent->winSize);
1651:
1652: if (width)
1653: {
1654: box.x1 -= width;
1655: box.y1 -= width;
1656: box.x2 += width;
1657: box.y2 += width;
1658: (* pScreen->RegionReset)(pWin->borderSize, &box);
1659: (* pScreen->Intersect)(pWin->borderSize, pWin->borderSize,
1660: pParent->winSize);
1661: }
1662: else
1663: (* pScreen->RegionCopy)(pWin->borderSize, pWin->winSize);
1664:
1665: if (WasMapped)
1666: {
1667: if (width < oldwidth)
1668: pBox = (* pScreen->RegionExtents)(oldRegion);
1669: else
1670: pBox = (* pScreen->RegionExtents)(pWin->borderSize);
1671: anyMarked = MarkSiblingsBelowMe(pWin, pBox);
1672:
1673: (* pScreen->ValidateTree)(pParent,(anyMarked ? pWin : (WindowPtr)NULL),
1674: TRUE, anyMarked );
1675:
1676: (* pWin->CopyWindow)(pWin, oldpt, oldRegion);
1677:
1678: if (width > oldwidth)
1679: {
1680: DoObscures(pParent);
1681: (* pScreen->Subtract)(pWin->borderExposed,
1682: pWin->borderClip, pWin->winSize);
1683: (* pWin->PaintWindowBorder)(pWin, pWin->borderExposed, PW_BORDER);
1684: (* pScreen->RegionEmpty)(pWin->borderExposed);
1685: }
1686: else if (oldwidth > width)
1687: HandleExposures(pParent);
1688:
1689: (* pScreen->RegionDestroy)(oldRegion);
1690:
1691: }
1692: }
1693:
1694:
1695: #define GET_INT16(m, f) \
1696: if (m & mask) \
1697: { \
1698: f = (short) *pVlist;\
1699: pVlist++; \
1700: }
1701: #define GET_CARD16(m, f) \
1702: if (m & mask) \
1703: { \
1704: f = (CARD16) *pVlist;\
1705: pVlist++;\
1706: }
1707:
1708: #define GET_CARD8(m, f) \
1709: if (m & mask) \
1710: { \
1711: f = (CARD8) *pVlist;\
1712: pVlist++;\
1713: }
1714:
1715: #define ChangeMask (CWX | CWY | CWWidth | CWHeight)
1716:
1717: #define IllegalInputOnlyConfigureMask (CWBorderWidth)
1718:
1719: /*
1720: * IsSiblingAboveMe
1721: * returns Above if pSib above pMe in stack or Below otherwise
1722: */
1723:
1724: static int
1725: IsSiblingAboveMe(pMe, pSib)
1726: WindowPtr pMe, pSib;
1727: {
1728: WindowPtr pWin;
1729:
1730: pWin = pMe->parent->firstChild;
1731: while (pWin)
1732: {
1733: if (pWin == pSib)
1734: return(Above);
1735: else if (pWin == pMe)
1736: return(Below);
1737: pWin = pWin->nextSib;
1738: }
1739: return(Below);
1740: }
1741:
1742: static Bool
1743: AnyWindowOverlapsMe(pWin, box)
1744: WindowPtr pWin;
1745: BoxPtr box;
1746: {
1747: WindowPtr pSib;
1748: register ScreenPtr pScreen;
1749:
1750: pSib = pWin->parent->firstChild;
1751: pScreen = pWin->drawable.pScreen;
1752: while (pSib)
1753: {
1754: if (pSib == pWin)
1755: return(FALSE);
1756: else if ((pSib->mapped) &&
1757: ((* pScreen->RectIn)(pSib->borderSize, box) != rgnOUT))
1758: return(TRUE);
1759: pSib = pSib->nextSib;
1760: }
1761: return(FALSE);
1762: }
1763:
1764: static WindowPtr
1765: IOverlapAnyWindow(pWin, box)
1766: WindowPtr pWin;
1767: BoxPtr box;
1768: {
1769: WindowPtr pSib;
1770: register ScreenPtr pScreen;
1771:
1772: pScreen = pWin->drawable.pScreen;
1773: pSib = pWin->nextSib;
1774: while (pSib)
1775: {
1776: if ((pSib->mapped) &&
1777: ((* pScreen->RectIn)(pSib->borderSize, box) != rgnOUT))
1778: return(pSib);
1779: pSib = pSib->nextSib;
1780: }
1781: return((WindowPtr )NULL);
1782: }
1783:
1784: /*
1785: * WhereDoIGoInTheStack()
1786: * Given pWin and pSib and the relationshipe smode, return
1787: * the window that pWin should go ABOVE.
1788: * If a pSib is specified:
1789: * Above: pWin is placed just above pSib
1790: * Below: pWin is placed just below pSib
1791: * TopIf: if pSib occludes pWin, then pWin is placed
1792: * at the top of the stack
1793: * BottomIf: if pWin occludes pSib, then pWin is
1794: * placed at the bottom of the stack
1795: * Opposite: if pSib occludes pWin, then pWin is placed at the
1796: * top of the stack, else if pWin occludes pSib, then
1797: * pWin is placed at the bottom of the stack
1798: *
1799: * If pSib is NULL:
1800: * Above: pWin is placed at the top of the stack
1801: * Below: pWin is placed at the bottom of the stack
1802: * TopIf: if any sibling occludes pWin, then pWin is placed at
1803: * the top of the stack
1804: * BottomIf: if pWin occludes any sibline, then pWin is placed at
1805: * the bottom of the stack
1806: * Opposite: if any sibling occludes pWin, then pWin is placed at
1807: * the top of the stack, else if pWin occludes any
1808: * sibling, then pWin is placed at the bottom of the stack
1809: *
1810: */
1811:
1812: static WindowPtr
1813: WhereDoIGoInTheStack(pWin, pSib, x, y, w, h, smode)
1814: WindowPtr pWin, pSib;
1815: short x, y, w, h;
1816: int smode;
1817: {
1818: BoxRec box;
1819: register ScreenPtr pScreen;
1820:
1821: if ((pWin == pWin->parent->firstChild) &&
1822: (pWin == pWin->parent->lastChild))
1823: return((WindowPtr ) NULL);
1824: pScreen = pWin->drawable.pScreen;
1825: box.x1 = x;
1826: box.y1 = y;
1827: box.x2= x + w;
1828: box.y2 = y + h;
1829: switch (smode)
1830: {
1831: case Above:
1832: if (pSib)
1833: return(pSib);
1834: else if (pWin == pWin->parent->firstChild)
1835: return(pWin->nextSib);
1836: else
1837: return(pWin->parent->firstChild);
1838: case Below:
1839: if (pSib)
1840: if (pSib->nextSib != pWin)
1841: return(pSib->nextSib);
1842: else
1843: return(pWin->nextSib);
1844: else
1845: return((WindowPtr )NULL);
1846: case TopIf:
1847: if (pSib)
1848: {
1849: if ((IsSiblingAboveMe(pWin, pSib) == Above) &&
1850: ((* pScreen->RectIn)(pSib->borderSize, &box) != rgnOUT))
1851: return(pWin->parent->firstChild);
1852: else
1853: return(pWin->nextSib);
1854: }
1855: else if (AnyWindowOverlapsMe(pWin, &box))
1856: return(pWin->parent->firstChild);
1857: else
1858: return(pWin->nextSib);
1859: case BottomIf:
1860: if (pSib)
1861: {
1862: if ((IsSiblingAboveMe(pWin, pSib) == Below) &&
1863: ((* pScreen->RectIn)(pSib->borderSize, &box) != rgnOUT))
1864: return(WindowPtr)NULL;
1865: else
1866: return(pWin->nextSib);
1867: }
1868: else if (IOverlapAnyWindow(pWin, &box))
1869: return((WindowPtr)NULL);
1870: else
1871: return(pWin->nextSib);
1872: case Opposite:
1873: if (pSib)
1874: {
1875: if ((* pScreen->RectIn)(pSib->borderSize, &box) != rgnOUT)
1876: {
1877: if (IsSiblingAboveMe(pWin, pSib) == Above)
1878: return(pWin->parent->firstChild);
1879: else
1880: return((WindowPtr)NULL);
1881: }
1882: else
1883: return(pWin->nextSib);
1884: }
1885: else if (AnyWindowOverlapsMe(pWin, &box))
1886: {
1887: /* If I'm occluded, I can't possibly be the first child
1888: * if (pWin == pWin->parent->firstChild)
1889: * return pWin->nextSib;
1890: */
1891: return(pWin->parent->firstChild);
1892: }
1893: else if (IOverlapAnyWindow(pWin, &box))
1894: return((WindowPtr)NULL);
1895: else
1896: return pWin->nextSib;
1897: default:
1898: {
1899: ErrorF("Internal error in ConfigureWindow, smode == %d\n",smode );
1900: return((WindowPtr)pWin->nextSib);
1901: }
1902: }
1903: }
1904:
1905: static void
1906: ReflectStackChange(pWin, pSib)
1907: WindowPtr pWin, pSib;
1908: {
1909: /* Note that pSib might be NULL */
1910:
1911: Bool doValidation = (Bool)pWin->realized;
1912: WindowPtr pParent;
1913: int anyMarked;
1914: BoxPtr box;
1915: WindowPtr pFirstChange;
1916:
1917: /* if this is a root window, can't be restacked */
1918: if (!(pParent = pWin->parent))
1919: return ;
1920:
1921: pFirstChange = MoveWindowInStack(pWin, pSib);
1922:
1923: if (doValidation)
1924: {
1925: box = (* pWin->drawable.pScreen->RegionExtents)(pWin->borderSize);
1926: anyMarked = MarkSiblingsBelowMe(pFirstChange, box);
1927: (* pWin->drawable.pScreen->ValidateTree)(pParent, pFirstChange,
1928: TRUE, anyMarked);
1929: DoObscures(pParent);
1930: HandleExposures(pParent);
1931: }
1932: }
1933:
1934: /*****
1935: * ConfigureWindow
1936: *****/
1937:
1938:
1939: int
1940: ConfigureWindow(pWin, mask, vlist, client)
1941: WindowPtr pWin;
1942: unsigned long mask;
1943: long *vlist;
1944: ClientPtr client;
1945: {
1946: #define RESTACK_WIN 0
1947: #define MOVE_WIN 1
1948: #define RESIZE_WIN 2
1949: WindowPtr pSib = (WindowPtr )NULL;
1950: Window sibwid;
1951: int index, tmask;
1952: long *pVlist;
1953: short x, y, beforeX, beforeY;
1954: unsigned short w = pWin->clientWinSize.width,
1955: h = pWin->clientWinSize.height,
1956: bw = pWin->borderWidth;
1957: int action,
1958: smode = Above;
1959: xEvent event;
1960:
1961: if ((pWin->class == InputOnly) && (mask & IllegalInputOnlyConfigureMask))
1962: return(BadMatch);
1963:
1964: if ((mask & CWSibling) && !(mask & CWStackMode))
1965: return(BadMatch);
1966:
1967: pVlist = vlist;
1968:
1969: if (pWin->parent)
1970: {
1971: x = pWin->absCorner.x - pWin->parent->absCorner.x - bw;
1972: y = pWin->absCorner.y - pWin->parent->absCorner.y - bw;
1973: }
1974: else
1975: {
1976: x = pWin->absCorner.x;
1977: y = pWin->absCorner.y;
1978: }
1979: beforeX = x;
1980: beforeY = y;
1981: action = RESTACK_WIN;
1982: if ((mask & (CWX | CWY)) && (!(mask & (CWHeight | CWWidth))))
1983: {
1984: GET_INT16(CWX, x);
1985: GET_INT16(CWY, y);
1986: action = MOVE_WIN;
1987: }
1988: /* or should be resized */
1989: else if (mask & (CWX | CWY | CWWidth | CWHeight))
1990: {
1991: GET_INT16(CWX, x);
1992: GET_INT16(CWY, y);
1993: GET_CARD16(CWWidth, w);
1994: GET_CARD16 (CWHeight, h);
1995: if (!w || !h)
1996: return BadValue;
1997: action = RESIZE_WIN;
1998: }
1999: tmask = mask & ~ChangeMask;
2000: while (tmask)
2001: {
2002: index = ffs(tmask) - 1;
2003: tmask &= ~(index = (1 << index));
2004: switch (index)
2005: {
2006: case CWBorderWidth:
2007: GET_CARD16(CWBorderWidth, bw);
2008: break;
2009: case CWSibling:
2010: sibwid = (Window ) *pVlist;
2011: pVlist++;
2012: pSib = (WindowPtr )LookupID(sibwid, RT_WINDOW, RC_CORE);
2013: if (!pSib)
2014: return(BadWindow);
2015: if (pSib->parent != pWin->parent)
2016: return(BadMatch);
2017: if (pSib == pWin)
2018: return(BadMatch);
2019: break;
2020: case CWStackMode:
2021: GET_CARD8(CWStackMode, smode);
2022: if ((smode != TopIf) && (smode != BottomIf) &&
2023: (smode != Opposite) && (smode != Above) && (smode != Below))
2024: return(BadMatch);
2025: break;
2026: default:
2027: return(BadMatch);
2028: }
2029: }
2030: /* root really can't be reconfigured, so just return */
2031: if (!pWin->parent)
2032: return Success;
2033:
2034: /* Figure out if the window should be moved. Doesnt
2035: make the changes to the window if event sent */
2036:
2037: if (mask & CWStackMode)
2038: pSib = WhereDoIGoInTheStack(pWin, pSib, x, y, w, h, smode);
2039: else
2040: pSib = pWin->nextSib;
2041:
2042: if ((!pWin->overrideRedirect) &&
2043: (pWin->parent->allEventMasks & SubstructureRedirectMask))
2044: {
2045: event.u.u.type = ConfigureRequest;
2046: event.u.configureRequest.window = pWin->wid;
2047: event.u.configureRequest.parent = pWin->parent->wid;
2048: if (mask & CWSibling)
2049: event.u.configureRequest.sibling = sibwid;
2050: else
2051: event.u.configureRequest.sibling = None;
2052: if (mask & CWStackMode)
2053: event.u.u.detail = smode;
2054: else
2055: event.u.u.detail = Above;
2056: event.u.configureRequest.x = x;
2057: event.u.configureRequest.y = y;
2058: event.u.configureRequest.width = w;
2059: event.u.configureRequest.height = h;
2060: event.u.configureRequest.borderWidth = bw;
2061: event.u.configureRequest.valueMask = mask;
2062: if (MaybeDeliverEventsToClient(pWin->parent, &event, 1,
2063: SubstructureRedirectMask, client) == 1)
2064: return(Success);
2065: }
2066: if (action == RESIZE_WIN) {
2067: Bool size_change = (w != pWin->clientWinSize.width)
2068: || (h != pWin->clientWinSize.height);
2069: if (size_change && (pWin->allEventMasks & ResizeRedirectMask)) {
2070: xEvent eventT;
2071: eventT.u.u.type = ResizeRequest;
2072: eventT.u.resizeRequest.window = pWin->wid;
2073: eventT.u.resizeRequest.width = w;
2074: eventT.u.resizeRequest.height = h;
2075: if (MaybeDeliverEventsToClient(pWin, &eventT, 1,
2076: ResizeRedirectMask, client) == 1) {
2077: /* if event is delivered, leave the actual size alone. */
2078: w = pWin->clientWinSize.width;
2079: h = pWin->clientWinSize.height;
2080: size_change = FALSE;
2081: }
2082: }
2083: if (!size_change) {
2084: if (mask & (CWX | CWY))
2085: action = MOVE_WIN;
2086: else if (mask & (CWStackMode | CWSibling | CWBorderWidth))
2087: action = RESTACK_WIN;
2088: else /* really nothing to do */
2089: return(Success) ;
2090: }
2091: }
2092:
2093: if (action == RESIZE_WIN)
2094: /* we've already checked whether there's really a size change */
2095: goto ActuallyDoSomething;
2096: if ((mask & CWX) && (x != beforeX))
2097: goto ActuallyDoSomething;
2098: if ((mask & CWY) && (y != beforeY))
2099: goto ActuallyDoSomething;
2100: if ((mask & CWBorderWidth) && (bw != pWin->borderWidth))
2101: goto ActuallyDoSomething;
2102: if (mask & CWStackMode)
2103: {
2104: if (pWin->nextSib != pSib)
2105: goto ActuallyDoSomething;
2106: }
2107: return(Success);
2108:
2109: ActuallyDoSomething:
2110: event.u.u.type = ConfigureNotify;
2111: event.u.configureNotify.window = pWin->wid;
2112: if (pSib)
2113: event.u.configureNotify.aboveSibling = pSib->wid;
2114: else
2115: event.u.configureNotify.aboveSibling = None;
2116: event.u.configureNotify.x = x;
2117: event.u.configureNotify.y = y;
2118: event.u.configureNotify.width = w;
2119: event.u.configureNotify.height = h;
2120: event.u.configureNotify.borderWidth = bw;
2121: event.u.configureNotify.override = pWin->overrideRedirect;
2122: DeliverEvents(pWin, &event, 1, NullWindow);
2123:
2124: if (mask & CWBorderWidth)
2125: {
2126: if (action == RESTACK_WIN)
2127: ChangeBorderWidth(pWin, bw);
2128: else
2129: pWin->borderWidth = bw;
2130: }
2131: if (action == MOVE_WIN)
2132: MoveWindow(pWin, x, y, pSib);
2133: else if (action == RESIZE_WIN)
2134: SlideAndSizeWindow(pWin, x, y, w, h, pSib);
2135: else if (mask & CWStackMode)
2136: ReflectStackChange(pWin, pSib);
2137:
2138: return(Success);
2139: #undef RESTACK_WIN
2140: #undef MOVE_WIN
2141: #undef RESIZE_WIN
2142: }
2143:
2144:
2145: /******
2146: *
2147: * CirculateWindow
2148: * For RaiseLowest, raises the lowest mapped child (if any) that is
2149: * obscured by another child to the top of the stack. For LowerHighest,
2150: * lowers the highest mapped child (if any) that is obscuring another
2151: * child to the bottom of the stack. Exposure processing is performed
2152: *
2153: ******/
2154:
2155: /* XXX shouldn't this be a case for the stack mode stuff?? */
2156:
2157: int
2158: CirculateWindow(pParent, direction, client)
2159: WindowPtr pParent;
2160: int direction;
2161: ClientPtr client;
2162: {
2163: WindowPtr pChild, pSib;
2164: xEvent event;
2165: register ScreenPtr pScreen;
2166:
2167: if (pParent->firstChild == pParent->lastChild)
2168: return(Success) ;
2169:
2170: pScreen = pParent->drawable.pScreen;
2171: if (direction == RaiseLowest)
2172: {
2173: pChild = pParent->lastChild;
2174: while (pChild)
2175: {
2176: if (pChild->mapped && (pChild->visibility != VisibilityUnobscured))
2177: {
2178: if (pParent->firstChild != pChild)
2179: {
2180: if (pParent->lastChild == pChild)
2181: pParent->lastChild = pChild->prevSib;
2182: if (pChild->nextSib)
2183: pChild->nextSib->prevSib = pChild->prevSib;
2184: if (pChild->prevSib)
2185: pChild->prevSib->nextSib = pChild->nextSib;
2186: pChild->nextSib = pParent->firstChild;
2187: pChild->prevSib = (WindowPtr ) NULL;
2188: pParent->firstChild->prevSib = pChild;
2189: pParent->firstChild = pChild;
2190: pChild->mapped = 0; /* to fool MapWindow */
2191: pSib = pChild;
2192: break;
2193: }
2194: return Success;
2195: }
2196: pChild = pChild->prevSib;
2197: }
2198: }
2199: else if (direction == LowerHighest)
2200: {
2201: BoxPtr pBox;
2202:
2203: pChild = pParent->firstChild;
2204: while (pChild)
2205: {
2206: if (pChild->mapped && (pChild->visibility == VisibilityUnobscured))
2207: {
2208: int result;
2209:
2210: /* HACK -- this search is n squared */
2211:
2212: pSib = pChild->nextSib;
2213:
2214: /* find a sibling that pChild overlaps */
2215:
2216: pBox = (* pScreen->RegionExtents)(pChild->borderSize);
2217: while (pSib)
2218: {
2219: if (pSib->realized && (pSib->visibility != VisibilityUnobscured))
2220: {
2221: result = (* pScreen->RectIn)(pSib->borderSize,
2222: &pBox);
2223: if (result != rgnOUT)
2224: break;
2225: }
2226: pSib = pSib->nextSib;
2227: }
2228: if (pSib)
2229: {
2230: WindowPtr pNext;
2231: pNext = pChild->nextSib;
2232: if (pParent->firstChild == pChild)
2233: pParent->firstChild = pNext;
2234: pNext->prevSib = pChild->prevSib;
2235: if (pChild->prevSib)
2236: pChild->prevSib->nextSib = pNext;
2237: pChild->nextSib = (WindowPtr ) NULL;
2238: pChild->prevSib = pParent->lastChild;
2239: pParent->lastChild->nextSib = pChild;
2240: pParent->lastChild = pChild;
2241: pSib->mapped = 0; /* to fool mapWindow */
2242: break;
2243: }
2244: }
2245: pChild = pChild->nextSib;
2246: }
2247: }
2248: if (!pChild)
2249: return(Success) ;
2250: event.u.circulate.window = pChild->wid;
2251: event.u.circulate.parent = pParent->wid;
2252: event.u.circulate.event = pParent->wid;
2253: if (direction == RaiseLowest)
2254: event.u.circulate.place = PlaceOnTop;
2255: else
2256: event.u.circulate.place = PlaceOnBottom;
2257:
2258: if (pParent->allEventMasks & SubstructureRedirectMask)
2259: {
2260: event.u.u.type = CirculateRequest;
2261: if (MaybeDeliverEventsToClient(pParent, &event, 1,
2262: SubstructureRedirectMask, client) == 1)
2263: return(Success);
2264: }
2265: if (pParent->realized)
2266: MapWindow(pSib, HANDLE_EXPOSURES, BITS_DISCARDED,
2267: DONT_SEND_NOTIFICATION, client);
2268: event.u.u.type = CirculateNotify;
2269: DeliverEvents(pParent, &event, 1, NullWindow);
2270: return(Success);
2271: }
2272:
2273: /*****
2274: * ReparentWindow
2275: *****/
2276:
2277: static int
2278: CompareWIDs(pWin, wid)
2279: WindowPtr pWin;
2280: int *wid;
2281: {
2282: if (pWin->wid == *wid)
2283: return(WT_STOPWALKING);
2284: else
2285: return(WT_WALKCHILDREN);
2286: }
2287:
2288: int
2289: ReparentWindow(pWin, pParent, x, y, client)
2290: WindowPtr pWin, pParent;
2291: short x,y;
2292: ClientPtr client;
2293: {
2294: WindowPtr pPrev;
2295: Bool WasMapped = (Bool)(pWin->realized);
2296: BoxRec box;
2297: xEvent event;
2298: short oldx, oldy;
2299: int bw;
2300: register ScreenPtr pScreen;
2301:
2302: if (pWin == pParent)
2303: return(BadWindow);
2304: if (TraverseTree(pWin, CompareWIDs, &pParent->wid) == WT_STOPWALKING)
2305: return(BadWindow);
2306:
2307: pScreen = pWin->drawable.pScreen;
2308: event.u.u.type = ReparentNotify;
2309: event.u.reparent.window = pWin->wid;
2310: event.u.reparent.parent = pParent->wid;
2311: event.u.reparent.x = x;
2312: event.u.reparent.y = y;
2313: event.u.reparent.override = pWin->overrideRedirect;
2314: DeliverEvents(pWin, &event, 1, pParent);
2315:
2316: oldx = pWin->absCorner.x;
2317: oldy = pWin->absCorner.y;
2318: if (WasMapped)
2319: UnmapWindow(pWin, HANDLE_EXPOSURES, SEND_NOTIFICATION, FALSE);
2320:
2321: /* take out of sibling chain */
2322:
2323: pPrev = pWin->parent;
2324: if (pPrev->firstChild == pWin)
2325: pPrev->firstChild = pWin->nextSib;
2326: if (pPrev->lastChild == pWin)
2327: pPrev->lastChild = pWin->prevSib;
2328:
2329: if (pWin->nextSib)
2330: pWin->nextSib->prevSib = pWin->prevSib;
2331: if (pWin->prevSib)
2332: pWin->prevSib->nextSib = pWin->nextSib;
2333:
2334: /* insert at begining of pParent */
2335: pWin->parent = pParent;
2336: pWin->nextSib = pParent->firstChild;
2337: pWin->prevSib = (WindowPtr )NULL;
2338: if (pParent->firstChild)
2339: pParent->firstChild->prevSib = pWin;
2340: else
2341: pParent->lastChild = pWin;
2342: pParent->firstChild = pWin;
2343:
2344: /* clip to parent */
2345: box.x1 = x + pParent->absCorner.x;
2346: box.y1 = y + pParent->absCorner.y;
2347: box.x2 = box.x1 + pWin->clientWinSize.width;
2348: box.y2 = box.y1+ pWin->clientWinSize.height;
2349: (* pScreen->RegionReset)(pWin->winSize, &box);
2350: (* pScreen->Intersect)(pWin->winSize, pWin->winSize,
2351: pParent->winSize);
2352:
2353: pWin->clientWinSize.x = x;
2354: pWin->clientWinSize.y = y;
2355: pWin->oldAbsCorner.x = oldx;
2356: pWin->oldAbsCorner.y = oldy;
2357: pWin->absCorner.x = box.x1;
2358: pWin->absCorner.y = box.y1;
2359:
2360: if (bw = pWin->borderWidth)
2361: {
2362: box.x1 -= bw;
2363: box.y1 -= bw;
2364: box.x2 += bw;
2365: box.y2 += bw;
2366: (* pScreen->RegionReset)(pWin->borderSize, &box);
2367: (* pScreen->Intersect)(pWin->borderSize, pWin->borderSize,
2368: pParent->winSize);
2369: }
2370: else
2371: (* pScreen->RegionCopy)(pWin->borderSize, pWin->winSize);
2372:
2373: (* pScreen->PositionWindow)(pWin, pWin->absCorner.x, pWin->absCorner.y);
2374: ResizeChildrenWinSize(pWin, FALSE, 0, 0, DONT_USE_GRAVITY);
2375:
2376: if (WasMapped)
2377: {
2378: MapWindow(pWin, HANDLE_EXPOSURES, BITS_DISCARDED, SEND_NOTIFICATION,
2379: client);
2380: }
2381: RecalculateDeliverableEvents(pParent);
2382: return(Success);
2383: }
2384:
2385: static int
2386: MarkChildren(pWin, box)
2387: WindowPtr pWin;
2388: BoxPtr box;
2389: {
2390: WindowPtr pChild;
2391: int anyMarked=0;
2392: register ScreenPtr pScreen;
2393:
2394: pScreen = pWin->drawable.pScreen;
2395: pChild = pWin->firstChild;
2396: while (pChild)
2397: {
2398: if (pChild->mapped && ((* pScreen->RectIn)(pChild->borderSize, box)))
2399: {
2400: anyMarked++;
2401: pChild->marked = 1;
2402: anyMarked += MarkChildren(pChild, box);
2403: }
2404: pChild = pChild->nextSib;
2405: }
2406: return(anyMarked);
2407: }
2408:
2409: static int
2410: MarkSiblingsBelowMe(pWin, box)
2411: WindowPtr pWin;
2412: BoxPtr box;
2413: {
2414: WindowPtr pSib;
2415: int anyMarked = 0;
2416: register ScreenPtr pScreen;
2417:
2418: pScreen = pWin->drawable.pScreen;
2419:
2420: pSib = pWin;
2421: while (pSib)
2422: {
2423: if (pSib->mapped && ((* pScreen->RectIn)(pSib->borderSize, box)))
2424: {
2425: pSib->marked = 1;
2426: anyMarked++;
2427: if (pSib->firstChild)
2428: anyMarked += MarkChildren(pSib, box);
2429: }
2430: pSib = pSib->nextSib;
2431: }
2432: return(anyMarked);
2433: }
2434:
2435:
2436: /*****
2437: * MapWindow
2438: * If some other client has selected SubStructureReDirect on the parent
2439: * and override-redirect is xFalse, then a MapRequest event is generated,
2440: * but the window remains unmapped. Otherwise, the window is mapped and a
2441: * MapNotify event is generated.
2442: *****/
2443:
2444: static void
2445: RealizeChildren(pWin, client)
2446: WindowPtr pWin;
2447: ClientPtr client;
2448: {
2449: WindowPtr pSib;
2450: Bool (* Realize)();
2451:
2452: pSib = pWin;
2453: if (pWin)
2454: Realize = pSib->drawable.pScreen->RealizeWindow;
2455: while (pSib)
2456: {
2457: if (pSib->mapped)
2458: {
2459: pSib->realized = TRUE;
2460: pSib->viewable = pSib->class == InputOutput;
2461: (* Realize)(pSib);
2462: FlushClientCaches(pSib->wid);
2463: if (pSib->firstChild)
2464: RealizeChildren(pSib->firstChild, client);
2465: }
2466: pSib = pSib->nextSib;
2467: }
2468: }
2469:
2470: int
2471: MapWindow(pWin, SendExposures, BitsAvailable, SendNotification, client)
2472:
2473: WindowPtr pWin;
2474: Bool SendExposures;
2475: Bool BitsAvailable;
2476: ClientPtr client;
2477: {
2478: register ScreenPtr pScreen;
2479:
2480: WindowPtr pParent;
2481: Bool anyMarked;
2482:
2483: if (pWin->mapped)
2484: return(Success);
2485: pScreen = pWin->drawable.pScreen;
2486: if (pParent = pWin->parent)
2487: {
2488: xEvent event;
2489: BoxPtr box;
2490:
2491: if (SendNotification && (!pWin->overrideRedirect) &&
2492: (pParent->allEventMasks & SubstructureRedirectMask))
2493: {
2494: event.u.u.type = MapRequest;
2495: event.u.mapRequest.window = pWin->wid;
2496: event.u.mapRequest.parent = pParent->wid;
2497:
2498: if (MaybeDeliverEventsToClient(pParent, &event, 1,
2499: SubstructureRedirectMask, client) == 1)
2500: return(Success);
2501: }
2502:
2503: pWin->mapped = 1;
2504: if (SendNotification)
2505: {
2506: event.u.u.type = MapNotify;
2507: event.u.mapNotify.window = pWin->wid;
2508: event.u.mapNotify.override = pWin->overrideRedirect;
2509: DeliverEvents(pWin, &event, 1, NullWindow);
2510: }
2511:
2512: pWin->marked = 0; /* so siblings get mapped correctly */
2513: if (!pParent->realized)
2514: return(Success);
2515: pWin->realized = TRUE;
2516: pWin->viewable = pWin->class == InputOutput;
2517: /* We SHOULD check for an error value here XXX */
2518: (* pScreen->RealizeWindow)(pWin);
2519: if (pWin->firstChild)
2520: RealizeChildren(pWin->firstChild, client);
2521: box = (* pScreen->RegionExtents)(pWin->borderSize);
2522: anyMarked = MarkSiblingsBelowMe(pWin, box);
2523:
2524: /* kludge; remove when miregion works! */
2525: if (!pParent->parent &&
2526: (box->x1 == pParent->winSize->extents.x1) &&
2527: (box->y1 == pParent->winSize->extents.y1) &&
2528: (box->x2 == pParent->winSize->extents.x2) &&
2529: (box->y2 == pParent->winSize->extents.y2) &&
2530: (pParent->firstChild == pWin)) {
2531: (*pWin->drawable.pScreen->RegionCopy)(pParent->clipList,
2532: pParent->winSize);
2533: }
2534: /* end of kludge */
2535:
2536: (* pScreen->ValidateTree)(pParent, pWin, TRUE, anyMarked);
2537: if (SendExposures)
2538: {
2539: if (!BitsAvailable)
2540: {
2541: (* pScreen->RegionCopy)(pWin->exposed, pWin->clipList);
2542: DoObscures(pParent);
2543: HandleExposures(pWin);
2544: }
2545: else
2546: {
2547: /*
2548: * Children shouldn't be in the parent's exposed region...
2549: (* pScreen->Subtract)(pParent->exposed, pParent->exposed,
2550: pWin->borderSize);
2551: */
2552: (* pScreen->RegionEmpty)(pWin->exposed);
2553: DoObscures(pParent);
2554: HandleExposures(pWin);
2555: }
2556: }
2557: }
2558: else
2559: {
2560: pWin->mapped = 1;
2561: pWin->realized = TRUE; /* for roots */
2562: pWin->viewable = pWin->class == InputOutput;
2563: /* We SHOULD check for an error value here XXX */
2564: (* pScreen->RealizeWindow)(pWin);
2565: }
2566:
2567: return(Success);
2568: }
2569:
2570:
2571: /*****
2572: * MapSubwindows
2573: * Performs a MapWindow all unmapped children of the window, in top
2574: * to bottom stacking order.
2575: *****/
2576:
2577: MapSubwindows(pWin, SendExposures, client)
2578: WindowPtr pWin;
2579: Bool SendExposures;
2580: ClientPtr client;
2581: {
2582: WindowPtr pChild;
2583:
2584: pChild = pWin->firstChild;
2585: while (pChild)
2586: {
2587: if (!pChild->mapped)
2588: /* What about backing store? */
2589: MapWindow(pChild, SendExposures, BITS_DISCARDED,
2590: SEND_NOTIFICATION, client);
2591: pChild = pChild->nextSib;
2592: }
2593: }
2594:
2595: /*****
2596: * UnmapWindow
2597: * If the window is already unmapped, this request has no effect.
2598: * Otherwise, the window is unmapped and an UnMapNotify event is
2599: * generated. Cannot unmap a root window.
2600: *****/
2601:
2602: static void
2603: UnrealizeChildren(pWin)
2604: WindowPtr pWin;
2605: {
2606: WindowPtr pSib;
2607: void (*RegionEmpty)();
2608: Bool (*Unrealize)();
2609:
2610: pSib = pWin;
2611: if (pWin)
2612: {
2613: RegionEmpty = pWin->drawable.pScreen->RegionEmpty;
2614: Unrealize = pWin->drawable.pScreen->UnrealizeWindow;
2615: }
2616: while (pSib)
2617: {
2618: pSib->realized = pSib->viewable = FALSE;
2619: (* Unrealize)(pSib);
2620: /* to force exposures later */
2621: (* RegionEmpty)(pSib->clipList);
2622: (* RegionEmpty)(pSib->borderClip);
2623: (* RegionEmpty)(pSib->exposed);
2624: pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
2625: DeleteWindowFromAnyEvents(pSib, FALSE);
2626: if (pSib->firstChild)
2627: UnrealizeChildren(pSib->firstChild);
2628: pSib = pSib->nextSib;
2629: }
2630: }
2631:
2632: UnmapWindow(pWin, SendExposures, SendNotification, fromConfigure)
2633: WindowPtr pWin;
2634: Bool SendExposures, fromConfigure;
2635: {
2636: WindowPtr pParent;
2637: xEvent event;
2638: Bool anyMarked;
2639: Bool wasMapped = (Bool)pWin->realized;
2640: BoxPtr box;
2641:
2642: if ((!pWin->mapped) || (!(pParent = pWin->parent)))
2643: return(Success);
2644: if (SendNotification)
2645: {
2646: event.u.u.type = UnmapNotify;
2647: event.u.unmapNotify.window = pWin->wid;
2648: event.u.unmapNotify.fromConfigure = fromConfigure;
2649: DeliverEvents(pWin, &event, 1, NullWindow);
2650: }
2651: if (wasMapped)
2652: {
2653: box = (* pWin->drawable.pScreen->RegionExtents)(pWin->borderSize);
2654: anyMarked = MarkSiblingsBelowMe(pWin, box);
2655: }
2656: pWin->mapped = 0;
2657: pWin->realized = pWin->viewable = FALSE;
2658: if (wasMapped)
2659: {
2660: /* We SHOULD check for an error value here XXX */
2661: (* pWin->drawable.pScreen->UnrealizeWindow)(pWin);
2662: DeleteWindowFromAnyEvents(pWin, FALSE);
2663: if (pWin->firstChild)
2664: UnrealizeChildren(pWin->firstChild);
2665: (* pWin->drawable.pScreen->ValidateTree)(pParent, pWin,
2666: TRUE, anyMarked);
2667: if (SendExposures)
2668: {
2669: HandleExposures(pParent);
2670: }
2671: }
2672: return(Success);
2673: }
2674:
2675: /*****
2676: * UnmapSubwindows
2677: * Performs an UnMapWindow request with the specified mode on all mapped
2678: * children of the window, in bottom to top stacking order.
2679: *
2680: * XXX: Should use the validation function, not mess with the clip lists
2681: * directly, though this way is faster.
2682: *****/
2683:
2684: UnmapSubwindows(pWin, sendExposures)
2685: WindowPtr pWin;
2686: Bool sendExposures;
2687: {
2688: WindowPtr pChild;
2689: xEvent event;
2690: void (*RegionEmpty)();
2691: Bool (*UnrealizeWindow)();
2692: Bool wasMapped = (Bool)pWin->realized;
2693:
2694: pChild = pWin->lastChild;
2695: event.u.u.type = UnmapNotify;
2696: event.u.unmapNotify.fromConfigure = xFalse;
2697: RegionEmpty = pWin->drawable.pScreen->RegionEmpty;
2698: UnrealizeWindow = pWin->drawable.pScreen->UnrealizeWindow;
2699: while (pChild)
2700: {
2701: if (pChild->mapped)
2702: {
2703: event.u.unmapNotify.window = pChild->wid;
2704: event.u.unmapNotify.fromConfigure = xFalse;
2705: DeliverEvents(pWin, &event, 1, NullWindow);
2706: pChild->mapped = 0;
2707: if (wasMapped)
2708: {
2709: pChild->realized = pChild->viewable = FALSE;
2710: /* We SHOULD check for an error value here XXX */
2711: (* UnrealizeWindow)(pChild);
2712: if (pChild->firstChild)
2713: UnrealizeChildren(pChild->firstChild);
2714: DeleteWindowFromAnyEvents(pChild, FALSE);
2715: (* RegionEmpty)(pChild->clipList);/* to force expsoures later*/
2716: (* RegionEmpty)(pChild->borderClip);
2717: (* RegionEmpty)(pChild->borderExposed);
2718: (* RegionEmpty)(pChild->exposed);
2719: pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;
2720: }
2721: }
2722: pChild = pChild->prevSib;
2723: }
2724: if ((pWin->lastChild) && wasMapped)
2725: {
2726: (* pWin->drawable.pScreen->Intersect)(pWin->clipList,
2727: pWin->winSize, pWin->borderClip);
2728: (* pWin->drawable.pScreen->RegionCopy)(pWin->exposed, pWin->clipList);
2729: HandleExposures(pWin);
2730: }
2731: }
2732:
2733:
2734: void
2735: HandleSaveSet(client)
2736: ClientPtr client;
2737: {
2738: WindowPtr pParent, pWin;
2739: int j;
2740:
2741: for (j=0; j<client->numSaved; j++)
2742: {
2743: pWin = (WindowPtr)client->saveSet[j];
2744: pParent = pWin->parent;
2745: while (pParent && (pParent->client == client))
2746: pParent = pParent->parent;
2747: if (pParent)
2748: {
2749: ReparentWindow(pWin, pParent, pWin->absCorner.x,
2750: pWin->absCorner.y, client);
2751: if(!pWin->realized && pWin->mapped)
2752: pWin->mapped = FALSE;
2753: MapWindow(pWin, HANDLE_EXPOSURES, BITS_DISCARDED,
2754: SEND_NOTIFICATION, client);
2755: }
2756: }
2757: }
2758:
2759: Bool
2760: VisibleBoundingBoxFromPoint(pWin, x, y, box)
2761: WindowPtr pWin;
2762: int x, y; /* in root */
2763: BoxPtr box; /* "return" value */
2764: {
2765: if (!pWin->realized)
2766: return (FALSE);
2767: if ((* pWin->drawable.pScreen->PointInRegion)(pWin->clipList, x, y, box))
2768: return(TRUE);
2769: return(FALSE);
2770: }
2771:
2772: Bool
2773: PointInWindowIsVisible(pWin, x, y)
2774: WindowPtr pWin;
2775: int x, y; /* in root */
2776: {
2777: BoxRec box;
2778:
2779: if (!pWin->realized)
2780: return (FALSE);
2781: if ((* pWin->drawable.pScreen->PointInRegion)(pWin->clipList, x, y, &box))
2782: return(TRUE);
2783: return(FALSE);
2784: }
2785:
2786:
2787: RegionPtr
2788: NotClippedByChildren(pWin)
2789: WindowPtr pWin;
2790: {
2791: register ScreenPtr pScreen;
2792: RegionPtr pReg;
2793:
2794: pScreen = pWin->drawable.pScreen;
2795: pReg = (* pScreen->RegionCreate)(NULL, 1);
2796: (* pScreen->Intersect) (pReg, pWin->borderClip, pWin->winSize);
2797: return(pReg);
2798: }
2799:
2800:
2801: void
2802: SendVisibilityNotify(pWin)
2803: WindowPtr pWin;
2804: {
2805: xEvent event;
2806: event.u.u.type = VisibilityNotify;
2807: event.u.visibility.window = pWin->wid;
2808: event.u.visibility.state = pWin->visibility;
2809: DeliverEvents(pWin, &event, 1, NullWindow);
2810: }
2811:
2812:
2813: #define RANDOM_WIDTH 32
2814:
2815: void
2816: SaveScreens(on, mode)
2817: int on;
2818: int mode;
2819: {
2820: int i, j;
2821: int what;
2822: unsigned char *srcbits, *mskbits;
2823:
2824: if (on == SCREEN_SAVER_FORCER)
2825: {
2826: if (mode == ScreenSaverReset)
2827: what = SCREEN_SAVER_OFF;
2828: else
2829: what = SCREEN_SAVER_ON;
2830: if (what == screenIsSaved)
2831: return ;
2832: }
2833: else
2834: what = on;
2835: for (i = 0; i < screenInfo.numScreens; i++)
2836: {
2837: if (on == SCREEN_SAVER_FORCER)
2838: {
2839: (* screenInfo.screen[i].SaveScreen) (&screenInfo.screen[i], on);
2840: }
2841: if (what == SCREEN_SAVER_OFF)
2842: {
2843: if (savedScreenInfo[i].blanked == SCREEN_IS_BLANKED)
2844: {
2845: (* screenInfo.screen[i].SaveScreen) (&screenInfo.screen[i], on);
2846: }
2847: else if (savedScreenInfo[i].blanked == SCREEN_IS_TILED)
2848: {
2849: FreeResource(savedScreenInfo[i].wid, RC_NONE);
2850: savedScreenInfo[i].pWindow = (WindowPtr)NULL;
2851: FreeResource(savedScreenInfo[i].cid, RC_NONE);
2852: }
2853: continue;
2854: }
2855: else if (what == SCREEN_SAVER_ON)
2856: {
2857: if (screenIsSaved == SCREEN_SAVER_ON) /* rotate pattern */
2858: {
2859: int new_x, new_y;
2860:
2861: if (savedScreenInfo[i].blanked == SCREEN_IS_TILED)
2862: {
2863: new_x = random() % RANDOM_WIDTH;
2864: new_y = random() % RANDOM_WIDTH;
2865: MoveWindow(savedScreenInfo[i].pWindow, -new_x, -new_y,
2866: savedScreenInfo[i].pWindow->nextSib);
2867: }
2868: continue;
2869: }
2870: if (ScreenSaverBlanking != DontPreferBlanking)
2871: {
2872: if ((* screenInfo.screen[i].SaveScreen)
2873: (&screenInfo.screen[i], what))
2874: {
2875: savedScreenInfo[i].blanked = SCREEN_IS_BLANKED;
2876: continue;
2877: }
2878: }
2879: if (ScreenSaverAllowExposures != DontAllowExposures)
2880: {
2881: int result;
2882: long attributes[1];
2883: int mask = CWBackPixmap;
2884: WindowPtr pWin;
2885: CursorMetricRec cm;
2886:
2887: if (WindowTable[i].backgroundTile ==
2888: (PixmapPtr)USE_BACKGROUND_PIXEL)
2889: {
2890: attributes[0] = WindowTable[i].backgroundPixel;
2891: mask = CWBackPixel;
2892: }
2893: else
2894: attributes[0] = None;
2895:
2896: pWin = savedScreenInfo[i].pWindow =
2897: /* We SHOULD check for an error value here XXX */
2898: CreateWindow(savedScreenInfo[i].wid,
2899: &WindowTable[i],
2900: -RANDOM_WIDTH, -RANDOM_WIDTH,
2901: screenInfo.screen[i].width + RANDOM_WIDTH,
2902: screenInfo.screen[i].height + RANDOM_WIDTH,
2903: 0, InputOutput, mask, attributes, 0, 0,
2904: WindowTable[i].visual, &result);
2905: if (attributes[0] == None)
2906: {
2907:
2908: pWin->backgroundTile = pWin->parent->backgroundTile;
2909: pWin->backgroundTile->refcnt++;
2910: (* screenInfo.screen[i].ChangeWindowAttributes)
2911: (pWin, CWBackPixmap);
2912: }
2913: AddResource(pWin->wid, RT_WINDOW,
2914: savedScreenInfo[i].pWindow,
2915: DeleteWindow, RC_CORE);
2916: cm.width=32;
2917: cm.height=16;
2918: cm.xhot=8;
2919: cm.yhot=8;
2920: srcbits = (unsigned char *)Xalloc( PixmapBytePad(32, 1)*16);
2921: mskbits = (unsigned char *)Xalloc( PixmapBytePad(32, 1)*16);
2922: for (j=0; j<PixmapBytePad(32, 1)*16; j++)
2923: srcbits[j] = mskbits[j] = 0x0;
2924: pWin->cursor = AllocCursor( srcbits, mskbits, &cm,
2925: ~0, ~0, ~0, 0, 0, 0);
2926: AddResource(savedScreenInfo[i].cid, RT_CURSOR,
2927: pWin->cursor,
2928: FreeCursor, RC_CORE);
2929: pWin->cursor->refcnt++;
2930: pWin->overrideRedirect = TRUE;
2931: MapWindow(pWin, TRUE, FALSE, FALSE, 0);
2932: savedScreenInfo[i].blanked = SCREEN_IS_TILED;
2933: }
2934: else
2935: savedScreenInfo[i].blanked = SCREEN_ISNT_SAVED;
2936: }
2937: }
2938: screenIsSaved = what;
2939: }
2940:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.