1 /* $XConsortium: window.c /main/210 1996/10/28 07:24:59 kaleb $ */
2 /* $XFree86: xc/programs/Xserver/dix/window.c,v 3.6 1997/01/18 06:53:16 dawes Exp $ */
5 Copyright (c) 1987 X Consortium
7 Permission is hereby granted, free of charge, to any person obtaining
8 a copy of this software and associated documentation files (the
9 "Software"), to deal in the Software without restriction, including
10 without limitation the rights to use, copy, modify, merge, publish,
11 distribute, sublicense, and/or sell copies of the Software, and to
12 permit persons to whom the Software is furnished to do so, subject to
13 the following conditions:
15 The above copyright notice and this permission notice shall be included
16 in all copies or substantial portions of the Software.
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
22 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 OTHER DEALINGS IN THE SOFTWARE.
26 Except as contained in this notice, the name of the X Consortium shall
27 not be used in advertising or otherwise to promote the sale, use or
28 other dealings in this Software without prior written authorization
29 from the X Consortium.
32 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
36 Permission to use, copy, modify, and distribute this software and its
37 documentation for any purpose and without fee is hereby granted,
38 provided that the above copyright notice appear in all copies and that
39 both that copyright notice and this permission notice appear in
40 supporting documentation, and that the name of Digital not be
41 used in advertising or publicity pertaining to distribution of the
42 software without specific, written prior permission.
44 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
45 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
46 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
47 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
48 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
49 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
55 #include "scrnintstr.h"
57 #include "regionstr.h"
59 #include "windowstr.h"
62 #include "colormapst.h"
63 #include "cursorstr.h"
64 #include "dixstruct.h"
67 #include "dixevents.h"
69 #include "extensions/Xagsrv.h"
72 #define _SECURITY_SERVER
73 #include "extensions/security.h"
76 extern Bool permitOldBugs;
78 #if defined(NEED_SCREEN_REGIONS)
79 #define REGION_PTR(pScreen,pWin) \
80 register ScreenPtr pScreen = pWin->drawable.pScreen;
82 #define REGION_PTR(pScreen,pWin) /* nothing */
86 * Window stuff for server
88 * CreateRootWindow, CreateWindow, ChangeWindowAttributes,
89 * GetWindowAttributes, DeleteWindow, DestroySubWindows,
90 * HandleSaveSet, ReparentWindow, MapWindow, MapSubWindows,
91 * UnmapWindow, UnmapSubWindows, ConfigureWindow, CirculateWindow,
95 static unsigned char _back_lsb[4] = {0x88, 0x22, 0x44, 0x11};
96 static unsigned char _back_msb[4] = {0x11, 0x44, 0x22, 0x88};
98 int screenIsSaved = SCREEN_SAVER_OFF;
100 ScreenSaverStuffRec savedScreenInfo[MAXSCREENS];
102 extern WindowPtr *WindowTable;
106 static Bool TileScreenSaver(
107 #if NeedFunctionPrototypes
114 #define INPUTONLY_LEGAL_MASK (CWWinGravity | CWEventMask | \
115 CWDontPropagate | CWOverrideRedirect | CWCursor )
117 #define BOXES_OVERLAP(b1, b2) \
118 (!( ((b1)->x2 <= (b2)->x1) || \
119 ( ((b1)->x1 >= (b2)->x2)) || \
120 ( ((b1)->y2 <= (b2)->y1)) || \
121 ( ((b1)->y1 >= (b2)->y2)) ) )
123 #define RedirectSend(pWin) \
124 ((pWin->eventMask|wOtherEventMasks(pWin)) & SubstructureRedirectMask)
126 #define SubSend(pWin) \
127 ((pWin->eventMask|wOtherEventMasks(pWin)) & SubstructureNotifyMask)
129 #define StrSend(pWin) \
130 ((pWin->eventMask|wOtherEventMasks(pWin)) & StructureNotifyMask)
132 #define SubStrSend(pWin,pParent) (StrSend(pWin) || SubSend(pParent))
135 int numSaveUndersViewable = 0;
136 int deltaSaveUndersViewable = 0;
145 PrintChildren(p1, indent)
155 for (i=0; i<indent; i++) ErrorF( " ");
156 ErrorF( "%x\n", p1->drawable.id);
157 miPrintRegion(&p1->clipList);
158 PrintChildren(p2, indent+4);
168 for (i=0; i<screenInfo.numScreens; i++)
170 ErrorF( "WINDOW %d\n", i);
171 pWin = WindowTable[i];
172 miPrintRegion(&pWin->clipList);
173 p1 = pWin->firstChild;
174 PrintChildren(p1, 4);
180 TraverseTree(pWin, func, data)
181 register WindowPtr pWin;
182 VisitWindowProcPtr func;
186 register WindowPtr pChild;
188 if (!(pChild = pWin))
192 result = (* func)(pChild, data);
193 if (result == WT_STOPWALKING)
194 return(WT_STOPWALKING);
195 if ((result == WT_WALKCHILDREN) && pChild->firstChild)
197 pChild = pChild->firstChild;
200 while (!pChild->nextSib && (pChild != pWin))
201 pChild = pChild->parent;
204 pChild = pChild->nextSib;
211 * Walk the window tree, for SCREEN, preforming FUNC(pWin, data) on
212 * each window. If FUNC returns WT_WALKCHILDREN, traverse the children,
213 * if it returns WT_DONTWALKCHILDREN, dont. If it returns WT_STOPWALKING
214 * exit WalkTree. Does depth-first traverse.
218 WalkTree(pScreen, func, data)
220 VisitWindowProcPtr func;
223 return(TraverseTree(WindowTable[pScreen->myNum], func, data));
226 /* hack for forcing backing store on all windows */
227 int defaultBackingStore = NotUseful;
228 /* hack to force no backing store */
229 Bool disableBackingStore = FALSE;
230 /* hack to force no save unders */
231 Bool disableSaveUnders = FALSE;
234 #if NeedFunctionPrototypes
235 SetWindowToDefaults(register WindowPtr pWin)
237 SetWindowToDefaults(pWin)
238 register WindowPtr pWin;
241 pWin->prevSib = NullWindow;
242 pWin->firstChild = NullWindow;
243 pWin->lastChild = NullWindow;
245 pWin->valdata = (ValidatePtr)NULL;
246 pWin->optional = (WindowOptPtr)NULL;
247 pWin->cursorIsNone = TRUE;
249 pWin->backingStore = NotUseful;
250 pWin->DIXsaveUnder = FALSE;
251 pWin->backStorage = (pointer) NULL;
253 pWin->mapped = FALSE; /* off */
254 pWin->realized = FALSE; /* off */
255 pWin->viewable = FALSE;
256 pWin->visibility = VisibilityNotViewable;
257 pWin->overrideRedirect = FALSE;
258 pWin->saveUnder = FALSE;
260 pWin->bitGravity = ForgetGravity;
261 pWin->winGravity = NorthWestGravity;
264 pWin->deliverableEvents = 0;
265 pWin->dontPropagate = 0;
266 pWin->forcedBS = FALSE;
267 #ifdef NEED_DBE_BUF_BITS
268 pWin->srcBuffer = DBE_FRONT_BUFFER;
269 pWin->dstBuffer = DBE_FRONT_BUFFER;
274 #if NeedFunctionPrototypes
275 MakeRootTile(WindowPtr pWin)
281 ScreenPtr pScreen = pWin->drawable.pScreen;
283 unsigned char back[128];
284 int len = BitmapBytePad(4);
285 register unsigned char *from, *to;
288 pWin->background.pixmap = (*pScreen->CreatePixmap)(pScreen, 4, 4,
291 pWin->backgroundState = BackgroundPixmap;
292 pGC = GetScratchGC(pScreen->rootDepth, pScreen);
293 if (!pWin->background.pixmap || !pGC)
294 FatalError("cound not create root tile");
297 CARD32 attributes[2];
299 attributes[0] = pScreen->whitePixel;
300 attributes[1] = pScreen->blackPixel;
302 (void)ChangeGC(pGC, GCForeground | GCBackground, attributes);
305 ValidateGC((DrawablePtr)pWin->background.pixmap, pGC);
307 from = (screenInfo.bitmapBitOrder == LSBFirst) ? _back_lsb : _back_msb;
310 for (i = 4; i > 0; i--, from++)
311 for (j = len; j > 0; j--)
314 (*pGC->ops->PutImage)((DrawablePtr)pWin->background.pixmap, pGC, 1,
315 0, 0, 4, 4, 0, XYBitmap, (char *)back);
322 AllocateWindow(pScreen)
327 register DevUnion *ppriv;
328 register unsigned *sizes;
329 register unsigned size;
332 pWin = (WindowPtr)xalloc(pScreen->totalWindowSize);
335 ppriv = (DevUnion *)(pWin + 1);
336 pWin->devPrivates = ppriv;
337 sizes = pScreen->WindowPrivateSizes;
338 ptr = (char *)(ppriv + pScreen->WindowPrivateLen);
339 for (i = pScreen->WindowPrivateLen; --i >= 0; ppriv++, sizes++)
341 if ( (size = *sizes) )
343 ppriv->ptr = (pointer)ptr;
347 ppriv->ptr = (pointer)NULL;
355 * Makes a window at initialization time for specified screen
359 CreateRootWindow(pScreen)
364 PixmapFormatRec *format;
366 pWin = AllocateWindow(pScreen);
370 savedScreenInfo[pScreen->myNum].pWindow = NULL;
371 savedScreenInfo[pScreen->myNum].wid = FakeClientID(0);
372 savedScreenInfo[pScreen->myNum].ExternalScreenSaver = NULL;
373 screenIsSaved = SCREEN_SAVER_OFF;
375 WindowTable[pScreen->myNum] = pWin;
377 pWin->drawable.pScreen = pScreen;
378 pWin->drawable.type = DRAWABLE_WINDOW;
380 pWin->drawable.depth = pScreen->rootDepth;
381 for (format = screenInfo.formats;
382 format->depth != pScreen->rootDepth;
385 pWin->drawable.bitsPerPixel = format->bitsPerPixel;
387 pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
389 pWin->parent = NullWindow;
390 SetWindowToDefaults(pWin);
392 pWin->optional = (WindowOptRec *) xalloc (sizeof (WindowOptRec));
394 pWin->optional->dontPropagateMask = 0;
395 pWin->optional->otherEventMasks = 0;
396 pWin->optional->otherClients = NULL;
397 pWin->optional->passiveGrabs = NULL;
398 pWin->optional->userProps = NULL;
399 pWin->optional->backingBitPlanes = ~0L;
400 pWin->optional->backingPixel = 0;
402 pWin->optional->boundingShape = NULL;
403 pWin->optional->clipShape = NULL;
406 pWin->optional->inputMasks = NULL;
408 pWin->optional->colormap = pScreen->defColormap;
409 pWin->optional->visual = pScreen->rootVisual;
411 pWin->nextSib = NullWindow;
413 pWin->drawable.id = FakeClientID(0);
415 pWin->origin.x = pWin->origin.y = 0;
416 pWin->drawable.height = pScreen->height;
417 pWin->drawable.width = pScreen->width;
418 pWin->drawable.x = pWin->drawable.y = 0;
422 box.x2 = pScreen->width;
423 box.y2 = pScreen->height;
424 REGION_INIT(pScreen, &pWin->clipList, &box, 1);
425 REGION_INIT(pScreen, &pWin->winSize, &box, 1);
426 REGION_INIT(pScreen, &pWin->borderSize, &box, 1);
427 REGION_INIT(pScreen, &pWin->borderClip, &box, 1);
429 pWin->drawable.class = InputOutput;
430 pWin->optional->visual = pScreen->rootVisual;
432 pWin->backgroundState = BackgroundPixel;
433 pWin->background.pixel = pScreen->whitePixel;
435 pWin->borderIsPixel = TRUE;
436 pWin->border.pixel = pScreen->blackPixel;
437 pWin->borderWidth = 0;
439 if (!AddResource(pWin->drawable.id, RT_WINDOW, (pointer)pWin))
442 if (disableBackingStore)
443 pScreen->backingStoreSupport = NotUseful;
445 #ifdef DO_SAVE_UNDERS
446 if ((pScreen->backingStoreSupport != NotUseful) &&
447 (pScreen->saveUnderSupport == NotUseful))
450 * If the screen has backing-store but no save-unders, let the
451 * clients know we can support save-unders using backing-store.
453 pScreen->saveUnderSupport = USE_DIX_SAVE_UNDERS;
455 #endif /* DO_SAVE_UNDERS */
457 if (disableSaveUnders)
458 pScreen->saveUnderSupport = NotUseful;
469 pScreen = pWin->drawable.pScreen;
470 if (!(*pScreen->CreateWindow)(pWin))
472 (*pScreen->PositionWindow)(pWin, 0, 0);
474 pWin->cursorIsNone = FALSE;
475 pWin->optional->cursor = rootCursor;
476 rootCursor->refcnt++;
478 pWin->backingStore = defaultBackingStore;
479 pWin->forcedBS = (defaultBackingStore != NotUseful);
480 /* We SHOULD check for an error value here XXX */
481 (*pScreen->ChangeWindowAttributes)(pWin,
482 CWBackPixmap|CWBorderPixel|CWCursor|CWBackingStore);
484 MapWindow(pWin, serverClient);
487 /* Set the region to the intersection of the rectangle and the
488 * window's winSize. The window is typically the parent of the
489 * window from which the region came.
493 ClippedRegionFromBox(pWin, Rgn, x, y, w, h)
494 register WindowPtr pWin;
499 REGION_PTR(pScreen, pWin)
502 box = *(REGION_EXTENTS(pScreen, &pWin->winSize));
503 /* we do these calculations to avoid overflows */
518 REGION_RESET(pScreen, Rgn, &box);
519 REGION_INTERSECT(pScreen, Rgn, Rgn, &pWin->winSize);
524 register WindowPtr pWin;
527 (screenIsSaved == SCREEN_SAVER_ON) &&
528 (HasSaverWindow (pWin->drawable.pScreen->myNum)))
529 return (pWin->firstChild);
536 * Makes a window in response to client request
540 CreateWindow(wid, pParent, x, y, w, h, bw, class, vmask, vlist,
541 depth, client, visual, error)
543 register WindowPtr pParent;
545 unsigned int w, h, bw;
554 register WindowPtr pWin;
556 register ScreenPtr pScreen;
561 PixmapFormatRec *format;
562 register WindowOptPtr ancwopt;
564 if (class == CopyFromParent)
565 class = pParent->drawable.class;
567 if ((class != InputOutput) && (class != InputOnly))
570 client->errorValue = class;
574 if ((class != InputOnly) && (pParent->drawable.class == InputOnly))
580 if ((class == InputOnly) && ((bw != 0) || (depth != 0)))
586 pScreen = pParent->drawable.pScreen;
588 if ((class == InputOutput) && (depth == 0))
589 depth = pParent->drawable.depth;
590 ancwopt = pParent->optional;
592 ancwopt = FindWindowWithOptional(pParent)->optional;
593 if (visual == CopyFromParent) {
597 if (client->appgroup && !pParent->parent &&
598 (ag_visual = XagRootVisual (client)))
602 visual = ancwopt->visual;
605 /* Find out if the depth and visual are acceptable for this Screen */
606 if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth))
609 for(idepth = 0; idepth < pScreen->numDepths; idepth++)
611 pDepth = (DepthPtr) &pScreen->allowedDepths[idepth];
612 if ((depth == pDepth->depth) || (depth == 0))
614 for (ivisual = 0; ivisual < pDepth->numVids; ivisual++)
616 if (visual == pDepth->vids[ivisual])
631 if (((vmask & (CWBorderPixmap | CWBorderPixel)) == 0) &&
632 (class != InputOnly) &&
633 (depth != pParent->drawable.depth))
639 if (((vmask & CWColormap) == 0) &&
640 (class != InputOnly) &&
641 ((visual != ancwopt->visual) || (ancwopt->colormap == None)))
647 pWin = AllocateWindow(pScreen);
653 pWin->drawable = pParent->drawable;
654 pWin->drawable.depth = depth;
655 if (depth == pParent->drawable.depth)
656 pWin->drawable.bitsPerPixel = pParent->drawable.bitsPerPixel;
659 for (format = screenInfo.formats; format->depth != depth; format++)
661 pWin->drawable.bitsPerPixel = format->bitsPerPixel;
663 if (class == InputOnly)
664 pWin->drawable.type = (short) UNDRAWABLE_WINDOW;
665 pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
667 pWin->drawable.id = wid;
668 pWin->drawable.class = class;
670 pWin->parent = pParent;
671 SetWindowToDefaults(pWin);
673 if (visual != ancwopt->visual)
675 if (!MakeWindowOptional (pWin))
681 pWin->optional->visual = visual;
682 pWin->optional->colormap = None;
685 pWin->borderWidth = bw;
687 /* can't let untrusted clients have background None windows;
688 * they make it too easy to steal window contents
690 if (client->trustLevel != XSecurityClientTrusted)
692 pWin->backgroundState = BackgroundPixel;
693 pWin->background.pixel = 0;
697 pWin->backgroundState = None;
699 pWin->borderIsPixel = pParent->borderIsPixel;
700 pWin->border = pParent->border;
701 if (pWin->borderIsPixel == FALSE)
702 pWin->border.pixmap->refcnt++;
704 pWin->origin.x = x + (int)bw;
705 pWin->origin.y = y + (int)bw;
706 pWin->drawable.width = w;
707 pWin->drawable.height = h;
708 pWin->drawable.x = pParent->drawable.x + x + (int)bw;
709 pWin->drawable.y = pParent->drawable.y + y + (int)bw;
711 /* set up clip list correctly for unobscured WindowPtr */
712 REGION_INIT(pScreen, &pWin->clipList, NullBox, 1);
713 REGION_INIT(pScreen, &pWin->borderClip, NullBox, 1);
714 REGION_INIT(pScreen, &pWin->winSize, NullBox, 1);
715 REGION_INIT(pScreen, &pWin->borderSize, NullBox, 1);
717 pHead = RealChildHead(pParent);
720 pWin->nextSib = pHead->nextSib;
722 pHead->nextSib->prevSib = pWin;
724 pParent->lastChild = pWin;
725 pHead->nextSib = pWin;
726 pWin->prevSib = pHead;
730 pWin->nextSib = pParent->firstChild;
731 if (pParent->firstChild)
732 pParent->firstChild->prevSib = pWin;
734 pParent->lastChild = pWin;
735 pParent->firstChild = pWin;
739 SetBorderSize (pWin);
741 /* We SHOULD check for an error value here XXX */
742 if (!(*pScreen->CreateWindow)(pWin))
745 DeleteWindow(pWin, None);
748 /* We SHOULD check for an error value here XXX */
749 (*pScreen->PositionWindow)(pWin, pWin->drawable.x, pWin->drawable.y);
751 if (!(vmask & CWEventMask))
752 RecalculateDeliverableEvents(pWin);
755 *error = ChangeWindowAttributes(pWin, vmask, vlist, wClient (pWin));
759 if (*error != Success)
761 DeleteWindow(pWin, None);
764 if (!(vmask & CWBackingStore) && (defaultBackingStore != NotUseful))
766 XID value = defaultBackingStore;
767 (void)ChangeWindowAttributes(pWin, CWBackingStore, &value, wClient (pWin));
768 pWin->forcedBS = TRUE;
771 if (SubSend(pParent))
773 event.u.u.type = CreateNotify;
774 event.u.createNotify.window = wid;
775 event.u.createNotify.parent = pParent->drawable.id;
776 event.u.createNotify.x = x;
777 event.u.createNotify.y = y;
778 event.u.createNotify.width = w;
779 event.u.createNotify.height = h;
780 event.u.createNotify.borderWidth = bw;
781 event.u.createNotify.override = pWin->overrideRedirect;
782 DeliverEvents(pParent, &event, 1, NullWindow);
789 #if NeedFunctionPrototypes
790 FreeWindowResources(register WindowPtr pWin)
792 FreeWindowResources(pWin)
793 register WindowPtr pWin;
796 register ScreenPtr pScreen = pWin->drawable.pScreen;
798 DeleteWindowFromAnySaveSet(pWin);
799 DeleteWindowFromAnySelections(pWin);
800 DeleteWindowFromAnyEvents(pWin, TRUE);
801 REGION_UNINIT(pScreen, &pWin->clipList);
802 REGION_UNINIT(pScreen, &pWin->winSize);
803 REGION_UNINIT(pScreen, &pWin->borderClip);
804 REGION_UNINIT(pScreen, &pWin->borderSize);
806 if (wBoundingShape (pWin))
807 REGION_DESTROY(pScreen, wBoundingShape (pWin));
808 if (wClipShape (pWin))
809 REGION_DESTROY(pScreen, wClipShape (pWin));
811 if (pWin->borderIsPixel == FALSE)
812 (*pScreen->DestroyPixmap)(pWin->border.pixmap);
813 if (pWin->backgroundState == BackgroundPixmap)
814 (*pScreen->DestroyPixmap)(pWin->background.pixmap);
816 DeleteAllWindowProperties(pWin);
817 /* We SHOULD check for an error value here XXX */
818 (*pScreen->DestroyWindow)(pWin);
819 DisposeWindowOptional (pWin);
823 #if NeedFunctionPrototypes
824 CrushTree(WindowPtr pWin)
830 register WindowPtr pChild, pSib, pParent;
831 UnrealizeWindowProcPtr UnrealizeWindow;
834 if (!(pChild = pWin->firstChild))
836 UnrealizeWindow = pWin->drawable.pScreen->UnrealizeWindow;
839 if (pChild->firstChild)
841 pChild = pChild->firstChild;
846 pParent = pChild->parent;
847 if (SubStrSend(pChild, pParent))
849 event.u.u.type = DestroyNotify;
850 event.u.destroyNotify.window = pChild->drawable.id;
851 DeliverEvents(pChild, &event, 1, NullWindow);
853 FreeResource(pChild->drawable.id, RT_WINDOW);
854 pSib = pChild->nextSib;
855 #ifdef DO_SAVE_UNDERS
856 if (pChild->saveUnder && pChild->viewable)
857 deltaSaveUndersViewable--;
859 pChild->viewable = FALSE;
860 if (pChild->realized)
862 pChild->realized = FALSE;
863 (*UnrealizeWindow)(pChild);
865 FreeWindowResources(pChild);
867 if ( (pChild = pSib) )
870 pChild->firstChild = NullWindow;
871 pChild->lastChild = NullWindow;
880 * Deletes child of window then window itself
881 * If wid is None, don't send any events
886 DeleteWindow(value, wid)
890 register WindowPtr pParent;
891 register WindowPtr pWin = (WindowPtr)value;
894 UnmapWindow(pWin, FALSE);
898 pParent = pWin->parent;
899 if (wid && pParent && SubStrSend(pWin, pParent))
901 event.u.u.type = DestroyNotify;
902 event.u.destroyNotify.window = pWin->drawable.id;
903 DeliverEvents(pWin, &event, 1, NullWindow);
906 FreeWindowResources(pWin);
909 if (pParent->firstChild == pWin)
910 pParent->firstChild = pWin->nextSib;
911 if (pParent->lastChild == pWin)
912 pParent->lastChild = pWin->prevSib;
914 pWin->nextSib->prevSib = pWin->prevSib;
916 pWin->prevSib->nextSib = pWin->nextSib;
924 DestroySubwindows(pWin, client)
925 register WindowPtr pWin;
929 * The protocol is quite clear that each window should be
930 * destroyed in turn, however, unmapping all of the first
931 * eliminates most of the calls to ValidateTree. So,
932 * this implementation is incorrect in that all of the
933 * UnmapNotifies occur before all of the DestroyNotifies.
934 * If you care, simply delete the call to UnmapSubwindows.
936 UnmapSubwindows(pWin);
937 while (pWin->lastChild)
938 FreeResource(pWin->lastChild->drawable.id, RT_NONE);
941 #define DeviceEventMasks (KeyPressMask | KeyReleaseMask | ButtonPressMask | \
942 ButtonReleaseMask | PointerMotionMask)
945 * ChangeWindowAttributes
947 * The value-mask specifies which attributes are to be changed; the
948 * value-list contains one value for each one bit in the mask, from least
949 * to most significant bit in the mask.
953 ChangeWindowAttributes(pWin, vmask, vlist, client)
954 register WindowPtr pWin;
959 register Mask index2;
960 register XID *pVlist;
963 CursorPtr pCursor, pOldCursor;
970 register ScreenPtr pScreen;
975 Bool checkOptional = FALSE;
976 Bool borderRelative = FALSE;
979 if ((pWin->drawable.class == InputOnly) && (vmask & (~INPUTONLY_LEGAL_MASK)))
983 pScreen = pWin->drawable.pScreen;
988 index2 = (Mask) lowbit (tmask);
993 pixID = (Pixmap )*pVlist;
995 if (pWin->backgroundState == ParentRelative)
996 borderRelative = TRUE;
1000 /* can't let untrusted clients have background None windows */
1001 if (client->trustLevel == XSecurityClientTrusted)
1004 if (pWin->backgroundState == BackgroundPixmap)
1005 (*pScreen->DestroyPixmap)(pWin->background.pixmap);
1009 pWin->backgroundState = None;
1013 { /* didn't change the background to None, so don't tell ddx */
1018 else if (pixID == ParentRelative)
1021 pWin->drawable.depth != pWin->parent->drawable.depth)
1026 if (pWin->backgroundState == BackgroundPixmap)
1027 (*pScreen->DestroyPixmap)(pWin->background.pixmap);
1031 pWin->backgroundState = ParentRelative;
1032 borderRelative = TRUE;
1033 /* Note that the parent's backgroundTile's refcnt is NOT
1038 pPixmap = (PixmapPtr)SecurityLookupIDByType(client, pixID,
1039 RT_PIXMAP, SecurityReadAccess);
1040 if (pPixmap != (PixmapPtr) NULL)
1042 if ((pPixmap->drawable.depth != pWin->drawable.depth) ||
1043 (pPixmap->drawable.pScreen != pScreen))
1048 if (pWin->backgroundState == BackgroundPixmap)
1049 (*pScreen->DestroyPixmap)(pWin->background.pixmap);
1050 pWin->backgroundState = BackgroundPixmap;
1051 pWin->background.pixmap = pPixmap;
1057 client->errorValue = pixID;
1063 if (pWin->backgroundState == ParentRelative)
1064 borderRelative = TRUE;
1065 if (pWin->backgroundState == BackgroundPixmap)
1066 (*pScreen->DestroyPixmap)(pWin->background.pixmap);
1067 pWin->backgroundState = BackgroundPixel;
1068 pWin->background.pixel = (CARD32 ) *pVlist;
1069 /* background pixel overrides background pixmap,
1070 so don't let the ddx layer see both bits */
1071 vmaskCopy &= ~CWBackPixmap;
1074 case CWBorderPixmap:
1075 pixID = (Pixmap ) *pVlist;
1077 if (pixID == CopyFromParent)
1079 if (!pWin->parent ||
1080 (pWin->drawable.depth != pWin->parent->drawable.depth))
1085 if (pWin->borderIsPixel == FALSE)
1086 (*pScreen->DestroyPixmap)(pWin->border.pixmap);
1087 pWin->border = pWin->parent->border;
1088 if ((pWin->borderIsPixel = pWin->parent->borderIsPixel) == TRUE)
1090 index2 = CWBorderPixel;
1094 pWin->parent->border.pixmap->refcnt++;
1099 pPixmap = (PixmapPtr)SecurityLookupIDByType(client, pixID,
1100 RT_PIXMAP, SecurityReadAccess);
1103 if ((pPixmap->drawable.depth != pWin->drawable.depth) ||
1104 (pPixmap->drawable.pScreen != pScreen))
1109 if (pWin->borderIsPixel == FALSE)
1110 (*pScreen->DestroyPixmap)(pWin->border.pixmap);
1111 pWin->borderIsPixel = FALSE;
1112 pWin->border.pixmap = pPixmap;
1118 client->errorValue = pixID;
1124 if (pWin->borderIsPixel == FALSE)
1125 (*pScreen->DestroyPixmap)(pWin->border.pixmap);
1126 pWin->borderIsPixel = TRUE;
1127 pWin->border.pixel = (CARD32) *pVlist;
1128 /* border pixel overrides border pixmap,
1129 so don't let the ddx layer see both bits */
1130 vmaskCopy &= ~CWBorderPixmap;
1134 val = (CARD8 )*pVlist;
1136 if (val > StaticGravity)
1139 client->errorValue = val;
1142 pWin->bitGravity = val;
1145 val = (CARD8 )*pVlist;
1147 if (val > StaticGravity)
1150 client->errorValue = val;
1153 pWin->winGravity = val;
1155 case CWBackingStore:
1156 val = (CARD8 )*pVlist;
1158 if ((val != NotUseful) && (val != WhenMapped) && (val != Always))
1161 client->errorValue = val;
1164 pWin->backingStore = val;
1165 pWin->forcedBS = FALSE;
1167 case CWBackingPlanes:
1168 if (pWin->optional || ((CARD32)*pVlist != (CARD32)~0L)) {
1169 if (!pWin->optional && !MakeWindowOptional (pWin))
1174 pWin->optional->backingBitPlanes = (CARD32) *pVlist;
1175 if ((CARD32)*pVlist == (CARD32)~0L)
1176 checkOptional = TRUE;
1180 case CWBackingPixel:
1181 if (pWin->optional || (CARD32) *pVlist) {
1182 if (!pWin->optional && !MakeWindowOptional (pWin))
1187 pWin->optional->backingPixel = (CARD32) *pVlist;
1189 checkOptional = TRUE;
1194 val = (BOOL) *pVlist;
1196 if ((val != xTrue) && (val != xFalse))
1199 client->errorValue = val;
1202 #ifdef DO_SAVE_UNDERS
1203 if (pWin->parent && (pWin->saveUnder != val) && (pWin->viewable) &&
1204 DO_SAVE_UNDERS(pWin))
1207 * Re-check all siblings and inferiors for obscurity or
1208 * exposition (hee hee).
1210 if (pWin->saveUnder)
1211 deltaSaveUndersViewable--;
1213 deltaSaveUndersViewable++;
1214 pWin->saveUnder = val;
1216 if (pWin->firstChild)
1218 pLayerWin = (*pScreen->GetLayerWindow)(pWin);
1219 if ((*pScreen->ChangeSaveUnder)(pLayerWin->parent, pWin->nextSib))
1220 (*pScreen->PostChangeSaveUnder)(pLayerWin->parent,
1225 if ((*pScreen->ChangeSaveUnder)(pWin, pWin->nextSib))
1226 (*pScreen->PostChangeSaveUnder)(pWin,
1232 /* If we're changing the saveUnder attribute of the root
1233 * window, all we do is set pWin->saveUnder so that
1234 * GetWindowAttributes returns the right value. We don't
1235 * do the "normal" save-under processing (as above).
1236 * Hope that doesn't cause any problems.
1238 pWin->saveUnder = val;
1241 pWin->saveUnder = val;
1242 #endif /* DO_SAVE_UNDERS */
1245 result = EventSelectForWindow(pWin, client, (Mask )*pVlist);
1253 case CWDontPropagate:
1254 result = EventSuppressForWindow(pWin, client, (Mask )*pVlist,
1263 case CWOverrideRedirect:
1264 val = (BOOL ) *pVlist;
1266 if ((val != xTrue) && (val != xFalse))
1269 client->errorValue = val;
1272 pWin->overrideRedirect = val;
1275 cmap = (Colormap) *pVlist;
1277 if (cmap == CopyFromParent)
1280 Colormap ag_colormap;
1281 ClientPtr win_owner;
1284 * win_owner == client for CreateWindow, other clients
1285 * can ChangeWindowAttributes
1287 win_owner = LookupClient (pWin->drawable.id, client);
1289 if ( win_owner && win_owner->appgroup &&
1290 !pWin->parent->parent &&
1291 (ag_colormap = XagDefaultColormap (win_owner)))
1297 pWin->optional->visual == wVisual (pWin->parent)))
1299 cmap = wColormap (pWin->parent);
1309 pCmap = (ColormapPtr)SecurityLookupIDByType(client, cmap,
1310 RT_COLORMAP, SecurityReadAccess);
1314 client->errorValue = cmap;
1317 if (pCmap->pVisual->vid != wVisual (pWin) ||
1318 pCmap->pScreen != pScreen)
1323 if (cmap != wColormap (pWin))
1325 if (!pWin->optional)
1327 if (!MakeWindowOptional (pWin))
1333 else if (pWin->parent && cmap == wColormap (pWin->parent))
1334 checkOptional = TRUE;
1337 * propagate the original colormap to any children
1341 for (pChild = pWin->firstChild; pChild; pChild=pChild->nextSib)
1343 if (!pChild->optional && !MakeWindowOptional (pChild))
1350 pWin->optional->colormap = cmap;
1353 * check on any children now matching the new colormap
1356 for (pChild = pWin->firstChild; pChild; pChild=pChild->nextSib)
1358 if (pChild->optional->colormap == cmap)
1359 CheckWindowOptionalNeed (pChild);
1362 xE.u.u.type = ColormapNotify;
1363 xE.u.colormap.window = pWin->drawable.id;
1364 xE.u.colormap.colormap = cmap;
1365 xE.u.colormap.new = xTrue;
1366 xE.u.colormap.state = IsMapInstalled(cmap, pWin);
1367 DeliverEvents(pWin, &xE, 1, NullWindow);
1371 cursorID = (Cursor ) *pVlist;
1376 if ( cursorID == None)
1378 if (pWin == WindowTable[pWin->drawable.pScreen->myNum])
1379 pCursor = rootCursor;
1381 pCursor = (CursorPtr) None;
1385 pCursor = (CursorPtr)SecurityLookupIDByType(client, cursorID,
1386 RT_CURSOR, SecurityReadAccess);
1390 client->errorValue = cursorID;
1395 if (pCursor != wCursor (pWin))
1398 * patch up child windows so they don't lose cursors.
1401 for (pChild = pWin->firstChild; pChild; pChild=pChild->nextSib)
1403 if (!pChild->optional && !pChild->cursorIsNone &&
1404 !MakeWindowOptional (pChild))
1412 if (pCursor == (CursorPtr) None)
1414 pWin->cursorIsNone = TRUE;
1417 pOldCursor = pWin->optional->cursor;
1418 pWin->optional->cursor = (CursorPtr) None;
1419 checkOptional = TRUE;
1422 if (!pWin->optional)
1424 if (!MakeWindowOptional (pWin))
1430 else if (pWin->parent && pCursor == wCursor (pWin->parent))
1431 checkOptional = TRUE;
1432 pOldCursor = pWin->optional->cursor;
1433 pWin->optional->cursor = pCursor;
1435 pWin->cursorIsNone = FALSE;
1437 * check on any children now matching the new cursor
1440 for (pChild=pWin->firstChild; pChild; pChild=pChild->nextSib)
1442 if (pChild->optional &&
1443 (pChild->optional->cursor == pCursor))
1444 CheckWindowOptionalNeed (pChild);
1449 WindowHasNewCursor( pWin);
1451 /* Can't free cursor until here - old cursor
1452 * is needed in WindowHasNewCursor
1455 FreeCursor (pOldCursor, (Cursor)0);
1460 client->errorValue = vmask;
1463 vmaskCopy |= index2;
1467 CheckWindowOptionalNeed (pWin);
1469 /* We SHOULD check for an error value here XXX */
1470 (*pScreen->ChangeWindowAttributes)(pWin, vmaskCopy);
1473 If the border contents have changed, redraw the border.
1474 Note that this has to be done AFTER pScreen->ChangeWindowAttributes
1475 for the tile to be rotated, and the correct function selected.
1477 if (((vmaskCopy & (CWBorderPixel | CWBorderPixmap)) || borderRelative)
1478 && pWin->viewable && HasBorder (pWin))
1482 REGION_INIT(pScreen, &exposed, NullBox, 0);
1483 REGION_SUBTRACT(pScreen, &exposed, &pWin->borderClip, &pWin->winSize);
1484 (*pWin->drawable.pScreen->PaintWindowBorder)(pWin, &exposed, PW_BORDER);
1485 REGION_UNINIT(pScreen, &exposed);
1492 * GetWindowAttributes
1493 * Notice that this is different than ChangeWindowAttributes
1497 GetWindowAttributes(pWin, client, wa)
1498 register WindowPtr pWin;
1500 xGetWindowAttributesReply *wa;
1503 wa->bitGravity = pWin->bitGravity;
1504 wa->winGravity = pWin->winGravity;
1505 if (pWin->forcedBS && pWin->backingStore != Always)
1506 wa->backingStore = NotUseful;
1508 wa->backingStore = pWin->backingStore;
1509 wa->length = (sizeof(xGetWindowAttributesReply) -
1510 sizeof(xGenericReply)) >> 2;
1511 wa->sequenceNumber = client->sequence;
1512 wa->backingBitPlanes = wBackingBitPlanes (pWin);
1513 wa->backingPixel = wBackingPixel (pWin);
1514 wa->saveUnder = (BOOL)pWin->saveUnder;
1515 wa->override = pWin->overrideRedirect;
1517 wa->mapState = IsUnmapped;
1518 else if (pWin->realized)
1519 wa->mapState = IsViewable;
1521 wa->mapState = IsUnviewable;
1523 wa->colormap = wColormap (pWin);
1524 wa->mapInstalled = (wa->colormap == None) ? xFalse
1525 : IsMapInstalled(wa->colormap, pWin);
1527 wa->yourEventMask = EventMaskForClient(pWin, client);
1528 wa->allEventMasks = pWin->eventMask | wOtherEventMasks (pWin);
1529 wa->doNotPropagateMask = wDontPropagateMask (pWin);
1530 wa->class = pWin->drawable.class;
1531 wa->visualID = wVisual (pWin);
1536 MoveWindowInStack(pWin, pNextSib)
1537 register WindowPtr pWin, pNextSib;
1539 register WindowPtr pParent = pWin->parent;
1540 WindowPtr pFirstChange = pWin; /* highest window where list changes */
1542 if (pWin->nextSib != pNextSib)
1544 if (!pNextSib) /* move to bottom */
1546 if (pParent->firstChild == pWin)
1547 pParent->firstChild = pWin->nextSib;
1548 /* if (pWin->nextSib) */ /* is always True: pNextSib == NULL
1549 * and pWin->nextSib != pNextSib
1550 * therefore pWin->nextSib != NULL */
1551 pFirstChange = pWin->nextSib;
1552 pWin->nextSib->prevSib = pWin->prevSib;
1554 pWin->prevSib->nextSib = pWin->nextSib;
1555 pParent->lastChild->nextSib = pWin;
1556 pWin->prevSib = pParent->lastChild;
1557 pWin->nextSib = NullWindow;
1558 pParent->lastChild = pWin;
1560 else if (pParent->firstChild == pNextSib) /* move to top */
1562 pFirstChange = pWin;
1563 if (pParent->lastChild == pWin)
1564 pParent->lastChild = pWin->prevSib;
1566 pWin->nextSib->prevSib = pWin->prevSib;
1568 pWin->prevSib->nextSib = pWin->nextSib;
1569 pWin->nextSib = pParent->firstChild;
1570 pWin->prevSib = (WindowPtr ) NULL;
1571 pNextSib->prevSib = pWin;
1572 pParent->firstChild = pWin;
1574 else /* move in middle of list */
1576 WindowPtr pOldNext = pWin->nextSib;
1578 pFirstChange = NullWindow;
1579 if (pParent->firstChild == pWin)
1580 pFirstChange = pParent->firstChild = pWin->nextSib;
1581 if (pParent->lastChild == pWin) {
1582 pFirstChange = pWin;
1583 pParent->lastChild = pWin->prevSib;
1586 pWin->nextSib->prevSib = pWin->prevSib;
1588 pWin->prevSib->nextSib = pWin->nextSib;
1589 pWin->nextSib = pNextSib;
1590 pWin->prevSib = pNextSib->prevSib;
1591 if (pNextSib->prevSib)
1592 pNextSib->prevSib->nextSib = pWin;
1593 pNextSib->prevSib = pWin;
1594 if (!pFirstChange) { /* do we know it yet? */
1595 pFirstChange = pParent->firstChild; /* no, search from top */
1596 while ((pFirstChange != pWin) && (pFirstChange != pOldNext))
1597 pFirstChange = pFirstChange->nextSib;
1602 return( pFirstChange );
1606 CreateUnclippedWinSize (pWin)
1607 register WindowPtr pWin;
1612 box.x1 = pWin->drawable.x;
1613 box.y1 = pWin->drawable.y;
1614 box.x2 = pWin->drawable.x + (int) pWin->drawable.width;
1615 box.y2 = pWin->drawable.y + (int) pWin->drawable.height;
1616 pRgn = REGION_CREATE(pWin->drawable.pScreen, &box, 1);
1618 if (wBoundingShape (pWin) || wClipShape (pWin)) {
1619 REGION_PTR(pScreen, pWin)
1621 REGION_TRANSLATE(pScreen, pRgn, - pWin->drawable.x,
1622 - pWin->drawable.y);
1623 if (wBoundingShape (pWin))
1624 REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
1625 if (wClipShape (pWin))
1626 REGION_INTERSECT(pScreen, pRgn, pRgn, wClipShape (pWin));
1627 REGION_TRANSLATE(pScreen, pRgn, pWin->drawable.x, pWin->drawable.y);
1635 register WindowPtr pWin;
1637 ClippedRegionFromBox(pWin->parent, &pWin->winSize,
1638 pWin->drawable.x, pWin->drawable.y,
1639 (int)pWin->drawable.width,
1640 (int)pWin->drawable.height);
1642 if (wBoundingShape (pWin) || wClipShape (pWin)) {
1643 REGION_PTR(pScreen, pWin)
1645 REGION_TRANSLATE(pScreen, &pWin->winSize, - pWin->drawable.x,
1646 - pWin->drawable.y);
1647 if (wBoundingShape (pWin))
1648 REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
1649 wBoundingShape (pWin));
1650 if (wClipShape (pWin))
1651 REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
1653 REGION_TRANSLATE(pScreen, &pWin->winSize, pWin->drawable.x,
1660 SetBorderSize (pWin)
1661 register WindowPtr pWin;
1665 if (HasBorder (pWin)) {
1666 bw = wBorderWidth (pWin);
1667 ClippedRegionFromBox(pWin->parent, &pWin->borderSize,
1668 pWin->drawable.x - bw, pWin->drawable.y - bw,
1669 (int)(pWin->drawable.width + (bw<<1)),
1670 (int)(pWin->drawable.height + (bw<<1)));
1672 if (wBoundingShape (pWin)) {
1673 REGION_PTR(pScreen, pWin)
1675 REGION_TRANSLATE(pScreen, &pWin->borderSize, - pWin->drawable.x,
1676 - pWin->drawable.y);
1677 REGION_INTERSECT(pScreen, &pWin->borderSize, &pWin->borderSize,
1678 wBoundingShape (pWin));
1679 REGION_TRANSLATE(pScreen, &pWin->borderSize, pWin->drawable.x,
1681 REGION_UNION(pScreen, &pWin->borderSize, &pWin->borderSize,
1686 REGION_COPY(pWin->drawable.pScreen, &pWin->borderSize,
1692 GravityTranslate (x, y, oldx, oldy, dw, dh, gravity, destx, desty)
1693 register int x, y; /* new window position */
1694 int oldx, oldy; /* old window position */
1697 register int *destx, *desty; /* position relative to gravity */
1701 *destx = x + dw / 2;
1704 case NorthEastGravity:
1710 *desty = y + dh / 2;
1713 *destx = x + dw / 2;
1714 *desty = y + dh / 2;
1718 *desty = y + dh / 2;
1720 case SouthWestGravity:
1725 *destx = x + dw / 2;
1728 case SouthEastGravity:
1743 /* XXX need to retile border on each window with ParentRelative origin */
1745 ResizeChildrenWinSize(pWin, dx, dy, dw, dh)
1746 register WindowPtr pWin;
1749 register ScreenPtr pScreen;
1750 register WindowPtr pSib, pChild;
1751 Bool resized = (dw || dh);
1753 pScreen = pWin->drawable.pScreen;
1755 for (pSib = pWin->firstChild; pSib; pSib = pSib->nextSib)
1757 if (resized && (pSib->winGravity > NorthWestGravity))
1761 cwsx = pSib->origin.x;
1762 cwsy = pSib->origin.y;
1763 GravityTranslate (cwsx, cwsy, cwsx - dx, cwsy - dy, dw, dh,
1764 pSib->winGravity, &cwsx, &cwsy);
1765 if (cwsx != pSib->origin.x || cwsy != pSib->origin.y)
1769 event.u.u.type = GravityNotify;
1770 event.u.gravity.window = pSib->drawable.id;
1771 event.u.gravity.x = cwsx - wBorderWidth (pSib);
1772 event.u.gravity.y = cwsy - wBorderWidth (pSib);
1773 DeliverEvents (pSib, &event, 1, NullWindow);
1774 pSib->origin.x = cwsx;
1775 pSib->origin.y = cwsy;
1778 pSib->drawable.x = pWin->drawable.x + pSib->origin.x;
1779 pSib->drawable.y = pWin->drawable.y + pSib->origin.y;
1781 SetBorderSize (pSib);
1782 (*pScreen->PositionWindow)(pSib, pSib->drawable.x, pSib->drawable.y);
1783 if ( (pChild = pSib->firstChild) )
1787 pChild->drawable.x = pChild->parent->drawable.x +
1789 pChild->drawable.y = pChild->parent->drawable.y +
1791 SetWinSize (pChild);
1792 SetBorderSize (pChild);
1793 (*pScreen->PositionWindow)(pChild,
1794 pChild->drawable.x, pChild->drawable.y);
1795 if (pChild->firstChild)
1797 pChild = pChild->firstChild;
1800 while (!pChild->nextSib && (pChild != pSib))
1801 pChild = pChild->parent;
1804 pChild = pChild->nextSib;
1810 #define GET_INT16(m, f) \
1813 f = (INT16) *pVlist;\
1816 #define GET_CARD16(m, f) \
1819 f = (CARD16) *pVlist;\
1823 #define GET_CARD8(m, f) \
1826 f = (CARD8) *pVlist;\
1830 #define ChangeMask ((Mask)(CWX | CWY | CWWidth | CWHeight))
1832 #define IllegalInputOnlyConfigureMask (CWBorderWidth)
1836 * returns Above if pSib above pMe in stack or Below otherwise
1840 #if NeedFunctionPrototypes
1842 register WindowPtr pMe,
1843 register WindowPtr pSib)
1845 IsSiblingAboveMe(pMe, pSib)
1846 register WindowPtr pMe, pSib;
1849 register WindowPtr pWin;
1851 pWin = pMe->parent->firstChild;
1856 else if (pWin == pMe)
1858 pWin = pWin->nextSib;
1864 #if NeedFunctionPrototypes
1866 register WindowPtr pWin,
1867 register BoxPtr pBox)
1869 WindowExtents(pWin, pBox)
1870 register WindowPtr pWin;
1871 register BoxPtr pBox;
1874 pBox->x1 = pWin->drawable.x - wBorderWidth (pWin);
1875 pBox->y1 = pWin->drawable.y - wBorderWidth (pWin);
1876 pBox->x2 = pWin->drawable.x + (int)pWin->drawable.width
1877 + wBorderWidth (pWin);
1878 pBox->y2 = pWin->drawable.y + (int)pWin->drawable.height
1879 + wBorderWidth (pWin);
1884 #define IS_SHAPED(pWin) (wBoundingShape (pWin) != (RegionPtr) NULL)
1887 #if NeedFunctionPrototypes
1888 MakeBoundingRegion (
1889 register WindowPtr pWin,
1892 MakeBoundingRegion (pWin, pBox)
1893 register WindowPtr pWin;
1898 REGION_PTR(pScreen, pWin)
1900 pRgn = REGION_CREATE(pScreen, pBox, 1);
1901 if (wBoundingShape (pWin)) {
1902 REGION_TRANSLATE(pScreen, pRgn, -pWin->origin.x,
1904 REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
1905 REGION_TRANSLATE(pScreen, pRgn, pWin->origin.x,
1912 #if NeedFunctionPrototypes
1919 ShapeOverlap (pWin, pWinBox, pSib, pSibBox)
1920 WindowPtr pWin, pSib;
1921 BoxPtr pWinBox, pSibBox;
1924 RegionPtr pWinRgn, pSibRgn;
1925 register ScreenPtr pScreen;
1928 if (!IS_SHAPED(pWin) && !IS_SHAPED(pSib))
1930 pScreen = pWin->drawable.pScreen;
1931 pWinRgn = MakeBoundingRegion (pWin, pWinBox);
1932 pSibRgn = MakeBoundingRegion (pSib, pSibBox);
1933 REGION_INTERSECT(pScreen, pWinRgn, pWinRgn, pSibRgn);
1934 ret = REGION_NOTEMPTY(pScreen, pWinRgn);
1935 REGION_DESTROY(pScreen, pWinRgn);
1936 REGION_DESTROY(pScreen, pSibRgn);
1942 #if NeedFunctionPrototypes
1943 AnyWindowOverlapsMe(
1946 register BoxPtr box)
1948 AnyWindowOverlapsMe(pWin, pHead, box)
1949 WindowPtr pWin, pHead;
1950 register BoxPtr box;
1953 register WindowPtr pSib;
1955 register BoxPtr sbox;
1957 for (pSib = pWin->prevSib; pSib != pHead; pSib = pSib->prevSib)
1961 sbox = WindowExtents(pSib, &sboxrec);
1962 if (BOXES_OVERLAP(sbox, box)
1964 && ShapeOverlap (pWin, box, pSib, sbox)
1974 #if NeedFunctionPrototypes
1977 register BoxPtr box)
1979 IOverlapAnyWindow(pWin, box)
1981 register BoxPtr box;
1984 register WindowPtr pSib;
1986 register BoxPtr sbox;
1988 for (pSib = pWin->nextSib; pSib; pSib = pSib->nextSib)
1992 sbox = WindowExtents(pSib, &sboxrec);
1993 if (BOXES_OVERLAP(sbox, box)
1995 && ShapeOverlap (pWin, box, pSib, sbox)
2005 * WhereDoIGoInTheStack()
2006 * Given pWin and pSib and the relationshipe smode, return
2007 * the window that pWin should go ABOVE.
2008 * If a pSib is specified:
2009 * Above: pWin is placed just above pSib
2010 * Below: pWin is placed just below pSib
2011 * TopIf: if pSib occludes pWin, then pWin is placed
2012 * at the top of the stack
2013 * BottomIf: if pWin occludes pSib, then pWin is
2014 * placed at the bottom of the stack
2015 * Opposite: if pSib occludes pWin, then pWin is placed at the
2016 * top of the stack, else if pWin occludes pSib, then
2017 * pWin is placed at the bottom of the stack
2020 * Above: pWin is placed at the top of the stack
2021 * Below: pWin is placed at the bottom of the stack
2022 * TopIf: if any sibling occludes pWin, then pWin is placed at
2023 * the top of the stack
2024 * BottomIf: if pWin occludes any sibline, then pWin is placed at
2025 * the bottom of the stack
2026 * Opposite: if any sibling occludes pWin, then pWin is placed at
2027 * the top of the stack, else if pWin occludes any
2028 * sibling, then pWin is placed at the bottom of the stack
2033 #if NeedFunctionPrototypes
2034 WhereDoIGoInTheStack(
2035 register WindowPtr pWin,
2036 register WindowPtr pSib,
2043 WhereDoIGoInTheStack(pWin, pSib, x, y, w, h, smode)
2044 register WindowPtr pWin, pSib;
2046 unsigned short w, h;
2051 register ScreenPtr pScreen;
2052 WindowPtr pHead, pFirst;
2054 if ((pWin == pWin->parent->firstChild) &&
2055 (pWin == pWin->parent->lastChild))
2056 return((WindowPtr ) NULL);
2057 pHead = RealChildHead(pWin->parent);
2058 pFirst = pHead ? pHead->nextSib : pWin->parent->firstChild;
2059 pScreen = pWin->drawable.pScreen;
2062 box.x2 = x + (int)w;
2063 box.y2 = y + (int)h;
2069 else if (pWin == pFirst)
2070 return(pWin->nextSib);
2075 if (pSib->nextSib != pWin)
2076 return(pSib->nextSib);
2078 return(pWin->nextSib);
2082 if ((!pWin->mapped || (pSib && !pSib->mapped)) && !permitOldBugs)
2083 return(pWin->nextSib);
2086 if ((IsSiblingAboveMe(pWin, pSib) == Above) &&
2087 (RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
2090 return(pWin->nextSib);
2092 else if (AnyWindowOverlapsMe(pWin, pHead, &box))
2095 return(pWin->nextSib);
2097 if ((!pWin->mapped || (pSib && !pSib->mapped)) && !permitOldBugs)
2098 return(pWin->nextSib);
2101 if ((IsSiblingAboveMe(pWin, pSib) == Below) &&
2102 (RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
2105 return(pWin->nextSib);
2107 else if (IOverlapAnyWindow(pWin, &box))
2110 return(pWin->nextSib);
2112 if ((!pWin->mapped || (pSib && !pSib->mapped)) && !permitOldBugs)
2113 return(pWin->nextSib);
2116 if (RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT)
2118 if (IsSiblingAboveMe(pWin, pSib) == Above)
2124 return(pWin->nextSib);
2126 else if (AnyWindowOverlapsMe(pWin, pHead, &box))
2128 /* If I'm occluded, I can't possibly be the first child
2129 * if (pWin == pWin->parent->firstChild)
2130 * return pWin->nextSib;
2134 else if (IOverlapAnyWindow(pWin, &box))
2137 return pWin->nextSib;
2140 ErrorF("Internal error in ConfigureWindow, smode == %d\n",smode );
2141 return pWin->nextSib;
2147 #if NeedFunctionPrototypes
2149 register WindowPtr pWin,
2150 register WindowPtr pSib,
2153 ReflectStackChange(pWin, pSib, kind)
2154 register WindowPtr pWin, pSib;
2158 /* Note that pSib might be NULL */
2160 Bool WasViewable = (Bool)pWin->viewable;
2163 WindowPtr pFirstChange;
2164 #ifdef DO_SAVE_UNDERS
2165 Bool dosave = FALSE;
2167 WindowPtr pLayerWin;
2168 ScreenPtr pScreen = pWin->drawable.pScreen;
2170 /* if this is a root window, can't be restacked */
2171 if (!(pParent = pWin->parent))
2174 pFirstChange = MoveWindowInStack(pWin, pSib);
2178 anyMarked = (*pScreen->MarkOverlappedWindows)(pWin, pFirstChange,
2180 if (pLayerWin != pWin) pFirstChange = pLayerWin;
2181 #ifdef DO_SAVE_UNDERS
2182 if (DO_SAVE_UNDERS(pWin))
2184 dosave = (*pScreen->ChangeSaveUnder)(pLayerWin, pFirstChange);
2186 #endif /* DO_SAVE_UNDERS */
2189 (*pScreen->ValidateTree)(pLayerWin->parent, pFirstChange, kind);
2190 (*pScreen->HandleExposures)(pLayerWin->parent);
2192 #ifdef DO_SAVE_UNDERS
2194 (*pScreen->PostChangeSaveUnder)(pLayerWin, pFirstChange);
2195 #endif /* DO_SAVE_UNDERS */
2196 if (anyMarked && pWin->drawable.pScreen->PostValidateTree)
2197 (*pScreen->PostValidateTree)(pLayerWin->parent, pFirstChange, kind);
2200 WindowsRestructured ();
2208 ConfigureWindow(pWin, mask, vlist, client)
2209 register WindowPtr pWin;
2214 #define RESTACK_WIN 0
2216 #define RESIZE_WIN 2
2217 #define REBORDER_WIN 3
2218 register WindowPtr pSib = NullWindow;
2219 register WindowPtr pParent = pWin->parent;
2222 register XID *pVlist;
2223 short x, y, beforeX, beforeY;
2224 unsigned short w = pWin->drawable.width,
2225 h = pWin->drawable.height,
2226 bw = pWin->borderWidth;
2227 int action, smode = Above;
2229 ClientPtr win_owner;
2230 ClientPtr ag_leader = NULL;
2234 if ((pWin->drawable.class == InputOnly) && (mask & IllegalInputOnlyConfigureMask))
2237 if ((mask & CWSibling) && !(mask & CWStackMode))
2244 x = pWin->drawable.x - pParent->drawable.x - (int)bw;
2245 y = pWin->drawable.y - pParent->drawable.y - (int)bw;
2249 x = pWin->drawable.x;
2250 y = pWin->drawable.y;
2254 action = RESTACK_WIN;
2255 if ((mask & (CWX | CWY)) && (!(mask & (CWHeight | CWWidth))))
2261 /* or should be resized */
2262 else if (mask & (CWX | CWY | CWWidth | CWHeight))
2266 GET_CARD16(CWWidth, w);
2267 GET_CARD16 (CWHeight, h);
2270 client->errorValue = 0;
2273 action = RESIZE_WIN;
2275 tmask = mask & ~ChangeMask;
2278 index2 = (Mask)lowbit (tmask);
2283 GET_CARD16(CWBorderWidth, bw);
2286 sibwid = (Window ) *pVlist;
2288 pSib = (WindowPtr )SecurityLookupIDByType(client, sibwid,
2289 RT_WINDOW, SecurityReadAccess);
2292 client->errorValue = sibwid;
2295 if (pSib->parent != pParent)
2301 GET_CARD8(CWStackMode, smode);
2302 if ((smode != TopIf) && (smode != BottomIf) &&
2303 (smode != Opposite) && (smode != Above) && (smode != Below))
2305 client->errorValue = smode;
2310 client->errorValue = mask;
2314 /* root really can't be reconfigured, so just return */
2318 /* Figure out if the window should be moved. Doesnt
2319 make the changes to the window if event sent */
2321 if (mask & CWStackMode)
2322 pSib = WhereDoIGoInTheStack(pWin, pSib, pParent->drawable.x + x,
2323 pParent->drawable.y + y,
2324 w + (bw << 1), h + (bw << 1), smode);
2326 pSib = pWin->nextSib;
2329 win_owner = clients[CLIENT_ID(pWin->drawable.id)];
2330 ag_leader = XagLeader (win_owner);
2333 if ((!pWin->overrideRedirect) &&
2334 (RedirectSend(pParent)
2336 || (win_owner->appgroup && ag_leader &&
2337 XagIsControlledRoot (client, pParent))
2341 event.u.u.type = ConfigureRequest;
2342 event.u.configureRequest.window = pWin->drawable.id;
2343 if (mask & CWSibling)
2344 event.u.configureRequest.sibling = sibwid;
2346 event.u.configureRequest.sibling = None;
2347 if (mask & CWStackMode)
2348 event.u.u.detail = smode;
2350 event.u.u.detail = Above;
2351 event.u.configureRequest.x = x;
2352 event.u.configureRequest.y = y;
2353 event.u.configureRequest.width = w;
2354 event.u.configureRequest.height = h;
2355 event.u.configureRequest.borderWidth = bw;
2356 event.u.configureRequest.valueMask = mask;
2358 /* make sure if the ag_leader maps the window it goes to the wm */
2359 if (ag_leader && ag_leader != client &&
2360 XagIsControlledRoot (client, pParent)) {
2361 event.u.configureRequest.parent = XagId (win_owner);
2362 (void) TryClientEvents (ag_leader, &event, 1,
2363 NoEventMask, NoEventMask, NullGrab);
2367 event.u.configureRequest.parent = pParent->drawable.id;
2368 if (MaybeDeliverEventsToClient(pParent, &event, 1,
2369 SubstructureRedirectMask, client) == 1)
2372 if (action == RESIZE_WIN)
2374 Bool size_change = (w != pWin->drawable.width)
2375 || (h != pWin->drawable.height);
2376 if (size_change && ((pWin->eventMask|wOtherEventMasks(pWin)) & ResizeRedirectMask))
2379 eventT.u.u.type = ResizeRequest;
2380 eventT.u.resizeRequest.window = pWin->drawable.id;
2381 eventT.u.resizeRequest.width = w;
2382 eventT.u.resizeRequest.height = h;
2383 if (MaybeDeliverEventsToClient(pWin, &eventT, 1,
2384 ResizeRedirectMask, client) == 1)
2386 /* if event is delivered, leave the actual size alone. */
2387 w = pWin->drawable.width;
2388 h = pWin->drawable.height;
2389 size_change = FALSE;
2394 if (mask & (CWX | CWY))
2396 else if (mask & (CWStackMode | CWBorderWidth))
2397 action = RESTACK_WIN;
2398 else /* really nothing to do */
2403 if (action == RESIZE_WIN)
2404 /* we've already checked whether there's really a size change */
2405 goto ActuallyDoSomething;
2406 if ((mask & CWX) && (x != beforeX))
2407 goto ActuallyDoSomething;
2408 if ((mask & CWY) && (y != beforeY))
2409 goto ActuallyDoSomething;
2410 if ((mask & CWBorderWidth) && (bw != wBorderWidth (pWin)))
2411 goto ActuallyDoSomething;
2412 if (mask & CWStackMode)
2414 if (pWin->nextSib != pSib)
2415 goto ActuallyDoSomething;
2419 ActuallyDoSomething:
2420 if (SubStrSend(pWin, pParent))
2422 event.u.u.type = ConfigureNotify;
2423 event.u.configureNotify.window = pWin->drawable.id;
2425 event.u.configureNotify.aboveSibling = pSib->drawable.id;
2427 event.u.configureNotify.aboveSibling = None;
2428 event.u.configureNotify.x = x;
2429 event.u.configureNotify.y = y;
2430 event.u.configureNotify.width = w;
2431 event.u.configureNotify.height = h;
2432 event.u.configureNotify.borderWidth = bw;
2433 event.u.configureNotify.override = pWin->overrideRedirect;
2434 DeliverEvents(pWin, &event, 1, NullWindow);
2436 if (mask & CWBorderWidth)
2438 if (action == RESTACK_WIN)
2441 pWin->borderWidth = bw;
2443 else if ((action == MOVE_WIN) &&
2444 (beforeX + wBorderWidth (pWin) == x + (int)bw) &&
2445 (beforeY + wBorderWidth (pWin) == y + (int)bw))
2447 action = REBORDER_WIN;
2448 (*pWin->drawable.pScreen->ChangeBorderWidth)(pWin, bw);
2451 pWin->borderWidth = bw;
2453 if (action == MOVE_WIN)
2454 (*pWin->drawable.pScreen->MoveWindow)(pWin, x, y, pSib,
2455 (mask & CWBorderWidth) ? VTOther : VTMove);
2456 else if (action == RESIZE_WIN)
2457 (*pWin->drawable.pScreen->ResizeWindow)(pWin, x, y, w, h, pSib);
2458 else if (mask & CWStackMode)
2459 ReflectStackChange(pWin, pSib, VTOther);
2461 if (action != RESTACK_WIN)
2462 CheckCursorConfinement(pWin);
2475 * For RaiseLowest, raises the lowest mapped child (if any) that is
2476 * obscured by another child to the top of the stack. For LowerHighest,
2477 * lowers the highest mapped child (if any) that is obscuring another
2478 * child to the bottom of the stack. Exposure processing is performed
2483 CirculateWindow(pParent, direction, client)
2488 register WindowPtr pWin, pHead, pFirst;
2492 pHead = RealChildHead(pParent);
2493 pFirst = pHead ? pHead->nextSib : pParent->firstChild;
2494 if (direction == RaiseLowest)
2496 for (pWin = pParent->lastChild;
2499 AnyWindowOverlapsMe(pWin, pHead, WindowExtents(pWin, &box)));
2500 pWin = pWin->prevSib) ;
2509 IOverlapAnyWindow(pWin, WindowExtents(pWin, &box)));
2510 pWin = pWin->nextSib) ;
2515 event.u.circulate.window = pWin->drawable.id;
2516 event.u.circulate.parent = pParent->drawable.id;
2517 event.u.circulate.event = pParent->drawable.id;
2518 if (direction == RaiseLowest)
2519 event.u.circulate.place = PlaceOnTop;
2521 event.u.circulate.place = PlaceOnBottom;
2523 if (RedirectSend(pParent))
2525 event.u.u.type = CirculateRequest;
2526 if (MaybeDeliverEventsToClient(pParent, &event, 1,
2527 SubstructureRedirectMask, client) == 1)
2531 event.u.u.type = CirculateNotify;
2532 DeliverEvents(pWin, &event, 1, NullWindow);
2533 ReflectStackChange(pWin,
2534 (direction == RaiseLowest) ? pFirst : NullWindow,
2541 #if NeedFunctionPrototypes
2544 pointer value) /* must conform to VisitWindowProcPtr */
2546 CompareWIDs(pWin, value)
2548 pointer value; /* must conform to VisitWindowProcPtr */
2551 Window *wid = (Window *)value;
2553 if (pWin->drawable.id == *wid)
2554 return(WT_STOPWALKING);
2556 return(WT_WALKCHILDREN);
2564 ReparentWindow(pWin, pParent, x, y, client)
2565 register WindowPtr pWin, pParent;
2569 WindowPtr pPrev, pPriorParent;
2570 Bool WasMapped = (Bool)(pWin->mapped);
2572 int bw = wBorderWidth (pWin);
2573 register ScreenPtr pScreen;
2575 pScreen = pWin->drawable.pScreen;
2576 if (TraverseTree(pWin, CompareWIDs, (pointer)&pParent->drawable.id) == WT_STOPWALKING)
2578 if (!MakeWindowOptional(pWin))
2582 UnmapWindow(pWin, FALSE);
2584 event.u.u.type = ReparentNotify;
2585 event.u.reparent.window = pWin->drawable.id;
2586 event.u.reparent.parent = pParent->drawable.id;
2587 event.u.reparent.x = x;
2588 event.u.reparent.y = y;
2589 event.u.reparent.override = pWin->overrideRedirect;
2590 DeliverEvents(pWin, &event, 1, pParent);
2592 /* take out of sibling chain */
2594 pPriorParent = pPrev = pWin->parent;
2595 if (pPrev->firstChild == pWin)
2596 pPrev->firstChild = pWin->nextSib;
2597 if (pPrev->lastChild == pWin)
2598 pPrev->lastChild = pWin->prevSib;
2601 pWin->nextSib->prevSib = pWin->prevSib;
2603 pWin->prevSib->nextSib = pWin->nextSib;
2605 /* insert at begining of pParent */
2606 pWin->parent = pParent;
2607 pPrev = RealChildHead(pParent);
2610 pWin->nextSib = pPrev->nextSib;
2612 pPrev->nextSib->prevSib = pWin;
2614 pParent->lastChild = pWin;
2615 pPrev->nextSib = pWin;
2616 pWin->prevSib = pPrev;
2620 pWin->nextSib = pParent->firstChild;
2621 pWin->prevSib = NullWindow;
2622 if (pParent->firstChild)
2623 pParent->firstChild->prevSib = pWin;
2625 pParent->lastChild = pWin;
2626 pParent->firstChild = pWin;
2629 pWin->origin.x = x + bw;
2630 pWin->origin.y = y + bw;
2631 pWin->drawable.x = x + bw + pParent->drawable.x;
2632 pWin->drawable.y = y + bw + pParent->drawable.y;
2634 /* clip to parent */
2636 SetBorderSize (pWin);
2638 if (pScreen->ReparentWindow)
2639 (*pScreen->ReparentWindow)(pWin, pPriorParent);
2640 (*pScreen->PositionWindow)(pWin, pWin->drawable.x, pWin->drawable.y);
2641 ResizeChildrenWinSize(pWin, 0, 0, 0, 0);
2643 CheckWindowOptionalNeed(pWin);
2646 MapWindow(pWin, client);
2647 RecalculateDeliverableEvents(pWin);
2652 #if NeedFunctionPrototypes
2653 RealizeTree(WindowPtr pWin)
2659 register WindowPtr pChild;
2660 RealizeWindowProcPtr Realize;
2662 Realize = pWin->drawable.pScreen->RealizeWindow;
2668 pChild->realized = TRUE;
2669 #ifdef DO_SAVE_UNDERS
2670 if (pChild->saveUnder)
2671 deltaSaveUndersViewable++;
2673 pChild->viewable = (pChild->drawable.class == InputOutput);
2674 (* Realize)(pChild);
2675 if (pChild->firstChild)
2677 pChild = pChild->firstChild;
2681 while (!pChild->nextSib && (pChild != pWin))
2682 pChild = pChild->parent;
2685 pChild = pChild->nextSib;
2691 * If some other client has selected SubStructureReDirect on the parent
2692 * and override-redirect is xFalse, then a MapRequest event is generated,
2693 * but the window remains unmapped. Otherwise, the window is mapped and a
2694 * MapNotify event is generated.
2698 MapWindow(pWin, client)
2699 register WindowPtr pWin;
2702 register ScreenPtr pScreen;
2704 register WindowPtr pParent;
2705 #ifdef DO_SAVE_UNDERS
2706 Bool dosave = FALSE;
2708 WindowPtr pLayerWin;
2714 /* don't let an untrusted client map a child-of-trusted-window, InputOnly
2715 * window; too easy to steal device input
2717 if ( (client->trustLevel != XSecurityClientTrusted) &&
2718 (pWin->drawable.class == InputOnly) &&
2719 (wClient(pWin->parent)->trustLevel == XSecurityClientTrusted) )
2723 pScreen = pWin->drawable.pScreen;
2724 if ( (pParent = pWin->parent) )
2729 ClientPtr win_owner = clients[CLIENT_ID(pWin->drawable.id)];
2730 ClientPtr ag_leader = XagLeader (win_owner);
2733 if ((!pWin->overrideRedirect) &&
2734 (RedirectSend(pParent)
2736 || (win_owner->appgroup && ag_leader &&
2737 XagIsControlledRoot (client, pParent))
2741 event.u.u.type = MapRequest;
2742 event.u.mapRequest.window = pWin->drawable.id;
2744 /* make sure if the ag_leader maps the window it goes to the wm */
2745 if (ag_leader && ag_leader != client &&
2746 XagIsControlledRoot (client, pParent)) {
2747 event.u.mapRequest.parent = XagId (win_owner);
2748 (void) TryClientEvents (ag_leader, &event, 1,
2749 NoEventMask, NoEventMask, NullGrab);
2753 event.u.mapRequest.parent = pParent->drawable.id;
2755 if (MaybeDeliverEventsToClient(pParent, &event, 1,
2756 SubstructureRedirectMask, client) == 1)
2760 pWin->mapped = TRUE;
2761 if (SubStrSend(pWin, pParent))
2763 event.u.u.type = MapNotify;
2764 event.u.mapNotify.window = pWin->drawable.id;
2765 event.u.mapNotify.override = pWin->overrideRedirect;
2766 DeliverEvents(pWin, &event, 1, NullWindow);
2769 if (!pParent->realized)
2774 anyMarked = (*pScreen->MarkOverlappedWindows)(pWin, pWin,
2776 #ifdef DO_SAVE_UNDERS
2777 if (DO_SAVE_UNDERS(pWin))
2779 dosave = (*pScreen->ChangeSaveUnder)(pLayerWin, pWin->nextSib);
2781 #endif /* DO_SAVE_UNDERS */
2784 (*pScreen->ValidateTree)(pLayerWin->parent, pLayerWin, VTMap);
2785 (*pScreen->HandleExposures)(pLayerWin->parent);
2787 #ifdef DO_SAVE_UNDERS
2789 (*pScreen->PostChangeSaveUnder)(pLayerWin, pWin->nextSib);
2790 #endif /* DO_SAVE_UNDERS */
2791 if (anyMarked && pScreen->PostValidateTree)
2792 (*pScreen->PostValidateTree)(pLayerWin->parent, pLayerWin, VTMap);
2794 WindowsRestructured ();
2800 pWin->mapped = TRUE;
2801 pWin->realized = TRUE; /* for roots */
2802 pWin->viewable = pWin->drawable.class == InputOutput;
2803 /* We SHOULD check for an error value here XXX */
2804 (*pScreen->RealizeWindow)(pWin);
2805 if (pScreen->ClipNotify)
2806 (*pScreen->ClipNotify) (pWin, 0, 0);
2807 if (pScreen->PostValidateTree)
2808 (*pScreen->PostValidateTree)(NullWindow, pWin, VTMap);
2809 REGION_INIT(pScreen, &temp, NullBox, 0);
2810 REGION_COPY(pScreen, &temp, &pWin->clipList);
2811 (*pScreen->WindowExposures) (pWin, &temp, NullRegion);
2812 REGION_UNINIT(pScreen, &temp);
2821 * Performs a MapWindow all unmapped children of the window, in top
2822 * to bottom stacking order.
2826 MapSubwindows(pParent, client)
2827 register WindowPtr pParent;
2830 register WindowPtr pWin;
2831 WindowPtr pFirstMapped = NullWindow;
2832 #ifdef DO_SAVE_UNDERS
2833 WindowPtr pFirstSaveUndered = NullWindow;
2835 register ScreenPtr pScreen;
2836 register Mask parentRedirect;
2837 register Mask parentNotify;
2840 #ifdef DO_SAVE_UNDERS
2841 Bool dosave = FALSE;
2843 WindowPtr pLayerWin;
2845 pScreen = pParent->drawable.pScreen;
2846 parentRedirect = RedirectSend(pParent);
2847 parentNotify = SubSend(pParent);
2849 for (pWin = pParent->firstChild; pWin; pWin = pWin->nextSib)
2853 if (parentRedirect && !pWin->overrideRedirect)
2855 event.u.u.type = MapRequest;
2856 event.u.mapRequest.window = pWin->drawable.id;
2857 event.u.mapRequest.parent = pParent->drawable.id;
2859 if (MaybeDeliverEventsToClient(pParent, &event, 1,
2860 SubstructureRedirectMask, client) == 1)
2864 pWin->mapped = TRUE;
2865 if (parentNotify || StrSend(pWin))
2867 event.u.u.type = MapNotify;
2868 event.u.mapNotify.window = pWin->drawable.id;
2869 event.u.mapNotify.override = pWin->overrideRedirect;
2870 DeliverEvents(pWin, &event, 1, NullWindow);
2874 pFirstMapped = pWin;
2875 if (pParent->realized)
2880 anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pWin,
2882 #ifdef DO_SAVE_UNDERS
2883 if (DO_SAVE_UNDERS(pWin))
2887 #endif /* DO_SAVE_UNDERS */
2895 pLayerWin = (*pScreen->GetLayerWindow)(pParent);
2896 if (pLayerWin->parent != pParent) {
2897 anyMarked |= (*pScreen->MarkOverlappedWindows)(pLayerWin,
2900 pFirstMapped = pLayerWin;
2904 #ifdef DO_SAVE_UNDERS
2905 if (pLayerWin->parent != pParent)
2907 if (dosave || (DO_SAVE_UNDERS(pLayerWin)))
2909 dosave = (*pScreen->ChangeSaveUnder)(pLayerWin,
2916 for (pWin = pParent->firstChild; pWin; pWin = pWin->nextSib)
2918 if (DO_SAVE_UNDERS(pWin))
2920 dosave |= (*pScreen->ChangeSaveUnder)(pWin,
2922 if (dosave && !pFirstSaveUndered)
2923 pFirstSaveUndered = pWin;
2927 #endif /* DO_SAVE_UNDERS */
2928 (*pScreen->ValidateTree)(pLayerWin->parent, pFirstMapped, VTMap);
2929 (*pScreen->HandleExposures)(pLayerWin->parent);
2931 #ifdef DO_SAVE_UNDERS
2933 (*pScreen->PostChangeSaveUnder)(pLayerWin,
2934 pFirstSaveUndered->nextSib);
2935 #endif /* DO_SAVE_UNDERS */
2936 if (anyMarked && pScreen->PostValidateTree)
2937 (*pScreen->PostValidateTree)(pLayerWin->parent, pFirstMapped,
2939 WindowsRestructured ();
2944 #if NeedFunctionPrototypes
2949 UnrealizeTree(pWin, fromConfigure)
2954 register WindowPtr pChild;
2955 UnrealizeWindowProcPtr Unrealize;
2956 MarkUnrealizedWindowProcPtr MarkUnrealizedWindow;
2958 Unrealize = pWin->drawable.pScreen->UnrealizeWindow;
2959 MarkUnrealizedWindow = pWin->drawable.pScreen->MarkUnrealizedWindow;
2963 if (pChild->realized)
2965 pChild->realized = FALSE;
2966 pChild->visibility = VisibilityNotViewable;
2967 (* Unrealize)(pChild);
2968 DeleteWindowFromAnyEvents(pChild, FALSE);
2969 if (pChild->viewable)
2971 #ifdef DO_SAVE_UNDERS
2972 if (pChild->saveUnder)
2973 deltaSaveUndersViewable--;
2975 pChild->viewable = FALSE;
2976 if (pChild->backStorage)
2977 (*pChild->drawable.pScreen->SaveDoomedAreas)(
2978 pChild, &pChild->clipList, 0, 0);
2979 (* MarkUnrealizedWindow)(pChild, pWin, fromConfigure);
2980 pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;
2982 if (pChild->firstChild)
2984 pChild = pChild->firstChild;
2988 while (!pChild->nextSib && (pChild != pWin))
2989 pChild = pChild->parent;
2992 pChild = pChild->nextSib;
2998 * If the window is already unmapped, this request has no effect.
2999 * Otherwise, the window is unmapped and an UnMapNotify event is
3000 * generated. Cannot unmap a root window.
3004 UnmapWindow(pWin, fromConfigure)
3005 register WindowPtr pWin;
3008 register WindowPtr pParent;
3010 Bool wasRealized = (Bool)pWin->realized;
3011 Bool wasViewable = (Bool)pWin->viewable;
3012 ScreenPtr pScreen = pWin->drawable.pScreen;
3013 WindowPtr pLayerWin = pWin;
3015 if ((!pWin->mapped) || (!(pParent = pWin->parent)))
3017 if (SubStrSend(pWin, pParent))
3019 event.u.u.type = UnmapNotify;
3020 event.u.unmapNotify.window = pWin->drawable.id;
3021 event.u.unmapNotify.fromConfigure = fromConfigure;
3022 DeliverEvents(pWin, &event, 1, NullWindow);
3024 if (wasViewable && !fromConfigure)
3026 pWin->valdata = UnmapValData;
3027 (*pScreen->MarkOverlappedWindows)(pWin, pWin->nextSib, &pLayerWin);
3028 (*pScreen->MarkWindow)(pLayerWin->parent);
3030 pWin->mapped = FALSE;
3032 UnrealizeTree(pWin, fromConfigure);
3037 (*pScreen->ValidateTree)(pLayerWin->parent, pWin, VTUnmap);
3038 (*pScreen->HandleExposures)(pLayerWin->parent);
3040 #ifdef DO_SAVE_UNDERS
3041 if (DO_SAVE_UNDERS(pWin))
3043 if ( (*pScreen->ChangeSaveUnder)(pLayerWin, pWin->nextSib) )
3045 (*pScreen->PostChangeSaveUnder)(pLayerWin, pWin->nextSib);
3048 pWin->DIXsaveUnder = FALSE;
3049 #endif /* DO_SAVE_UNDERS */
3050 if (!fromConfigure && pScreen->PostValidateTree)
3051 (*pScreen->PostValidateTree)(pLayerWin->parent, pWin, VTUnmap);
3053 if (wasRealized && !fromConfigure)
3054 WindowsRestructured ();
3060 * Performs an UnmapWindow request with the specified mode on all mapped
3061 * children of the window, in bottom to top stacking order.
3065 UnmapSubwindows(pWin)
3066 register WindowPtr pWin;
3068 register WindowPtr pChild, pHead;
3070 Bool wasRealized = (Bool)pWin->realized;
3071 Bool wasViewable = (Bool)pWin->viewable;
3072 Bool anyMarked = FALSE;
3074 WindowPtr pLayerWin;
3075 ScreenPtr pScreen = pWin->drawable.pScreen;
3077 if (!pWin->firstChild)
3079 parentNotify = SubSend(pWin);
3080 pHead = RealChildHead(pWin);
3083 pLayerWin = (*pScreen->GetLayerWindow)(pWin);
3085 for (pChild = pWin->lastChild; pChild != pHead; pChild = pChild->prevSib)
3089 if (parentNotify || StrSend(pChild))
3091 event.u.u.type = UnmapNotify;
3092 event.u.unmapNotify.window = pChild->drawable.id;
3093 event.u.unmapNotify.fromConfigure = xFalse;
3094 DeliverEvents(pChild, &event, 1, NullWindow);
3096 if (pChild->viewable)
3098 pChild->valdata = UnmapValData;
3101 pChild->mapped = FALSE;
3102 if (pChild->realized)
3103 UnrealizeTree(pChild, FALSE);
3106 #ifdef DO_SAVE_UNDERS
3107 pChild->DIXsaveUnder = FALSE;
3108 #endif /* DO_SAVE_UNDERS */
3109 if (pChild->backStorage)
3110 (*pScreen->SaveDoomedAreas)(
3111 pChild, &pChild->clipList, 0, 0);
3119 if (pLayerWin->parent == pWin)
3120 (*pScreen->MarkWindow)(pWin);
3124 (*pScreen->MarkOverlappedWindows)(pWin, pLayerWin,
3126 (*pScreen->MarkWindow)(pLayerWin->parent);
3128 /* Windows between pWin and pLayerWin may not have been marked */
3131 while (ptmp != pLayerWin->parent)
3133 (*pScreen->MarkWindow)(ptmp);
3134 ptmp = ptmp->parent;
3136 pHead = pWin->firstChild;
3138 (*pScreen->ValidateTree)(pLayerWin->parent, pHead, VTUnmap);
3139 (*pScreen->HandleExposures)(pLayerWin->parent);
3141 #ifdef DO_SAVE_UNDERS
3142 if (DO_SAVE_UNDERS(pWin))
3144 if ( (*pScreen->ChangeSaveUnder)(pLayerWin, pLayerWin))
3145 (*pScreen->PostChangeSaveUnder)(pLayerWin, pLayerWin);
3147 #endif /* DO_SAVE_UNDERS */
3148 if (anyMarked && pScreen->PostValidateTree)
3149 (*pScreen->PostValidateTree)(pLayerWin->parent, pHead, VTUnmap);
3152 WindowsRestructured ();
3157 HandleSaveSet(client)
3158 register ClientPtr client;
3160 register WindowPtr pParent, pWin;
3163 for (j=0; j<client->numSaved; j++)
3165 pWin = (WindowPtr)client->saveSet[j];
3166 pParent = pWin->parent;
3167 while (pParent && (wClient (pParent) == client))
3168 pParent = pParent->parent;
3171 if (pParent != pWin->parent)
3173 ReparentWindow(pWin, pParent,
3174 pWin->drawable.x - wBorderWidth (pWin) - pParent->drawable.x,
3175 pWin->drawable.y - wBorderWidth (pWin) - pParent->drawable.y,
3177 if(!pWin->realized && pWin->mapped)
3178 pWin->mapped = FALSE;
3180 MapWindow(pWin, client);
3183 xfree(client->saveSet);
3184 client->numSaved = 0;
3185 client->saveSet = (pointer *)NULL;
3189 VisibleBoundingBoxFromPoint(pWin, x, y, box)
3190 register WindowPtr pWin;
3191 int x, y; /* in root */
3192 BoxPtr box; /* "return" value */
3194 if (!pWin->realized)
3196 if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->clipList, x, y, box))
3202 PointInWindowIsVisible(pWin, x, y)
3203 register WindowPtr pWin;
3204 int x, y; /* in root */
3208 if (!pWin->realized)
3210 if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->borderClip,
3218 NotClippedByChildren(pWin)
3219 register WindowPtr pWin;
3221 register ScreenPtr pScreen;
3224 pScreen = pWin->drawable.pScreen;
3225 pReg = REGION_CREATE(pScreen, NullBox, 1);
3227 screenIsSaved != SCREEN_SAVER_ON ||
3228 !HasSaverWindow (pWin->drawable.pScreen->myNum))
3230 REGION_INTERSECT(pScreen, pReg, &pWin->borderClip, &pWin->winSize);
3237 SendVisibilityNotify(pWin)
3241 event.u.u.type = VisibilityNotify;
3242 event.u.visibility.window = pWin->drawable.id;
3243 event.u.visibility.state = pWin->visibility;
3244 DeliverEvents(pWin, &event, 1, NullWindow);
3248 #define RANDOM_WIDTH 32
3251 extern int logoScreenSaver;
3252 static void DrawLogo(
3253 #if NeedFunctionPrototypes
3260 SaveScreens(on, mode)
3268 if (on == SCREEN_SAVER_FORCER)
3270 UpdateCurrentTimeIf();
3271 lastDeviceEventTime = currentTime;
3272 if (mode == ScreenSaverReset)
3273 what = SCREEN_SAVER_OFF;
3275 what = SCREEN_SAVER_ON;
3282 if (what == screenIsSaved)
3283 type = SCREEN_SAVER_CYCLE;
3285 for (i = 0; i < screenInfo.numScreens; i++)
3287 if (on == SCREEN_SAVER_FORCER)
3288 (* screenInfo.screens[i]->SaveScreen) (screenInfo.screens[i], on);
3289 if (savedScreenInfo[i].ExternalScreenSaver)
3291 if ((*savedScreenInfo[i].ExternalScreenSaver)
3292 (screenInfo.screens[i], type, on == SCREEN_SAVER_FORCER))
3295 if (type == screenIsSaved)
3298 case SCREEN_SAVER_OFF:
3299 if (savedScreenInfo[i].blanked == SCREEN_IS_BLANKED)
3301 (* screenInfo.screens[i]->SaveScreen) (screenInfo.screens[i],
3304 else if (HasSaverWindow (i))
3306 savedScreenInfo[i].pWindow = NullWindow;
3307 FreeResource(savedScreenInfo[i].wid, RT_NONE);
3310 case SCREEN_SAVER_CYCLE:
3311 if (savedScreenInfo[i].blanked == SCREEN_IS_TILED)
3313 WindowPtr pWin = savedScreenInfo[i].pWindow;
3314 /* make it look like screen saver is off, so that
3315 * NotClippedByChildren will compute a clip list
3316 * for the root window, so miPaintWindow works
3318 screenIsSaved = SCREEN_SAVER_OFF;
3320 if (logoScreenSaver)
3321 (*pWin->drawable.pScreen->ClearToBackground)(pWin, 0, 0, 0, 0, FALSE);
3323 (*pWin->drawable.pScreen->MoveWindow)(pWin,
3324 (short)(-(rand() % RANDOM_WIDTH)),
3325 (short)(-(rand() % RANDOM_WIDTH)),
3326 pWin->nextSib, VTMove);
3328 if (logoScreenSaver)
3331 screenIsSaved = SCREEN_SAVER_ON;
3334 case SCREEN_SAVER_ON:
3335 if (ScreenSaverBlanking != DontPreferBlanking)
3337 if ((* screenInfo.screens[i]->SaveScreen)
3338 (screenInfo.screens[i], what))
3340 savedScreenInfo[i].blanked = SCREEN_IS_BLANKED;
3343 if ((ScreenSaverAllowExposures != DontAllowExposures) &&
3344 TileScreenSaver(i, SCREEN_IS_BLACK))
3346 savedScreenInfo[i].blanked = SCREEN_IS_BLACK;
3350 if ((ScreenSaverAllowExposures != DontAllowExposures) &&
3351 TileScreenSaver(i, SCREEN_IS_TILED))
3353 savedScreenInfo[i].blanked = SCREEN_IS_TILED;
3356 savedScreenInfo[i].blanked = SCREEN_ISNT_SAVED;
3360 screenIsSaved = what;
3364 #if NeedFunctionPrototypes
3365 TileScreenSaver(int i, int kind)
3367 TileScreenSaver(i, kind)
3378 unsigned char *srcbits, *mskbits;
3386 case SCREEN_IS_TILED:
3387 switch (WindowTable[i]->backgroundState) {
3388 case BackgroundPixel:
3389 attributes[attri++] = WindowTable[i]->background.pixel;
3390 mask |= CWBackPixel;
3392 case BackgroundPixmap:
3393 attributes[attri++] = None;
3394 mask |= CWBackPixmap;
3400 case SCREEN_IS_BLACK:
3401 attributes[attri++] = WindowTable[i]->drawable.pScreen->blackPixel;
3402 mask |= CWBackPixel;
3405 mask |= CWOverrideRedirect;
3406 attributes[attri++] = xTrue;
3409 * create a blank cursor
3416 srcbits = (unsigned char *)xalloc( BitmapBytePad(32)*16);
3417 mskbits = (unsigned char *)xalloc( BitmapBytePad(32)*16);
3418 if (!srcbits || !mskbits)
3426 for (j=0; j<BitmapBytePad(32)*16; j++)
3427 srcbits[j] = mskbits[j] = 0x0;
3428 cursor = AllocCursor(srcbits, mskbits, &cm, 0, 0, 0, 0, 0, 0);
3431 cursorID = FakeClientID(0);
3432 if (AddResource (cursorID, RT_CURSOR, (pointer) cursor))
3434 attributes[attri] = cursorID;
3447 pWin = savedScreenInfo[i].pWindow =
3448 CreateWindow(savedScreenInfo[i].wid,
3450 -RANDOM_WIDTH, -RANDOM_WIDTH,
3451 (unsigned short)screenInfo.screens[i]->width + RANDOM_WIDTH,
3452 (unsigned short)screenInfo.screens[i]->height + RANDOM_WIDTH,
3453 0, InputOutput, mask, attributes, 0, serverClient,
3454 wVisual (WindowTable[i]), &result);
3457 FreeResource (cursorID, RT_NONE);
3462 if (!AddResource(pWin->drawable.id, RT_WINDOW,
3463 (pointer)savedScreenInfo[i].pWindow))
3466 if (mask & CWBackPixmap)
3468 MakeRootTile (pWin);
3469 (*pWin->drawable.pScreen->ChangeWindowAttributes)(pWin, CWBackPixmap);
3471 MapWindow(pWin, serverClient);
3473 if (kind == SCREEN_IS_TILED && logoScreenSaver)
3480 * FindWindowWithOptional
3482 * search ancestors of the given window for an entry containing
3483 * a WindowOpt structure. Assumptions: some parent will
3484 * contain the structure.
3488 FindWindowWithOptional (w)
3489 register WindowPtr w;
3493 while (!w->optional);
3498 * CheckWindowOptionalNeed
3500 * check each optional entry in the given window to see if
3501 * the value is satisfied by the default rules. If so,
3502 * release the optional record
3506 CheckWindowOptionalNeed (w)
3507 register WindowPtr w;
3509 register WindowOptPtr optional;
3510 register WindowOptPtr parentOptional;
3514 optional = w->optional;
3515 if (optional->dontPropagateMask != DontPropagateMasks[w->dontPropagate])
3517 if (optional->otherEventMasks != 0)
3519 if (optional->otherClients != NULL)
3521 if (optional->passiveGrabs != NULL)
3523 if (optional->userProps != NULL)
3525 if (optional->backingBitPlanes != ~0L)
3527 if (optional->backingPixel != 0)
3530 if (optional->boundingShape != NULL)
3532 if (optional->clipShape != NULL)
3536 if (optional->inputMasks != NULL)
3539 parentOptional = FindWindowWithOptional(w)->optional;
3540 if (optional->visual != parentOptional->visual)
3542 if (optional->cursor != None &&
3543 (optional->cursor != parentOptional->cursor ||
3544 w->parent->cursorIsNone))
3546 if (optional->colormap != parentOptional->colormap)
3548 DisposeWindowOptional (w);
3552 * MakeWindowOptional
3554 * create an optional record and initialize it with the default
3559 MakeWindowOptional (pWin)
3560 register WindowPtr pWin;
3562 register WindowOptPtr optional;
3563 register WindowOptPtr parentOptional;
3567 optional = (WindowOptPtr) xalloc (sizeof (WindowOptRec));
3570 optional->dontPropagateMask = DontPropagateMasks[pWin->dontPropagate];
3571 optional->otherEventMasks = 0;
3572 optional->otherClients = NULL;
3573 optional->passiveGrabs = NULL;
3574 optional->userProps = NULL;
3575 optional->backingBitPlanes = ~0L;
3576 optional->backingPixel = 0;
3578 optional->boundingShape = NULL;
3579 optional->clipShape = NULL;
3582 optional->inputMasks = NULL;
3584 parentOptional = FindWindowWithOptional(pWin)->optional;
3585 optional->visual = parentOptional->visual;
3586 if (!pWin->cursorIsNone)
3588 optional->cursor = parentOptional->cursor;
3589 optional->cursor->refcnt++;
3593 optional->cursor = None;
3595 optional->colormap = parentOptional->colormap;
3596 pWin->optional = optional;
3601 DisposeWindowOptional (pWin)
3602 register WindowPtr pWin;
3604 if (!pWin->optional)
3607 * everything is peachy. Delete the optional record
3610 if (pWin->optional->cursor)
3612 FreeCursor (pWin->optional->cursor, (Cursor)0);
3613 pWin->cursorIsNone = FALSE;
3616 pWin->cursorIsNone = TRUE;
3617 xfree (pWin->optional);
3618 pWin->optional = NULL;
3623 #if NeedFunctionPrototypes
3624 DrawLogo(WindowPtr pWin)
3633 unsigned int width, height, size;
3636 DDXPointRec poly[4];
3637 ChangeGCVal fore[2], back[2];
3639 BITS32 fmask, bmask;
3642 pDraw = (DrawablePtr)pWin;
3643 pScreen = pDraw->pScreen;
3644 x = -pWin->origin.x;
3645 y = -pWin->origin.y;
3646 width = pScreen->width;
3647 height = pScreen->height;
3648 pGC = GetScratchGC(pScreen->rootDepth, pScreen);
3652 if ((rand() % 100) <= 17) /* make the probability for white fairly low */
3653 fore[0].val = pScreen->whitePixel;
3655 fore[0].val = pScreen->blackPixel;
3656 if ((pWin->backgroundState == BackgroundPixel) &&
3657 (cmap = (ColormapPtr)LookupIDByType(wColormap (pWin), RT_COLORMAP))) {
3658 Pixel querypixels[2];
3660 querypixels[0] = fore[0].val;
3661 querypixels[1] = pWin->background.pixel;
3662 QueryColors(cmap, 2, querypixels, rgb);
3663 if ((rgb[0].red == rgb[1].red) &&
3664 (rgb[0].green == rgb[1].green) &&
3665 (rgb[0].blue == rgb[1].blue)) {
3666 if (fore[0].val == pScreen->blackPixel)
3667 fore[0].val = pScreen->whitePixel;
3669 fore[0].val = pScreen->blackPixel;
3672 fore[1].val = FillSolid;
3673 fmask = GCForeground|GCFillStyle;
3674 if (pWin->backgroundState == BackgroundPixel) {
3675 back[0].val = pWin->background.pixel;
3676 back[1].val = FillSolid;
3677 bmask = GCForeground|GCFillStyle;
3681 dixChangeGC(NullClient, pGC, GCTileStipXOrigin|GCTileStipYOrigin,
3683 back[0].val = FillTiled;
3684 back[1].ptr = pWin->background.pixmap;
3685 bmask = GCFillStyle|GCTile;
3688 /* should be the same as the reference function XmuDrawLogo() */
3693 size = RANDOM_WIDTH + rand() % (size - RANDOM_WIDTH);
3695 x += rand() % (width - size);
3696 y += rand() % (height - size);
3699 * Draw what will be the thin strokes.
3709 * Point d is 9/44 (~1/5) of the way across.
3713 if (thin < 1) thin = 1;
3715 d31 = thin + thin + gap;
3716 poly[0].x = x + size; poly[0].y = y;
3717 poly[1].x = x + size-d31; poly[1].y = y;
3718 poly[2].x = x + 0; poly[2].y = y + size;
3719 poly[3].x = x + d31; poly[3].y = y + size;
3720 dixChangeGC(NullClient, pGC, fmask, NULL, fore);
3721 ValidateGC(pDraw, pGC);
3722 (*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);
3725 * Erase area not needed for lower thin stroke.
3735 poly[0].x = x + d31/2; poly[0].y = y + size;
3736 poly[1].x = x + size / 2; poly[1].y = y + size/2;
3737 poly[2].x = x + (size/2)+(d31-(d31/2)); poly[2].y = y + size/2;
3738 poly[3].x = x + d31; poly[3].y = y + size;
3739 dixChangeGC(NullClient, pGC, bmask, NULL, back);
3740 ValidateGC(pDraw, pGC);
3741 (*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);
3744 * Erase area not needed for upper thin stroke.
3754 poly[0].x = x + size - d31/2; poly[0].y = y;
3755 poly[1].x = x + size / 2; poly[1].y = y + size/2;
3756 poly[2].x = x + (size/2)-(d31-(d31/2)); poly[2].y = y + size/2;
3757 poly[3].x = x + size - d31; poly[3].y = y;
3758 ValidateGC(pDraw, pGC);
3759 (*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);
3762 * Draw thick stroke.
3763 * Point b is 1/4 of the way across.
3774 poly[0].x = x; poly[0].y = y;
3775 poly[1].x = x + size/4; poly[1].y = y;
3776 poly[2].x = x + size; poly[2].y = y + size;
3777 poly[3].x = x + size - size/4; poly[3].y = y + size;
3778 dixChangeGC(NullClient, pGC, fmask, NULL, fore);
3779 ValidateGC(pDraw, pGC);
3780 (*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);
3783 * Erase to create gap.
3792 poly[0].x = x + size- thin; poly[0].y = y;
3793 poly[1].x = x + size-( thin+gap); poly[1].y = y;
3794 poly[2].x = x + thin; poly[2].y = y + size;
3795 poly[3].x = x + thin + gap; poly[3].y = y + size;
3796 dixChangeGC(NullClient, pGC, bmask, NULL, back);
3797 ValidateGC(pDraw, pGC);
3798 (*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);