1
/* $XdotOrg: xserver/xorg/dix/window.c,v 1.13 2006/01/12 22:14:56 sandmann Exp $ */
2
/* $Xorg: window.c,v 1.4 2001/02/09 02:04:41 xorgcvs Exp $ */
5
Copyright 1987, 1998 The Open Group
7
Permission to use, copy, modify, distribute, and sell this software and its
8
documentation for any purpose is hereby granted without fee, provided that
9
the above copyright notice appear in all copies and that both that
10
copyright notice and this permission notice appear in supporting
13
The above copyright notice and this permission notice shall be included
14
in all copies or substantial portions of the Software.
16
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19
IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
20
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22
OTHER DEALINGS IN THE SOFTWARE.
24
Except as contained in this notice, the name of The Open Group shall
25
not be used in advertising or otherwise to promote the sale, use or
26
other dealings in this Software without prior written authorization
30
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
34
Permission to use, copy, modify, and distribute this software and its
35
documentation for any purpose and without fee is hereby granted,
36
provided that the above copyright notice appear in all copies and that
37
both that copyright notice and this permission notice appear in
38
supporting documentation, and that the name of Digital not be
39
used in advertising or publicity pertaining to distribution of the
40
software without specific, written prior permission.
42
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
43
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
44
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
45
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
46
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
47
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
52
/* The panoramix components contained the following notice */
53
/*****************************************************************
55
Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts.
57
Permission is hereby granted, free of charge, to any person obtaining a copy
58
of this software and associated documentation files (the "Software"), to deal
59
in the Software without restriction, including without limitation the rights
60
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
61
copies of the Software.
63
The above copyright notice and this permission notice shall be included in
64
all copies or substantial portions of the Software.
66
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
67
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
68
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
69
DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
70
BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY,
71
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
72
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
74
Except as contained in this notice, the name of Digital Equipment Corporation
75
shall not be used in advertising or otherwise to promote the sale, use or other
76
dealings in this Software without prior written authorization from Digital
77
Equipment Corporation.
79
******************************************************************/
81
/* $XFree86: xc/programs/Xserver/dix/window.c,v 3.36 2003/11/14 23:52:50 torrey Exp $ */
83
#ifdef HAVE_DIX_CONFIG_H
84
#include <dix-config.h>
88
#include "scrnintstr.h"
90
#include "regionstr.h"
92
#include "windowstr.h"
95
#include "colormapst.h"
96
#include "cursorstr.h"
97
#include "dixstruct.h"
101
#include "panoramiX.h"
102
#include "panoramiXsrv.h"
104
#include "dixevents.h"
108
#include <X11/extensions/Xagsrv.h>
111
#define _SECURITY_SERVER
112
#include <X11/extensions/security.h>
116
* Window stuff for server
118
* CreateRootWindow, CreateWindow, ChangeWindowAttributes,
119
* GetWindowAttributes, DeleteWindow, DestroySubWindows,
120
* HandleSaveSet, ReparentWindow, MapWindow, MapSubWindows,
121
* UnmapWindow, UnmapSubWindows, ConfigureWindow, CirculateWindow,
125
static unsigned char _back_lsb[4] = {0x88, 0x22, 0x44, 0x11};
126
static unsigned char _back_msb[4] = {0x11, 0x44, 0x22, 0x88};
128
int screenIsSaved = SCREEN_SAVER_OFF;
130
ScreenSaverStuffRec savedScreenInfo[MAXSCREENS];
133
extern void DeleteWindowFromAnyEvents();
134
extern Mask EventMaskForClient();
135
extern void WindowHasNewCursor();
136
extern void RecalculateDeliverableEvents();
139
static Bool TileScreenSaver(int i, int kind);
142
#define INPUTONLY_LEGAL_MASK (CWWinGravity | CWEventMask | \
143
CWDontPropagate | CWOverrideRedirect | CWCursor )
145
#define BOXES_OVERLAP(b1, b2) \
146
(!( ((b1)->x2 <= (b2)->x1) || \
147
( ((b1)->x1 >= (b2)->x2)) || \
148
( ((b1)->y2 <= (b2)->y1)) || \
149
( ((b1)->y1 >= (b2)->y2)) ) )
151
#define RedirectSend(pWin) \
152
((pWin->eventMask|wOtherEventMasks(pWin)) & SubstructureRedirectMask)
154
#define SubSend(pWin) \
155
((pWin->eventMask|wOtherEventMasks(pWin)) & SubstructureNotifyMask)
157
#define StrSend(pWin) \
158
((pWin->eventMask|wOtherEventMasks(pWin)) & StructureNotifyMask)
160
#define SubStrSend(pWin,pParent) (StrSend(pWin) || SubSend(pParent))
163
int numSaveUndersViewable = 0;
164
int deltaSaveUndersViewable = 0;
173
PrintChildren(WindowPtr p1, int indent)
181
for (i=0; i<indent; i++) ErrorF( " ");
182
ErrorF( "%x\n", p1->drawable.id);
183
miPrintRegion(&p1->clipList);
184
PrintChildren(p2, indent+4);
194
for (i=0; i<screenInfo.numScreens; i++)
196
ErrorF( "WINDOW %d\n", i);
197
pWin = WindowTable[i];
198
miPrintRegion(&pWin->clipList);
199
p1 = pWin->firstChild;
200
PrintChildren(p1, 4);
206
TraverseTree(register WindowPtr pWin, VisitWindowProcPtr func, pointer data)
209
register WindowPtr pChild;
211
if (!(pChild = pWin))
215
result = (* func)(pChild, data);
216
if (result == WT_STOPWALKING)
217
return(WT_STOPWALKING);
218
if ((result == WT_WALKCHILDREN) && pChild->firstChild)
220
pChild = pChild->firstChild;
223
while (!pChild->nextSib && (pChild != pWin))
224
pChild = pChild->parent;
227
pChild = pChild->nextSib;
234
* Walk the window tree, for SCREEN, preforming FUNC(pWin, data) on
235
* each window. If FUNC returns WT_WALKCHILDREN, traverse the children,
236
* if it returns WT_DONTWALKCHILDREN, dont. If it returns WT_STOPWALKING
237
* exit WalkTree. Does depth-first traverse.
241
WalkTree(ScreenPtr pScreen, VisitWindowProcPtr func, pointer data)
243
return(TraverseTree(WindowTable[pScreen->myNum], func, data));
246
/* hack for forcing backing store on all windows */
247
int defaultBackingStore = NotUseful;
248
/* hack to force no backing store */
249
Bool disableBackingStore = FALSE;
250
Bool enableBackingStore = FALSE;
251
/* hack to force no save unders */
252
Bool disableSaveUnders = FALSE;
255
SetWindowToDefaults(register WindowPtr pWin)
257
pWin->prevSib = NullWindow;
258
pWin->firstChild = NullWindow;
259
pWin->lastChild = NullWindow;
261
pWin->valdata = (ValidatePtr)NULL;
262
pWin->optional = (WindowOptPtr)NULL;
263
pWin->cursorIsNone = TRUE;
265
pWin->backingStore = NotUseful;
266
pWin->DIXsaveUnder = FALSE;
267
pWin->backStorage = (pointer) NULL;
269
pWin->mapped = FALSE; /* off */
270
pWin->realized = FALSE; /* off */
271
pWin->viewable = FALSE;
272
pWin->visibility = VisibilityNotViewable;
273
pWin->overrideRedirect = FALSE;
274
pWin->saveUnder = FALSE;
276
pWin->bitGravity = ForgetGravity;
277
pWin->winGravity = NorthWestGravity;
280
pWin->deliverableEvents = 0;
281
pWin->dontPropagate = 0;
282
pWin->forcedBS = FALSE;
283
#ifdef NEED_DBE_BUF_BITS
284
pWin->srcBuffer = DBE_FRONT_BUFFER;
285
pWin->dstBuffer = DBE_FRONT_BUFFER;
288
pWin->redirectDraw = 0;
293
MakeRootTile(WindowPtr pWin)
295
ScreenPtr pScreen = pWin->drawable.pScreen;
297
unsigned char back[128];
298
int len = BitmapBytePad(sizeof(long));
299
register unsigned char *from, *to;
302
pWin->background.pixmap = (*pScreen->CreatePixmap)(pScreen, 4, 4,
305
pWin->backgroundState = BackgroundPixmap;
306
pGC = GetScratchGC(pScreen->rootDepth, pScreen);
307
if (!pWin->background.pixmap || !pGC)
308
FatalError("could not create root tile");
311
CARD32 attributes[2];
313
attributes[0] = pScreen->whitePixel;
314
attributes[1] = pScreen->blackPixel;
316
(void)ChangeGC(pGC, GCForeground | GCBackground, attributes);
319
ValidateGC((DrawablePtr)pWin->background.pixmap, pGC);
321
from = (screenInfo.bitmapBitOrder == LSBFirst) ? _back_lsb : _back_msb;
324
for (i = 4; i > 0; i--, from++)
325
for (j = len; j > 0; j--)
329
bzero(back, sizeof(back));
331
(*pGC->ops->PutImage)((DrawablePtr)pWin->background.pixmap, pGC, 1,
332
0, 0, len, 4, 0, XYBitmap, (char *)back);
339
AllocateWindow(ScreenPtr pScreen)
343
register DevUnion *ppriv;
344
register unsigned *sizes;
345
register unsigned size;
348
pWin = (WindowPtr)xalloc(pScreen->totalWindowSize);
351
ppriv = (DevUnion *)(pWin + 1);
352
pWin->devPrivates = ppriv;
353
sizes = pScreen->WindowPrivateSizes;
354
ptr = (char *)(ppriv + pScreen->WindowPrivateLen);
355
for (i = pScreen->WindowPrivateLen; --i >= 0; ppriv++, sizes++)
357
if ( (size = *sizes) )
359
ppriv->ptr = (pointer)ptr;
363
ppriv->ptr = (pointer)NULL;
371
* Makes a window at initialization time for specified screen
375
CreateRootWindow(ScreenPtr pScreen)
379
PixmapFormatRec *format;
381
pWin = AllocateWindow(pScreen);
385
savedScreenInfo[pScreen->myNum].pWindow = NULL;
386
savedScreenInfo[pScreen->myNum].wid = FakeClientID(0);
387
savedScreenInfo[pScreen->myNum].ExternalScreenSaver = NULL;
388
screenIsSaved = SCREEN_SAVER_OFF;
390
WindowTable[pScreen->myNum] = pWin;
392
pWin->drawable.pScreen = pScreen;
393
pWin->drawable.type = DRAWABLE_WINDOW;
395
pWin->drawable.depth = pScreen->rootDepth;
396
for (format = screenInfo.formats;
397
format->depth != pScreen->rootDepth;
400
pWin->drawable.bitsPerPixel = format->bitsPerPixel;
402
pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
404
pWin->parent = NullWindow;
405
SetWindowToDefaults(pWin);
407
pWin->optional = (WindowOptRec *) xalloc (sizeof (WindowOptRec));
411
pWin->optional->dontPropagateMask = 0;
412
pWin->optional->otherEventMasks = 0;
413
pWin->optional->otherClients = NULL;
414
pWin->optional->passiveGrabs = NULL;
415
pWin->optional->userProps = NULL;
416
pWin->optional->backingBitPlanes = ~0L;
417
pWin->optional->backingPixel = 0;
419
pWin->optional->boundingShape = NULL;
420
pWin->optional->clipShape = NULL;
421
pWin->optional->inputShape = NULL;
424
pWin->optional->inputMasks = NULL;
426
pWin->optional->colormap = pScreen->defColormap;
427
pWin->optional->visual = pScreen->rootVisual;
429
pWin->nextSib = NullWindow;
431
pWin->drawable.id = FakeClientID(0);
433
pWin->origin.x = pWin->origin.y = 0;
434
pWin->drawable.height = pScreen->height;
435
pWin->drawable.width = pScreen->width;
436
pWin->drawable.x = pWin->drawable.y = 0;
440
box.x2 = pScreen->width;
441
box.y2 = pScreen->height;
442
REGION_INIT(pScreen, &pWin->clipList, &box, 1);
443
REGION_INIT(pScreen, &pWin->winSize, &box, 1);
444
REGION_INIT(pScreen, &pWin->borderSize, &box, 1);
445
REGION_INIT(pScreen, &pWin->borderClip, &box, 1);
447
pWin->drawable.class = InputOutput;
448
pWin->optional->visual = pScreen->rootVisual;
450
pWin->backgroundState = BackgroundPixel;
451
pWin->background.pixel = pScreen->whitePixel;
453
pWin->borderIsPixel = TRUE;
454
pWin->border.pixel = pScreen->blackPixel;
455
pWin->borderWidth = 0;
457
if (!AddResource(pWin->drawable.id, RT_WINDOW, (pointer)pWin))
460
if (disableBackingStore)
461
pScreen->backingStoreSupport = NotUseful;
462
if (enableBackingStore)
463
pScreen->backingStoreSupport = Always;
465
#ifdef DO_SAVE_UNDERS
466
if ((pScreen->backingStoreSupport != NotUseful) &&
467
(pScreen->saveUnderSupport == NotUseful))
470
* If the screen has backing-store but no save-unders, let the
471
* clients know we can support save-unders using backing-store.
473
pScreen->saveUnderSupport = USE_DIX_SAVE_UNDERS;
475
#endif /* DO_SAVE_UNDERS */
477
if (disableSaveUnders)
478
pScreen->saveUnderSupport = NotUseful;
484
InitRootWindow(WindowPtr pWin)
486
ScreenPtr pScreen = pWin->drawable.pScreen;
488
if (!(*pScreen->CreateWindow)(pWin))
490
(*pScreen->PositionWindow)(pWin, 0, 0);
492
pWin->cursorIsNone = FALSE;
493
pWin->optional->cursor = rootCursor;
494
rootCursor->refcnt++;
496
pWin->backingStore = defaultBackingStore;
497
pWin->forcedBS = (defaultBackingStore != NotUseful);
498
/* We SHOULD check for an error value here XXX */
499
(*pScreen->ChangeWindowAttributes)(pWin,
500
CWBackPixmap|CWBorderPixel|CWCursor|CWBackingStore);
502
MapWindow(pWin, serverClient);
505
/* Set the region to the intersection of the rectangle and the
506
* window's winSize. The window is typically the parent of the
507
* window from which the region came.
511
ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
512
register int x, register int y,
513
register int w, register int h)
515
ScreenPtr pScreen = pWin->drawable.pScreen;
518
box = *(REGION_EXTENTS(pScreen, &pWin->winSize));
519
/* we do these calculations to avoid overflows */
534
REGION_RESET(pScreen, Rgn, &box);
535
REGION_INTERSECT(pScreen, Rgn, Rgn, &pWin->winSize);
539
RealChildHead(register WindowPtr pWin)
542
(screenIsSaved == SCREEN_SAVER_ON) &&
543
(HasSaverWindow (pWin->drawable.pScreen->myNum)))
544
return (pWin->firstChild);
551
* Makes a window in response to client request
555
CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
556
unsigned h, unsigned bw, unsigned class, register Mask vmask, XID *vlist,
557
int depth, ClientPtr client, VisualID visual, int *error)
559
register WindowPtr pWin;
561
register ScreenPtr pScreen;
566
PixmapFormatRec *format;
567
register WindowOptPtr ancwopt;
569
if (class == CopyFromParent)
570
class = pParent->drawable.class;
572
if ((class != InputOutput) && (class != InputOnly))
575
client->errorValue = class;
579
if ((class != InputOnly) && (pParent->drawable.class == InputOnly))
585
if ((class == InputOnly) && ((bw != 0) || (depth != 0)))
591
pScreen = pParent->drawable.pScreen;
592
if ((class == InputOutput) && (depth == 0))
593
depth = pParent->drawable.depth;
594
ancwopt = pParent->optional;
596
ancwopt = FindWindowWithOptional(pParent)->optional;
597
if (visual == CopyFromParent) {
601
if (client->appgroup && !pParent->parent &&
602
(ag_visual = XagRootVisual (client)))
606
visual = ancwopt->visual;
609
/* Find out if the depth and visual are acceptable for this Screen */
610
if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth))
613
for(idepth = 0; idepth < pScreen->numDepths; idepth++)
615
pDepth = (DepthPtr) &pScreen->allowedDepths[idepth];
616
if ((depth == pDepth->depth) || (depth == 0))
618
for (ivisual = 0; ivisual < pDepth->numVids; ivisual++)
620
if (visual == pDepth->vids[ivisual])
635
if (((vmask & (CWBorderPixmap | CWBorderPixel)) == 0) &&
636
(class != InputOnly) &&
637
(depth != pParent->drawable.depth))
643
if (((vmask & CWColormap) == 0) &&
644
(class != InputOnly) &&
645
((visual != ancwopt->visual) || (ancwopt->colormap == None)))
651
pWin = AllocateWindow(pScreen);
657
pWin->drawable = pParent->drawable;
658
pWin->drawable.depth = depth;
659
if (depth == pParent->drawable.depth)
660
pWin->drawable.bitsPerPixel = pParent->drawable.bitsPerPixel;
663
for (format = screenInfo.formats; format->depth != depth; format++)
665
pWin->drawable.bitsPerPixel = format->bitsPerPixel;
667
if (class == InputOnly)
668
pWin->drawable.type = (short) UNDRAWABLE_WINDOW;
669
pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
671
pWin->drawable.id = wid;
672
pWin->drawable.class = class;
674
pWin->parent = pParent;
675
SetWindowToDefaults(pWin);
677
if (visual != ancwopt->visual)
679
if (!MakeWindowOptional (pWin))
685
pWin->optional->visual = visual;
686
pWin->optional->colormap = None;
689
pWin->borderWidth = bw;
691
/* can't let untrusted clients have background None windows;
692
* they make it too easy to steal window contents
694
if (client->trustLevel != XSecurityClientTrusted)
696
pWin->backgroundState = BackgroundPixel;
697
pWin->background.pixel = 0;
701
pWin->backgroundState = None;
703
pWin->borderIsPixel = pParent->borderIsPixel;
704
pWin->border = pParent->border;
705
if (pWin->borderIsPixel == FALSE)
706
pWin->border.pixmap->refcnt++;
708
pWin->origin.x = x + (int)bw;
709
pWin->origin.y = y + (int)bw;
710
pWin->drawable.width = w;
711
pWin->drawable.height = h;
712
pWin->drawable.x = pParent->drawable.x + x + (int)bw;
713
pWin->drawable.y = pParent->drawable.y + y + (int)bw;
715
/* set up clip list correctly for unobscured WindowPtr */
716
REGION_NULL(pScreen, &pWin->clipList);
717
REGION_NULL(pScreen, &pWin->borderClip);
718
REGION_NULL(pScreen, &pWin->winSize);
719
REGION_NULL(pScreen, &pWin->borderSize);
721
pHead = RealChildHead(pParent);
724
pWin->nextSib = pHead->nextSib;
726
pHead->nextSib->prevSib = pWin;
728
pParent->lastChild = pWin;
729
pHead->nextSib = pWin;
730
pWin->prevSib = pHead;
734
pWin->nextSib = pParent->firstChild;
735
if (pParent->firstChild)
736
pParent->firstChild->prevSib = pWin;
738
pParent->lastChild = pWin;
739
pParent->firstChild = pWin;
743
SetBorderSize (pWin);
745
/* We SHOULD check for an error value here XXX */
746
if (!(*pScreen->CreateWindow)(pWin))
749
DeleteWindow(pWin, None);
752
/* We SHOULD check for an error value here XXX */
753
(*pScreen->PositionWindow)(pWin, pWin->drawable.x, pWin->drawable.y);
755
if (!(vmask & CWEventMask))
756
RecalculateDeliverableEvents(pWin);
759
*error = ChangeWindowAttributes(pWin, vmask, vlist, wClient (pWin));
763
if (*error != Success)
765
DeleteWindow(pWin, None);
768
if (!(vmask & CWBackingStore) && (defaultBackingStore != NotUseful))
770
XID value = defaultBackingStore;
771
(void)ChangeWindowAttributes(pWin, CWBackingStore, &value, wClient (pWin));
772
pWin->forcedBS = TRUE;
775
if (SubSend(pParent))
777
event.u.u.type = CreateNotify;
778
event.u.createNotify.window = wid;
779
event.u.createNotify.parent = pParent->drawable.id;
780
event.u.createNotify.x = x;
781
event.u.createNotify.y = y;
782
event.u.createNotify.width = w;
783
event.u.createNotify.height = h;
784
event.u.createNotify.borderWidth = bw;
785
event.u.createNotify.override = pWin->overrideRedirect;
786
DeliverEvents(pParent, &event, 1, NullWindow);
792
FreeWindowResources(register WindowPtr pWin)
794
register ScreenPtr pScreen = pWin->drawable.pScreen;
796
DeleteWindowFromAnySaveSet(pWin);
797
DeleteWindowFromAnySelections(pWin);
798
DeleteWindowFromAnyEvents(pWin, TRUE);
799
REGION_UNINIT(pScreen, &pWin->clipList);
800
REGION_UNINIT(pScreen, &pWin->winSize);
801
REGION_UNINIT(pScreen, &pWin->borderClip);
802
REGION_UNINIT(pScreen, &pWin->borderSize);
804
if (wBoundingShape (pWin))
805
REGION_DESTROY(pScreen, wBoundingShape (pWin));
806
if (wClipShape (pWin))
807
REGION_DESTROY(pScreen, wClipShape (pWin));
808
if (wInputShape (pWin))
809
REGION_DESTROY(pScreen, wInputShape (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
CrushTree(WindowPtr pWin)
825
register WindowPtr pChild, pSib, pParent;
826
UnrealizeWindowProcPtr UnrealizeWindow;
829
if (!(pChild = pWin->firstChild))
831
UnrealizeWindow = pWin->drawable.pScreen->UnrealizeWindow;
834
if (pChild->firstChild)
836
pChild = pChild->firstChild;
841
pParent = pChild->parent;
842
if (SubStrSend(pChild, pParent))
844
event.u.u.type = DestroyNotify;
845
event.u.destroyNotify.window = pChild->drawable.id;
846
DeliverEvents(pChild, &event, 1, NullWindow);
848
FreeResource(pChild->drawable.id, RT_WINDOW);
849
pSib = pChild->nextSib;
850
#ifdef DO_SAVE_UNDERS
851
if (pChild->saveUnder && pChild->viewable)
852
deltaSaveUndersViewable--;
854
pChild->viewable = FALSE;
855
if (pChild->realized)
857
pChild->realized = FALSE;
858
(*UnrealizeWindow)(pChild);
860
FreeWindowResources(pChild);
862
if ( (pChild = pSib) )
865
pChild->firstChild = NullWindow;
866
pChild->lastChild = NullWindow;
875
* Deletes child of window then window itself
876
* If wid is None, don't send any events
880
DeleteWindow(pointer value, XID wid)
882
register WindowPtr pParent;
883
register WindowPtr pWin = (WindowPtr)value;
886
UnmapWindow(pWin, FALSE);
890
pParent = pWin->parent;
891
if (wid && pParent && SubStrSend(pWin, pParent))
893
event.u.u.type = DestroyNotify;
894
event.u.destroyNotify.window = pWin->drawable.id;
895
DeliverEvents(pWin, &event, 1, NullWindow);
898
FreeWindowResources(pWin);
901
if (pParent->firstChild == pWin)
902
pParent->firstChild = pWin->nextSib;
903
if (pParent->lastChild == pWin)
904
pParent->lastChild = pWin->prevSib;
906
pWin->nextSib->prevSib = pWin->prevSib;
908
pWin->prevSib->nextSib = pWin->nextSib;
915
DestroySubwindows(register WindowPtr pWin, ClientPtr client)
918
* The protocol is quite clear that each window should be
919
* destroyed in turn, however, unmapping all of the first
920
* eliminates most of the calls to ValidateTree. So,
921
* this implementation is incorrect in that all of the
922
* UnmapNotifies occur before all of the DestroyNotifies.
923
* If you care, simply delete the call to UnmapSubwindows.
925
UnmapSubwindows(pWin);
926
while (pWin->lastChild)
927
FreeResource(pWin->lastChild->drawable.id, RT_NONE);
930
#define DeviceEventMasks (KeyPressMask | KeyReleaseMask | ButtonPressMask | \
931
ButtonReleaseMask | PointerMotionMask)
934
* ChangeWindowAttributes
936
* The value-mask specifies which attributes are to be changed; the
937
* value-list contains one value for each one bit in the mask, from least
938
* to most significant bit in the mask.
942
ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPtr client)
944
register Mask index2;
945
register XID *pVlist;
948
CursorPtr pCursor, pOldCursor;
955
register ScreenPtr pScreen;
960
Bool checkOptional = FALSE;
961
Bool borderRelative = FALSE;
964
if ((pWin->drawable.class == InputOnly) && (vmask & (~INPUTONLY_LEGAL_MASK)))
968
pScreen = pWin->drawable.pScreen;
973
index2 = (Mask) lowbit (tmask);
978
pixID = (Pixmap )*pVlist;
980
if (pWin->backgroundState == ParentRelative)
981
borderRelative = TRUE;
985
/* can't let untrusted clients have background None windows */
986
if (client->trustLevel == XSecurityClientTrusted)
989
if (pWin->backgroundState == BackgroundPixmap)
990
(*pScreen->DestroyPixmap)(pWin->background.pixmap);
994
pWin->backgroundState = None;
998
{ /* didn't change the background to None, so don't tell ddx */
1003
else if (pixID == ParentRelative)
1006
pWin->drawable.depth != pWin->parent->drawable.depth)
1011
if (pWin->backgroundState == BackgroundPixmap)
1012
(*pScreen->DestroyPixmap)(pWin->background.pixmap);
1016
pWin->backgroundState = ParentRelative;
1017
borderRelative = TRUE;
1018
/* Note that the parent's backgroundTile's refcnt is NOT
1023
pPixmap = (PixmapPtr)SecurityLookupIDByType(client, pixID,
1024
RT_PIXMAP, SecurityReadAccess);
1025
if (pPixmap != (PixmapPtr) NULL)
1027
if ((pPixmap->drawable.depth != pWin->drawable.depth) ||
1028
(pPixmap->drawable.pScreen != pScreen))
1033
if (pWin->backgroundState == BackgroundPixmap)
1034
(*pScreen->DestroyPixmap)(pWin->background.pixmap);
1035
pWin->backgroundState = BackgroundPixmap;
1036
pWin->background.pixmap = pPixmap;
1042
client->errorValue = pixID;
1048
if (pWin->backgroundState == ParentRelative)
1049
borderRelative = TRUE;
1050
if (pWin->backgroundState == BackgroundPixmap)
1051
(*pScreen->DestroyPixmap)(pWin->background.pixmap);
1052
pWin->backgroundState = BackgroundPixel;
1053
pWin->background.pixel = (CARD32 ) *pVlist;
1054
/* background pixel overrides background pixmap,
1055
so don't let the ddx layer see both bits */
1056
vmaskCopy &= ~CWBackPixmap;
1059
case CWBorderPixmap:
1060
pixID = (Pixmap ) *pVlist;
1062
if (pixID == CopyFromParent)
1064
if (!pWin->parent ||
1065
(pWin->drawable.depth != pWin->parent->drawable.depth))
1070
if (pWin->borderIsPixel == FALSE)
1071
(*pScreen->DestroyPixmap)(pWin->border.pixmap);
1072
pWin->border = pWin->parent->border;
1073
if ((pWin->borderIsPixel = pWin->parent->borderIsPixel) == TRUE)
1075
index2 = CWBorderPixel;
1079
pWin->parent->border.pixmap->refcnt++;
1084
pPixmap = (PixmapPtr)SecurityLookupIDByType(client, pixID,
1085
RT_PIXMAP, SecurityReadAccess);
1088
if ((pPixmap->drawable.depth != pWin->drawable.depth) ||
1089
(pPixmap->drawable.pScreen != pScreen))
1094
if (pWin->borderIsPixel == FALSE)
1095
(*pScreen->DestroyPixmap)(pWin->border.pixmap);
1096
pWin->borderIsPixel = FALSE;
1097
pWin->border.pixmap = pPixmap;
1103
client->errorValue = pixID;
1109
if (pWin->borderIsPixel == FALSE)
1110
(*pScreen->DestroyPixmap)(pWin->border.pixmap);
1111
pWin->borderIsPixel = TRUE;
1112
pWin->border.pixel = (CARD32) *pVlist;
1113
/* border pixel overrides border pixmap,
1114
so don't let the ddx layer see both bits */
1115
vmaskCopy &= ~CWBorderPixmap;
1119
val = (CARD8 )*pVlist;
1121
if (val > StaticGravity)
1124
client->errorValue = val;
1127
pWin->bitGravity = val;
1130
val = (CARD8 )*pVlist;
1132
if (val > StaticGravity)
1135
client->errorValue = val;
1138
pWin->winGravity = val;
1140
case CWBackingStore:
1141
val = (CARD8 )*pVlist;
1143
if ((val != NotUseful) && (val != WhenMapped) && (val != Always))
1146
client->errorValue = val;
1149
pWin->backingStore = val;
1150
pWin->forcedBS = FALSE;
1152
case CWBackingPlanes:
1153
if (pWin->optional || ((CARD32)*pVlist != (CARD32)~0L)) {
1154
if (!pWin->optional && !MakeWindowOptional (pWin))
1159
pWin->optional->backingBitPlanes = (CARD32) *pVlist;
1160
if ((CARD32)*pVlist == (CARD32)~0L)
1161
checkOptional = TRUE;
1165
case CWBackingPixel:
1166
if (pWin->optional || (CARD32) *pVlist) {
1167
if (!pWin->optional && !MakeWindowOptional (pWin))
1172
pWin->optional->backingPixel = (CARD32) *pVlist;
1174
checkOptional = TRUE;
1179
val = (BOOL) *pVlist;
1181
if ((val != xTrue) && (val != xFalse))
1184
client->errorValue = val;
1187
#ifdef DO_SAVE_UNDERS
1188
if (pWin->parent && (pWin->saveUnder != val) && (pWin->viewable) &&
1189
DO_SAVE_UNDERS(pWin))
1192
* Re-check all siblings and inferiors for obscurity or
1193
* exposition (hee hee).
1195
if (pWin->saveUnder)
1196
deltaSaveUndersViewable--;
1198
deltaSaveUndersViewable++;
1199
pWin->saveUnder = val;
1201
if (pWin->firstChild)
1203
pLayerWin = (*pScreen->GetLayerWindow)(pWin);
1204
if ((*pScreen->ChangeSaveUnder)(pLayerWin->parent, pWin->nextSib))
1205
(*pScreen->PostChangeSaveUnder)(pLayerWin->parent,
1210
if ((*pScreen->ChangeSaveUnder)(pWin, pWin->nextSib))
1211
(*pScreen->PostChangeSaveUnder)(pWin,
1217
/* If we're changing the saveUnder attribute of the root
1218
* window, all we do is set pWin->saveUnder so that
1219
* GetWindowAttributes returns the right value. We don't
1220
* do the "normal" save-under processing (as above).
1221
* Hope that doesn't cause any problems.
1223
pWin->saveUnder = val;
1226
pWin->saveUnder = val;
1227
#endif /* DO_SAVE_UNDERS */
1230
result = EventSelectForWindow(pWin, client, (Mask )*pVlist);
1238
case CWDontPropagate:
1239
result = EventSuppressForWindow(pWin, client, (Mask )*pVlist,
1248
case CWOverrideRedirect:
1249
val = (BOOL ) *pVlist;
1251
if ((val != xTrue) && (val != xFalse))
1254
client->errorValue = val;
1257
pWin->overrideRedirect = val;
1260
cmap = (Colormap) *pVlist;
1262
if (cmap == CopyFromParent)
1265
Colormap ag_colormap;
1266
ClientPtr win_owner;
1269
* win_owner == client for CreateWindow, other clients
1270
* can ChangeWindowAttributes
1272
win_owner = clients[CLIENT_ID(pWin->drawable.id)];
1274
if ( win_owner && win_owner->appgroup &&
1275
!pWin->parent->parent &&
1276
(ag_colormap = XagDefaultColormap (win_owner)))
1282
pWin->optional->visual == wVisual (pWin->parent)))
1284
cmap = wColormap (pWin->parent);
1294
pCmap = (ColormapPtr)SecurityLookupIDByType(client, cmap,
1295
RT_COLORMAP, SecurityReadAccess);
1299
client->errorValue = cmap;
1302
if (pCmap->pVisual->vid != wVisual (pWin) ||
1303
pCmap->pScreen != pScreen)
1308
if (cmap != wColormap (pWin))
1310
if (!pWin->optional)
1312
if (!MakeWindowOptional (pWin))
1318
else if (pWin->parent && cmap == wColormap (pWin->parent))
1319
checkOptional = TRUE;
1322
* propagate the original colormap to any children
1326
for (pChild = pWin->firstChild; pChild; pChild=pChild->nextSib)
1328
if (!pChild->optional && !MakeWindowOptional (pChild))
1335
pWin->optional->colormap = cmap;
1338
* check on any children now matching the new colormap
1341
for (pChild = pWin->firstChild; pChild; pChild=pChild->nextSib)
1343
if (pChild->optional->colormap == cmap)
1344
CheckWindowOptionalNeed (pChild);
1347
xE.u.u.type = ColormapNotify;
1348
xE.u.colormap.window = pWin->drawable.id;
1349
xE.u.colormap.colormap = cmap;
1350
xE.u.colormap.new = xTrue;
1351
xE.u.colormap.state = IsMapInstalled(cmap, pWin);
1352
DeliverEvents(pWin, &xE, 1, NullWindow);
1356
cursorID = (Cursor ) *pVlist;
1361
if ( cursorID == None)
1363
if (pWin == WindowTable[pWin->drawable.pScreen->myNum])
1364
pCursor = rootCursor;
1366
pCursor = (CursorPtr) None;
1370
pCursor = (CursorPtr)SecurityLookupIDByType(client, cursorID,
1371
RT_CURSOR, SecurityReadAccess);
1375
client->errorValue = cursorID;
1380
if (pCursor != wCursor (pWin))
1383
* patch up child windows so they don't lose cursors.
1386
for (pChild = pWin->firstChild; pChild; pChild=pChild->nextSib)
1388
if (!pChild->optional && !pChild->cursorIsNone &&
1389
!MakeWindowOptional (pChild))
1397
if (pCursor == (CursorPtr) None)
1399
pWin->cursorIsNone = TRUE;
1402
pOldCursor = pWin->optional->cursor;
1403
pWin->optional->cursor = (CursorPtr) None;
1404
checkOptional = TRUE;
1407
if (!pWin->optional)
1409
if (!MakeWindowOptional (pWin))
1415
else if (pWin->parent && pCursor == wCursor (pWin->parent))
1416
checkOptional = TRUE;
1417
pOldCursor = pWin->optional->cursor;
1418
pWin->optional->cursor = pCursor;
1420
pWin->cursorIsNone = FALSE;
1422
* check on any children now matching the new cursor
1425
for (pChild=pWin->firstChild; pChild; pChild=pChild->nextSib)
1427
if (pChild->optional &&
1428
(pChild->optional->cursor == pCursor))
1429
CheckWindowOptionalNeed (pChild);
1434
WindowHasNewCursor( pWin);
1436
/* Can't free cursor until here - old cursor
1437
* is needed in WindowHasNewCursor
1440
FreeCursor (pOldCursor, (Cursor)0);
1445
client->errorValue = vmask;
1448
vmaskCopy |= index2;
1452
CheckWindowOptionalNeed (pWin);
1454
/* We SHOULD check for an error value here XXX */
1455
(*pScreen->ChangeWindowAttributes)(pWin, vmaskCopy);
1458
If the border contents have changed, redraw the border.
1459
Note that this has to be done AFTER pScreen->ChangeWindowAttributes
1460
for the tile to be rotated, and the correct function selected.
1462
if (((vmaskCopy & (CWBorderPixel | CWBorderPixmap)) || borderRelative)
1463
&& pWin->viewable && HasBorder (pWin))
1467
REGION_NULL(pScreen, &exposed);
1468
REGION_SUBTRACT(pScreen, &exposed, &pWin->borderClip, &pWin->winSize);
1469
(*pWin->drawable.pScreen->PaintWindowBorder)(pWin, &exposed, PW_BORDER);
1470
REGION_UNINIT(pScreen, &exposed);
1477
* GetWindowAttributes
1478
* Notice that this is different than ChangeWindowAttributes
1482
GetWindowAttributes(register WindowPtr pWin, ClientPtr client, xGetWindowAttributesReply *wa)
1485
wa->bitGravity = pWin->bitGravity;
1486
wa->winGravity = pWin->winGravity;
1487
if (pWin->forcedBS && pWin->backingStore != Always)
1488
wa->backingStore = NotUseful;
1490
wa->backingStore = pWin->backingStore;
1491
wa->length = (sizeof(xGetWindowAttributesReply) -
1492
sizeof(xGenericReply)) >> 2;
1493
wa->sequenceNumber = client->sequence;
1494
wa->backingBitPlanes = wBackingBitPlanes (pWin);
1495
wa->backingPixel = wBackingPixel (pWin);
1496
wa->saveUnder = (BOOL)pWin->saveUnder;
1497
wa->override = pWin->overrideRedirect;
1499
wa->mapState = IsUnmapped;
1500
else if (pWin->realized)
1501
wa->mapState = IsViewable;
1503
wa->mapState = IsUnviewable;
1505
wa->colormap = wColormap (pWin);
1506
wa->mapInstalled = (wa->colormap == None) ? xFalse
1507
: IsMapInstalled(wa->colormap, pWin);
1509
wa->yourEventMask = EventMaskForClient(pWin, client);
1510
wa->allEventMasks = pWin->eventMask | wOtherEventMasks (pWin);
1511
wa->doNotPropagateMask = wDontPropagateMask (pWin);
1512
wa->class = pWin->drawable.class;
1513
wa->visualID = wVisual (pWin);
1518
MoveWindowInStack(register WindowPtr pWin, register WindowPtr pNextSib)
1520
register WindowPtr pParent = pWin->parent;
1521
WindowPtr pFirstChange = pWin; /* highest window where list changes */
1523
if (pWin->nextSib != pNextSib)
1525
WindowPtr pOldNextSib = pWin->nextSib;
1527
if (!pNextSib) /* move to bottom */
1529
if (pParent->firstChild == pWin)
1530
pParent->firstChild = pWin->nextSib;
1531
/* if (pWin->nextSib) */ /* is always True: pNextSib == NULL
1532
* and pWin->nextSib != pNextSib
1533
* therefore pWin->nextSib != NULL */
1534
pFirstChange = pWin->nextSib;
1535
pWin->nextSib->prevSib = pWin->prevSib;
1537
pWin->prevSib->nextSib = pWin->nextSib;
1538
pParent->lastChild->nextSib = pWin;
1539
pWin->prevSib = pParent->lastChild;
1540
pWin->nextSib = NullWindow;
1541
pParent->lastChild = pWin;
1543
else if (pParent->firstChild == pNextSib) /* move to top */
1545
pFirstChange = pWin;
1546
if (pParent->lastChild == pWin)
1547
pParent->lastChild = pWin->prevSib;
1549
pWin->nextSib->prevSib = pWin->prevSib;
1551
pWin->prevSib->nextSib = pWin->nextSib;
1552
pWin->nextSib = pParent->firstChild;
1553
pWin->prevSib = (WindowPtr ) NULL;
1554
pNextSib->prevSib = pWin;
1555
pParent->firstChild = pWin;
1557
else /* move in middle of list */
1559
WindowPtr pOldNext = pWin->nextSib;
1561
pFirstChange = NullWindow;
1562
if (pParent->firstChild == pWin)
1563
pFirstChange = pParent->firstChild = pWin->nextSib;
1564
if (pParent->lastChild == pWin) {
1565
pFirstChange = pWin;
1566
pParent->lastChild = pWin->prevSib;
1569
pWin->nextSib->prevSib = pWin->prevSib;
1571
pWin->prevSib->nextSib = pWin->nextSib;
1572
pWin->nextSib = pNextSib;
1573
pWin->prevSib = pNextSib->prevSib;
1574
if (pNextSib->prevSib)
1575
pNextSib->prevSib->nextSib = pWin;
1576
pNextSib->prevSib = pWin;
1577
if (!pFirstChange) { /* do we know it yet? */
1578
pFirstChange = pParent->firstChild; /* no, search from top */
1579
while ((pFirstChange != pWin) && (pFirstChange != pOldNext))
1580
pFirstChange = pFirstChange->nextSib;
1583
if(pWin->drawable.pScreen->RestackWindow)
1584
(*pWin->drawable.pScreen->RestackWindow)(pWin, pOldNextSib);
1589
* In rootless mode we can't optimize away window restacks.
1590
* There may be non-X windows around, so even if the window
1591
* is in the correct position from X's point of view,
1592
* the underlying window system may want to reorder it.
1594
else if (pWin->drawable.pScreen->RestackWindow)
1595
(*pWin->drawable.pScreen->RestackWindow)(pWin, pWin->nextSib);
1598
return( pFirstChange );
1602
CreateUnclippedWinSize (register WindowPtr pWin)
1607
box.x1 = pWin->drawable.x;
1608
box.y1 = pWin->drawable.y;
1609
box.x2 = pWin->drawable.x + (int) pWin->drawable.width;
1610
box.y2 = pWin->drawable.y + (int) pWin->drawable.height;
1611
pRgn = REGION_CREATE(pWin->drawable.pScreen, &box, 1);
1613
if (wBoundingShape (pWin) || wClipShape (pWin)) {
1614
ScreenPtr pScreen = pWin->drawable.pScreen;
1616
REGION_TRANSLATE(pScreen, pRgn, - pWin->drawable.x,
1617
- pWin->drawable.y);
1618
if (wBoundingShape (pWin))
1619
REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
1620
if (wClipShape (pWin))
1621
REGION_INTERSECT(pScreen, pRgn, pRgn, wClipShape (pWin));
1622
REGION_TRANSLATE(pScreen, pRgn, pWin->drawable.x, pWin->drawable.y);
1629
SetWinSize (register WindowPtr pWin)
1632
if (pWin->redirectDraw)
1636
box.x1 = pWin->drawable.x;
1637
box.y1 = pWin->drawable.y;
1638
box.x2 = pWin->drawable.x + pWin->drawable.width;
1639
box.y2 = pWin->drawable.y + pWin->drawable.height;
1640
REGION_RESET (pScreen, &pWin->winSize, &box);
1644
ClippedRegionFromBox(pWin->parent, &pWin->winSize,
1645
pWin->drawable.x, pWin->drawable.y,
1646
(int)pWin->drawable.width,
1647
(int)pWin->drawable.height);
1649
if (wBoundingShape (pWin) || wClipShape (pWin)) {
1650
ScreenPtr pScreen = pWin->drawable.pScreen;
1652
REGION_TRANSLATE(pScreen, &pWin->winSize, - pWin->drawable.x,
1653
- pWin->drawable.y);
1654
if (wBoundingShape (pWin))
1655
REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
1656
wBoundingShape (pWin));
1657
if (wClipShape (pWin))
1658
REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
1660
REGION_TRANSLATE(pScreen, &pWin->winSize, pWin->drawable.x,
1667
SetBorderSize (register WindowPtr pWin)
1671
if (HasBorder (pWin)) {
1672
bw = wBorderWidth (pWin);
1674
if (pWin->redirectDraw)
1678
box.x1 = pWin->drawable.x - bw;
1679
box.y1 = pWin->drawable.y - bw;
1680
box.x2 = pWin->drawable.x + pWin->drawable.width + bw;
1681
box.y2 = pWin->drawable.y + pWin->drawable.height + bw;
1682
REGION_RESET (pScreen, &pWin->borderSize, &box);
1686
ClippedRegionFromBox(pWin->parent, &pWin->borderSize,
1687
pWin->drawable.x - bw, pWin->drawable.y - bw,
1688
(int)(pWin->drawable.width + (bw<<1)),
1689
(int)(pWin->drawable.height + (bw<<1)));
1691
if (wBoundingShape (pWin)) {
1692
ScreenPtr pScreen = pWin->drawable.pScreen;
1694
REGION_TRANSLATE(pScreen, &pWin->borderSize, - pWin->drawable.x,
1695
- pWin->drawable.y);
1696
REGION_INTERSECT(pScreen, &pWin->borderSize, &pWin->borderSize,
1697
wBoundingShape (pWin));
1698
REGION_TRANSLATE(pScreen, &pWin->borderSize, pWin->drawable.x,
1700
REGION_UNION(pScreen, &pWin->borderSize, &pWin->borderSize,
1705
REGION_COPY(pWin->drawable.pScreen, &pWin->borderSize,
1712
* \param x,y new window position
1713
* \param oldx,oldy old window position
1714
* \param destx,desty position relative to gravity
1718
GravityTranslate (register int x, register int y, int oldx, int oldy,
1719
int dw, int dh, unsigned gravity,
1720
register int *destx, register int *desty)
1724
*destx = x + dw / 2;
1727
case NorthEastGravity:
1733
*desty = y + dh / 2;
1736
*destx = x + dw / 2;
1737
*desty = y + dh / 2;
1741
*desty = y + dh / 2;
1743
case SouthWestGravity:
1748
*destx = x + dw / 2;
1751
case SouthEastGravity:
1766
/* XXX need to retile border on each window with ParentRelative origin */
1768
ResizeChildrenWinSize(register WindowPtr pWin, int dx, int dy, int dw, int dh)
1770
register ScreenPtr pScreen;
1771
register WindowPtr pSib, pChild;
1772
Bool resized = (dw || dh);
1774
pScreen = pWin->drawable.pScreen;
1776
for (pSib = pWin->firstChild; pSib; pSib = pSib->nextSib)
1778
if (resized && (pSib->winGravity > NorthWestGravity))
1782
cwsx = pSib->origin.x;
1783
cwsy = pSib->origin.y;
1784
GravityTranslate (cwsx, cwsy, cwsx - dx, cwsy - dy, dw, dh,
1785
pSib->winGravity, &cwsx, &cwsy);
1786
if (cwsx != pSib->origin.x || cwsy != pSib->origin.y)
1790
event.u.u.type = GravityNotify;
1791
event.u.gravity.window = pSib->drawable.id;
1792
event.u.gravity.x = cwsx - wBorderWidth (pSib);
1793
event.u.gravity.y = cwsy - wBorderWidth (pSib);
1794
DeliverEvents (pSib, &event, 1, NullWindow);
1795
pSib->origin.x = cwsx;
1796
pSib->origin.y = cwsy;
1799
pSib->drawable.x = pWin->drawable.x + pSib->origin.x;
1800
pSib->drawable.y = pWin->drawable.y + pSib->origin.y;
1802
SetBorderSize (pSib);
1803
(*pScreen->PositionWindow)(pSib, pSib->drawable.x, pSib->drawable.y);
1805
if ( (pChild = pSib->firstChild) )
1809
pChild->drawable.x = pChild->parent->drawable.x +
1811
pChild->drawable.y = pChild->parent->drawable.y +
1813
SetWinSize (pChild);
1814
SetBorderSize (pChild);
1815
(*pScreen->PositionWindow)(pChild,
1816
pChild->drawable.x, pChild->drawable.y);
1817
if (pChild->firstChild)
1819
pChild = pChild->firstChild;
1822
while (!pChild->nextSib && (pChild != pSib))
1823
pChild = pChild->parent;
1826
pChild = pChild->nextSib;
1832
#define GET_INT16(m, f) \
1835
f = (INT16) *pVlist;\
1838
#define GET_CARD16(m, f) \
1841
f = (CARD16) *pVlist;\
1845
#define GET_CARD8(m, f) \
1848
f = (CARD8) *pVlist;\
1852
#define ChangeMask ((Mask)(CWX | CWY | CWWidth | CWHeight))
1854
#define IllegalInputOnlyConfigureMask (CWBorderWidth)
1858
* returns Above if pSib above pMe in stack or Below otherwise
1863
register WindowPtr pMe,
1864
register WindowPtr pSib)
1866
register WindowPtr pWin;
1868
pWin = pMe->parent->firstChild;
1873
else if (pWin == pMe)
1875
pWin = pWin->nextSib;
1882
register WindowPtr pWin,
1883
register BoxPtr pBox)
1885
pBox->x1 = pWin->drawable.x - wBorderWidth (pWin);
1886
pBox->y1 = pWin->drawable.y - wBorderWidth (pWin);
1887
pBox->x2 = pWin->drawable.x + (int)pWin->drawable.width
1888
+ wBorderWidth (pWin);
1889
pBox->y2 = pWin->drawable.y + (int)pWin->drawable.height
1890
+ wBorderWidth (pWin);
1895
#define IS_SHAPED(pWin) (wBoundingShape (pWin) != (RegionPtr) NULL)
1898
MakeBoundingRegion (
1899
register WindowPtr pWin,
1903
ScreenPtr pScreen = pWin->drawable.pScreen;
1905
pRgn = REGION_CREATE(pScreen, pBox, 1);
1906
if (wBoundingShape (pWin)) {
1907
REGION_TRANSLATE(pScreen, pRgn, -pWin->origin.x,
1909
REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
1910
REGION_TRANSLATE(pScreen, pRgn, pWin->origin.x,
1923
RegionPtr pWinRgn, pSibRgn;
1924
register ScreenPtr pScreen;
1927
if (!IS_SHAPED(pWin) && !IS_SHAPED(pSib))
1929
pScreen = pWin->drawable.pScreen;
1930
pWinRgn = MakeBoundingRegion (pWin, pWinBox);
1931
pSibRgn = MakeBoundingRegion (pSib, pSibBox);
1932
REGION_INTERSECT(pScreen, pWinRgn, pWinRgn, pSibRgn);
1933
ret = REGION_NOTEMPTY(pScreen, pWinRgn);
1934
REGION_DESTROY(pScreen, pWinRgn);
1935
REGION_DESTROY(pScreen, pSibRgn);
1941
AnyWindowOverlapsMe(
1944
register BoxPtr box)
1946
register WindowPtr pSib;
1948
register BoxPtr sbox;
1950
for (pSib = pWin->prevSib; pSib != pHead; pSib = pSib->prevSib)
1954
sbox = WindowExtents(pSib, &sboxrec);
1955
if (BOXES_OVERLAP(sbox, box)
1957
&& ShapeOverlap (pWin, box, pSib, sbox)
1969
register BoxPtr box)
1971
register WindowPtr pSib;
1973
register BoxPtr sbox;
1975
for (pSib = pWin->nextSib; pSib; pSib = pSib->nextSib)
1979
sbox = WindowExtents(pSib, &sboxrec);
1980
if (BOXES_OVERLAP(sbox, box)
1982
&& ShapeOverlap (pWin, box, pSib, sbox)
1992
* WhereDoIGoInTheStack()
1993
* Given pWin and pSib and the relationshipe smode, return
1994
* the window that pWin should go ABOVE.
1995
* If a pSib is specified:
1996
* Above: pWin is placed just above pSib
1997
* Below: pWin is placed just below pSib
1998
* TopIf: if pSib occludes pWin, then pWin is placed
1999
* at the top of the stack
2000
* BottomIf: if pWin occludes pSib, then pWin is
2001
* placed at the bottom of the stack
2002
* Opposite: if pSib occludes pWin, then pWin is placed at the
2003
* top of the stack, else if pWin occludes pSib, then
2004
* pWin is placed at the bottom of the stack
2007
* Above: pWin is placed at the top of the stack
2008
* Below: pWin is placed at the bottom of the stack
2009
* TopIf: if any sibling occludes pWin, then pWin is placed at
2010
* the top of the stack
2011
* BottomIf: if pWin occludes any sibline, then pWin is placed at
2012
* the bottom of the stack
2013
* Opposite: if any sibling occludes pWin, then pWin is placed at
2014
* the top of the stack, else if pWin occludes any
2015
* sibling, then pWin is placed at the bottom of the stack
2020
WhereDoIGoInTheStack(
2021
register WindowPtr pWin,
2022
register WindowPtr pSib,
2030
register ScreenPtr pScreen;
2031
WindowPtr pHead, pFirst;
2033
if ((pWin == pWin->parent->firstChild) &&
2034
(pWin == pWin->parent->lastChild))
2035
return((WindowPtr ) NULL);
2036
pHead = RealChildHead(pWin->parent);
2037
pFirst = pHead ? pHead->nextSib : pWin->parent->firstChild;
2038
pScreen = pWin->drawable.pScreen;
2041
box.x2 = x + (int)w;
2042
box.y2 = y + (int)h;
2048
else if (pWin == pFirst)
2049
return(pWin->nextSib);
2054
if (pSib->nextSib != pWin)
2055
return(pSib->nextSib);
2057
return(pWin->nextSib);
2061
if ((!pWin->mapped || (pSib && !pSib->mapped)) && !permitOldBugs)
2062
return(pWin->nextSib);
2065
if ((IsSiblingAboveMe(pWin, pSib) == Above) &&
2066
(RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
2069
return(pWin->nextSib);
2071
else if (AnyWindowOverlapsMe(pWin, pHead, &box))
2074
return(pWin->nextSib);
2076
if ((!pWin->mapped || (pSib && !pSib->mapped)) && !permitOldBugs)
2077
return(pWin->nextSib);
2080
if ((IsSiblingAboveMe(pWin, pSib) == Below) &&
2081
(RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
2084
return(pWin->nextSib);
2086
else if (IOverlapAnyWindow(pWin, &box))
2089
return(pWin->nextSib);
2091
if ((!pWin->mapped || (pSib && !pSib->mapped)) && !permitOldBugs)
2092
return(pWin->nextSib);
2095
if (RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT)
2097
if (IsSiblingAboveMe(pWin, pSib) == Above)
2103
return(pWin->nextSib);
2105
else if (AnyWindowOverlapsMe(pWin, pHead, &box))
2107
/* If I'm occluded, I can't possibly be the first child
2108
* if (pWin == pWin->parent->firstChild)
2109
* return pWin->nextSib;
2113
else if (IOverlapAnyWindow(pWin, &box))
2116
return pWin->nextSib;
2119
ErrorF("Internal error in ConfigureWindow, smode == %d\n",smode );
2120
return pWin->nextSib;
2127
register WindowPtr pWin,
2128
register WindowPtr pSib,
2131
/* Note that pSib might be NULL */
2133
Bool WasViewable = (Bool)pWin->viewable;
2135
WindowPtr pFirstChange;
2136
#ifdef DO_SAVE_UNDERS
2137
Bool dosave = FALSE;
2139
WindowPtr pLayerWin;
2140
ScreenPtr pScreen = pWin->drawable.pScreen;
2142
/* if this is a root window, can't be restacked */
2146
pFirstChange = MoveWindowInStack(pWin, pSib);
2150
anyMarked = (*pScreen->MarkOverlappedWindows)(pWin, pFirstChange,
2152
if (pLayerWin != pWin) pFirstChange = pLayerWin;
2153
#ifdef DO_SAVE_UNDERS
2154
if (DO_SAVE_UNDERS(pWin))
2156
dosave = (*pScreen->ChangeSaveUnder)(pLayerWin, pFirstChange);
2158
#endif /* DO_SAVE_UNDERS */
2161
(*pScreen->ValidateTree)(pLayerWin->parent, pFirstChange, kind);
2162
(*pScreen->HandleExposures)(pLayerWin->parent);
2164
#ifdef DO_SAVE_UNDERS
2166
(*pScreen->PostChangeSaveUnder)(pLayerWin, pFirstChange);
2167
#endif /* DO_SAVE_UNDERS */
2168
if (anyMarked && pWin->drawable.pScreen->PostValidateTree)
2169
(*pScreen->PostValidateTree)(pLayerWin->parent, pFirstChange, kind);
2172
WindowsRestructured ();
2180
ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientPtr client)
2182
#define RESTACK_WIN 0
2184
#define RESIZE_WIN 2
2185
#define REBORDER_WIN 3
2186
register WindowPtr pSib = NullWindow;
2187
register WindowPtr pParent = pWin->parent;
2190
register XID *pVlist;
2191
short x, y, beforeX, beforeY;
2192
unsigned short w = pWin->drawable.width,
2193
h = pWin->drawable.height,
2194
bw = pWin->borderWidth;
2195
int action, smode = Above;
2197
ClientPtr win_owner;
2198
ClientPtr ag_leader = NULL;
2202
if ((pWin->drawable.class == InputOnly) && (mask & IllegalInputOnlyConfigureMask))
2205
if ((mask & CWSibling) && !(mask & CWStackMode))
2212
x = pWin->drawable.x - pParent->drawable.x - (int)bw;
2213
y = pWin->drawable.y - pParent->drawable.y - (int)bw;
2217
x = pWin->drawable.x;
2218
y = pWin->drawable.y;
2222
action = RESTACK_WIN;
2223
if ((mask & (CWX | CWY)) && (!(mask & (CWHeight | CWWidth))))
2229
/* or should be resized */
2230
else if (mask & (CWX | CWY | CWWidth | CWHeight))
2234
GET_CARD16(CWWidth, w);
2235
GET_CARD16 (CWHeight, h);
2238
client->errorValue = 0;
2241
action = RESIZE_WIN;
2243
tmask = mask & ~ChangeMask;
2246
index2 = (Mask)lowbit (tmask);
2251
GET_CARD16(CWBorderWidth, bw);
2254
sibwid = (Window ) *pVlist;
2256
pSib = (WindowPtr )SecurityLookupIDByType(client, sibwid,
2257
RT_WINDOW, SecurityReadAccess);
2260
client->errorValue = sibwid;
2263
if (pSib->parent != pParent)
2269
GET_CARD8(CWStackMode, smode);
2270
if ((smode != TopIf) && (smode != BottomIf) &&
2271
(smode != Opposite) && (smode != Above) && (smode != Below))
2273
client->errorValue = smode;
2278
client->errorValue = mask;
2282
/* root really can't be reconfigured, so just return */
2286
/* Figure out if the window should be moved. Doesnt
2287
make the changes to the window if event sent */
2289
if (mask & CWStackMode)
2290
pSib = WhereDoIGoInTheStack(pWin, pSib, pParent->drawable.x + x,
2291
pParent->drawable.y + y,
2292
w + (bw << 1), h + (bw << 1), smode);
2294
pSib = pWin->nextSib;
2297
win_owner = clients[CLIENT_ID(pWin->drawable.id)];
2298
ag_leader = XagLeader (win_owner);
2301
if ((!pWin->overrideRedirect) &&
2302
(RedirectSend(pParent)
2304
|| (win_owner->appgroup && ag_leader &&
2305
XagIsControlledRoot (client, pParent))
2309
event.u.u.type = ConfigureRequest;
2310
event.u.configureRequest.window = pWin->drawable.id;
2311
if (mask & CWSibling)
2312
event.u.configureRequest.sibling = sibwid;
2314
event.u.configureRequest.sibling = None;
2315
if (mask & CWStackMode)
2316
event.u.u.detail = smode;
2318
event.u.u.detail = Above;
2319
event.u.configureRequest.x = x;
2320
event.u.configureRequest.y = y;
2322
if(!noPanoramiXExtension && (!pParent || !pParent->parent)) {
2323
event.u.configureRequest.x += panoramiXdataPtr[0].x;
2324
event.u.configureRequest.y += panoramiXdataPtr[0].y;
2327
event.u.configureRequest.width = w;
2328
event.u.configureRequest.height = h;
2329
event.u.configureRequest.borderWidth = bw;
2330
event.u.configureRequest.valueMask = mask;
2332
/* make sure if the ag_leader maps the window it goes to the wm */
2333
if (ag_leader && ag_leader != client &&
2334
XagIsControlledRoot (client, pParent)) {
2335
event.u.configureRequest.parent = XagId (win_owner);
2336
(void) TryClientEvents (ag_leader, &event, 1,
2337
NoEventMask, NoEventMask, NullGrab);
2341
event.u.configureRequest.parent = pParent->drawable.id;
2342
if (MaybeDeliverEventsToClient(pParent, &event, 1,
2343
SubstructureRedirectMask, client) == 1)
2346
if (action == RESIZE_WIN)
2348
Bool size_change = (w != pWin->drawable.width)
2349
|| (h != pWin->drawable.height);
2350
if (size_change && ((pWin->eventMask|wOtherEventMasks(pWin)) & ResizeRedirectMask))
2353
eventT.u.u.type = ResizeRequest;
2354
eventT.u.resizeRequest.window = pWin->drawable.id;
2355
eventT.u.resizeRequest.width = w;
2356
eventT.u.resizeRequest.height = h;
2357
if (MaybeDeliverEventsToClient(pWin, &eventT, 1,
2358
ResizeRedirectMask, client) == 1)
2360
/* if event is delivered, leave the actual size alone. */
2361
w = pWin->drawable.width;
2362
h = pWin->drawable.height;
2363
size_change = FALSE;
2368
if (mask & (CWX | CWY))
2370
else if (mask & (CWStackMode | CWBorderWidth))
2371
action = RESTACK_WIN;
2372
else /* really nothing to do */
2377
if (action == RESIZE_WIN)
2378
/* we've already checked whether there's really a size change */
2379
goto ActuallyDoSomething;
2380
if ((mask & CWX) && (x != beforeX))
2381
goto ActuallyDoSomething;
2382
if ((mask & CWY) && (y != beforeY))
2383
goto ActuallyDoSomething;
2384
if ((mask & CWBorderWidth) && (bw != wBorderWidth (pWin)))
2385
goto ActuallyDoSomething;
2386
if (mask & CWStackMode)
2389
/* See above for why we always reorder in rootless mode. */
2390
if (pWin->nextSib != pSib)
2392
goto ActuallyDoSomething;
2396
ActuallyDoSomething:
2397
if (SubStrSend(pWin, pParent))
2399
event.u.u.type = ConfigureNotify;
2400
event.u.configureNotify.window = pWin->drawable.id;
2402
event.u.configureNotify.aboveSibling = pSib->drawable.id;
2404
event.u.configureNotify.aboveSibling = None;
2405
event.u.configureNotify.x = x;
2406
event.u.configureNotify.y = y;
2408
if(!noPanoramiXExtension && (!pParent || !pParent->parent)) {
2409
event.u.configureNotify.x += panoramiXdataPtr[0].x;
2410
event.u.configureNotify.y += panoramiXdataPtr[0].y;
2413
event.u.configureNotify.width = w;
2414
event.u.configureNotify.height = h;
2415
event.u.configureNotify.borderWidth = bw;
2416
event.u.configureNotify.override = pWin->overrideRedirect;
2417
DeliverEvents(pWin, &event, 1, NullWindow);
2419
if (mask & CWBorderWidth)
2421
if (action == RESTACK_WIN)
2424
pWin->borderWidth = bw;
2426
else if ((action == MOVE_WIN) &&
2427
(beforeX + wBorderWidth (pWin) == x + (int)bw) &&
2428
(beforeY + wBorderWidth (pWin) == y + (int)bw))
2430
action = REBORDER_WIN;
2431
(*pWin->drawable.pScreen->ChangeBorderWidth)(pWin, bw);
2434
pWin->borderWidth = bw;
2436
if (action == MOVE_WIN)
2437
(*pWin->drawable.pScreen->MoveWindow)(pWin, x, y, pSib,
2438
(mask & CWBorderWidth) ? VTOther : VTMove);
2439
else if (action == RESIZE_WIN)
2440
(*pWin->drawable.pScreen->ResizeWindow)(pWin, x, y, w, h, pSib);
2441
else if (mask & CWStackMode)
2442
ReflectStackChange(pWin, pSib, VTOther);
2444
if (action != RESTACK_WIN)
2445
CheckCursorConfinement(pWin);
2457
* For RaiseLowest, raises the lowest mapped child (if any) that is
2458
* obscured by another child to the top of the stack. For LowerHighest,
2459
* lowers the highest mapped child (if any) that is obscuring another
2460
* child to the bottom of the stack. Exposure processing is performed
2465
CirculateWindow(WindowPtr pParent, int direction, ClientPtr client)
2467
register WindowPtr pWin, pHead, pFirst;
2471
pHead = RealChildHead(pParent);
2472
pFirst = pHead ? pHead->nextSib : pParent->firstChild;
2473
if (direction == RaiseLowest)
2475
for (pWin = pParent->lastChild;
2478
AnyWindowOverlapsMe(pWin, pHead, WindowExtents(pWin, &box)));
2479
pWin = pWin->prevSib) ;
2488
IOverlapAnyWindow(pWin, WindowExtents(pWin, &box)));
2489
pWin = pWin->nextSib) ;
2494
event.u.circulate.window = pWin->drawable.id;
2495
event.u.circulate.parent = pParent->drawable.id;
2496
event.u.circulate.event = pParent->drawable.id;
2497
if (direction == RaiseLowest)
2498
event.u.circulate.place = PlaceOnTop;
2500
event.u.circulate.place = PlaceOnBottom;
2502
if (RedirectSend(pParent))
2504
event.u.u.type = CirculateRequest;
2505
if (MaybeDeliverEventsToClient(pParent, &event, 1,
2506
SubstructureRedirectMask, client) == 1)
2510
event.u.u.type = CirculateNotify;
2511
DeliverEvents(pWin, &event, 1, NullWindow);
2512
ReflectStackChange(pWin,
2513
(direction == RaiseLowest) ? pFirst : NullWindow,
2522
pointer value) /* must conform to VisitWindowProcPtr */
2524
Window *wid = (Window *)value;
2526
if (pWin->drawable.id == *wid)
2527
return(WT_STOPWALKING);
2529
return(WT_WALKCHILDREN);
2537
ReparentWindow(register WindowPtr pWin, register WindowPtr pParent,
2538
int x, int y, ClientPtr client)
2540
WindowPtr pPrev, pPriorParent;
2541
Bool WasMapped = (Bool)(pWin->mapped);
2543
int bw = wBorderWidth (pWin);
2544
register ScreenPtr pScreen;
2546
pScreen = pWin->drawable.pScreen;
2547
if (TraverseTree(pWin, CompareWIDs, (pointer)&pParent->drawable.id) == WT_STOPWALKING)
2549
if (!MakeWindowOptional(pWin))
2553
UnmapWindow(pWin, FALSE);
2555
event.u.u.type = ReparentNotify;
2556
event.u.reparent.window = pWin->drawable.id;
2557
event.u.reparent.parent = pParent->drawable.id;
2558
event.u.reparent.x = x;
2559
event.u.reparent.y = y;
2561
if(!noPanoramiXExtension && !pParent->parent) {
2562
event.u.reparent.x += panoramiXdataPtr[0].x;
2563
event.u.reparent.y += panoramiXdataPtr[0].y;
2566
event.u.reparent.override = pWin->overrideRedirect;
2567
DeliverEvents(pWin, &event, 1, pParent);
2569
/* take out of sibling chain */
2571
pPriorParent = pPrev = pWin->parent;
2572
if (pPrev->firstChild == pWin)
2573
pPrev->firstChild = pWin->nextSib;
2574
if (pPrev->lastChild == pWin)
2575
pPrev->lastChild = pWin->prevSib;
2578
pWin->nextSib->prevSib = pWin->prevSib;
2580
pWin->prevSib->nextSib = pWin->nextSib;
2582
/* insert at begining of pParent */
2583
pWin->parent = pParent;
2584
pPrev = RealChildHead(pParent);
2587
pWin->nextSib = pPrev->nextSib;
2589
pPrev->nextSib->prevSib = pWin;
2591
pParent->lastChild = pWin;
2592
pPrev->nextSib = pWin;
2593
pWin->prevSib = pPrev;
2597
pWin->nextSib = pParent->firstChild;
2598
pWin->prevSib = NullWindow;
2599
if (pParent->firstChild)
2600
pParent->firstChild->prevSib = pWin;
2602
pParent->lastChild = pWin;
2603
pParent->firstChild = pWin;
2606
pWin->origin.x = x + bw;
2607
pWin->origin.y = y + bw;
2608
pWin->drawable.x = x + bw + pParent->drawable.x;
2609
pWin->drawable.y = y + bw + pParent->drawable.y;
2611
/* clip to parent */
2613
SetBorderSize (pWin);
2615
if (pScreen->ReparentWindow)
2616
(*pScreen->ReparentWindow)(pWin, pPriorParent);
2617
(*pScreen->PositionWindow)(pWin, pWin->drawable.x, pWin->drawable.y);
2618
ResizeChildrenWinSize(pWin, 0, 0, 0, 0);
2620
CheckWindowOptionalNeed(pWin);
2623
MapWindow(pWin, client);
2624
RecalculateDeliverableEvents(pWin);
2629
RealizeTree(WindowPtr pWin)
2631
register WindowPtr pChild;
2632
RealizeWindowProcPtr Realize;
2634
Realize = pWin->drawable.pScreen->RealizeWindow;
2640
pChild->realized = TRUE;
2641
#ifdef DO_SAVE_UNDERS
2642
if (pChild->saveUnder)
2643
deltaSaveUndersViewable++;
2645
pChild->viewable = (pChild->drawable.class == InputOutput);
2646
(* Realize)(pChild);
2647
if (pChild->firstChild)
2649
pChild = pChild->firstChild;
2653
while (!pChild->nextSib && (pChild != pWin))
2654
pChild = pChild->parent;
2657
pChild = pChild->nextSib;
2663
* If some other client has selected SubStructureReDirect on the parent
2664
* and override-redirect is xFalse, then a MapRequest event is generated,
2665
* but the window remains unmapped. Otherwise, the window is mapped and a
2666
* MapNotify event is generated.
2670
MapWindow(register WindowPtr pWin, ClientPtr client)
2672
register ScreenPtr pScreen;
2674
register WindowPtr pParent;
2675
#ifdef DO_SAVE_UNDERS
2676
Bool dosave = FALSE;
2678
WindowPtr pLayerWin;
2684
/* don't let an untrusted client map a child-of-trusted-window, InputOnly
2685
* window; too easy to steal device input
2687
if ( (client->trustLevel != XSecurityClientTrusted) &&
2688
(pWin->drawable.class == InputOnly) &&
2689
(wClient(pWin->parent)->trustLevel == XSecurityClientTrusted) )
2693
pScreen = pWin->drawable.pScreen;
2694
if ( (pParent = pWin->parent) )
2699
ClientPtr win_owner = clients[CLIENT_ID(pWin->drawable.id)];
2700
ClientPtr ag_leader = XagLeader (win_owner);
2703
if ((!pWin->overrideRedirect) &&
2704
(RedirectSend(pParent)
2706
|| (win_owner->appgroup && ag_leader &&
2707
XagIsControlledRoot (client, pParent))
2711
event.u.u.type = MapRequest;
2712
event.u.mapRequest.window = pWin->drawable.id;
2714
/* make sure if the ag_leader maps the window it goes to the wm */
2715
if (ag_leader && ag_leader != client &&
2716
XagIsControlledRoot (client, pParent)) {
2717
event.u.mapRequest.parent = XagId (win_owner);
2718
(void) TryClientEvents (ag_leader, &event, 1,
2719
NoEventMask, NoEventMask, NullGrab);
2723
event.u.mapRequest.parent = pParent->drawable.id;
2725
if (MaybeDeliverEventsToClient(pParent, &event, 1,
2726
SubstructureRedirectMask, client) == 1)
2730
pWin->mapped = TRUE;
2731
if (SubStrSend(pWin, pParent) && MapUnmapEventsEnabled(pWin))
2733
event.u.u.type = MapNotify;
2734
event.u.mapNotify.window = pWin->drawable.id;
2735
event.u.mapNotify.override = pWin->overrideRedirect;
2736
DeliverEvents(pWin, &event, 1, NullWindow);
2739
if (!pParent->realized)
2744
anyMarked = (*pScreen->MarkOverlappedWindows)(pWin, pWin,
2746
#ifdef DO_SAVE_UNDERS
2747
if (DO_SAVE_UNDERS(pWin))
2749
dosave = (*pScreen->ChangeSaveUnder)(pLayerWin, pWin->nextSib);
2751
#endif /* DO_SAVE_UNDERS */
2754
(*pScreen->ValidateTree)(pLayerWin->parent, pLayerWin, VTMap);
2755
(*pScreen->HandleExposures)(pLayerWin->parent);
2757
#ifdef DO_SAVE_UNDERS
2759
(*pScreen->PostChangeSaveUnder)(pLayerWin, pWin->nextSib);
2760
#endif /* DO_SAVE_UNDERS */
2761
if (anyMarked && pScreen->PostValidateTree)
2762
(*pScreen->PostValidateTree)(pLayerWin->parent, pLayerWin, VTMap);
2764
WindowsRestructured ();
2770
pWin->mapped = TRUE;
2771
pWin->realized = TRUE; /* for roots */
2772
pWin->viewable = pWin->drawable.class == InputOutput;
2773
/* We SHOULD check for an error value here XXX */
2774
(*pScreen->RealizeWindow)(pWin);
2775
if (pScreen->ClipNotify)
2776
(*pScreen->ClipNotify) (pWin, 0, 0);
2777
if (pScreen->PostValidateTree)
2778
(*pScreen->PostValidateTree)(NullWindow, pWin, VTMap);
2779
REGION_NULL(pScreen, &temp);
2780
REGION_COPY(pScreen, &temp, &pWin->clipList);
2781
(*pScreen->WindowExposures) (pWin, &temp, NullRegion);
2782
REGION_UNINIT(pScreen, &temp);
2791
* Performs a MapWindow all unmapped children of the window, in top
2792
* to bottom stacking order.
2796
MapSubwindows(register WindowPtr pParent, ClientPtr client)
2798
register WindowPtr pWin;
2799
WindowPtr pFirstMapped = NullWindow;
2800
#ifdef DO_SAVE_UNDERS
2801
WindowPtr pFirstSaveUndered = NullWindow;
2803
register ScreenPtr pScreen;
2804
register Mask parentRedirect;
2805
register Mask parentNotify;
2808
#ifdef DO_SAVE_UNDERS
2809
Bool dosave = FALSE;
2811
WindowPtr pLayerWin;
2813
pScreen = pParent->drawable.pScreen;
2814
parentRedirect = RedirectSend(pParent);
2815
parentNotify = SubSend(pParent);
2817
for (pWin = pParent->firstChild; pWin; pWin = pWin->nextSib)
2821
if (parentRedirect && !pWin->overrideRedirect)
2823
event.u.u.type = MapRequest;
2824
event.u.mapRequest.window = pWin->drawable.id;
2825
event.u.mapRequest.parent = pParent->drawable.id;
2827
if (MaybeDeliverEventsToClient(pParent, &event, 1,
2828
SubstructureRedirectMask, client) == 1)
2832
pWin->mapped = TRUE;
2833
if (parentNotify || StrSend(pWin))
2835
event.u.u.type = MapNotify;
2836
event.u.mapNotify.window = pWin->drawable.id;
2837
event.u.mapNotify.override = pWin->overrideRedirect;
2838
DeliverEvents(pWin, &event, 1, NullWindow);
2842
pFirstMapped = pWin;
2843
if (pParent->realized)
2848
anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pWin,
2850
#ifdef DO_SAVE_UNDERS
2851
if (DO_SAVE_UNDERS(pWin))
2855
#endif /* DO_SAVE_UNDERS */
2863
pLayerWin = (*pScreen->GetLayerWindow)(pParent);
2864
if (pLayerWin->parent != pParent) {
2865
anyMarked |= (*pScreen->MarkOverlappedWindows)(pLayerWin,
2868
pFirstMapped = pLayerWin;
2872
#ifdef DO_SAVE_UNDERS
2873
if (pLayerWin->parent != pParent)
2875
if (dosave || (DO_SAVE_UNDERS(pLayerWin)))
2877
dosave = (*pScreen->ChangeSaveUnder)(pLayerWin,
2884
for (pWin = pParent->firstChild; pWin; pWin = pWin->nextSib)
2886
if (DO_SAVE_UNDERS(pWin))
2888
dosave |= (*pScreen->ChangeSaveUnder)(pWin,
2890
if (dosave && !pFirstSaveUndered)
2891
pFirstSaveUndered = pWin;
2895
#endif /* DO_SAVE_UNDERS */
2896
(*pScreen->ValidateTree)(pLayerWin->parent, pFirstMapped, VTMap);
2897
(*pScreen->HandleExposures)(pLayerWin->parent);
2899
#ifdef DO_SAVE_UNDERS
2901
(*pScreen->PostChangeSaveUnder)(pLayerWin,
2902
pFirstSaveUndered->nextSib);
2903
#endif /* DO_SAVE_UNDERS */
2904
if (anyMarked && pScreen->PostValidateTree)
2905
(*pScreen->PostValidateTree)(pLayerWin->parent, pFirstMapped,
2907
WindowsRestructured ();
2916
register WindowPtr pChild;
2917
UnrealizeWindowProcPtr Unrealize;
2918
MarkUnrealizedWindowProcPtr MarkUnrealizedWindow;
2920
Unrealize = pWin->drawable.pScreen->UnrealizeWindow;
2921
MarkUnrealizedWindow = pWin->drawable.pScreen->MarkUnrealizedWindow;
2925
if (pChild->realized)
2927
pChild->realized = FALSE;
2928
pChild->visibility = VisibilityNotViewable;
2930
if(!noPanoramiXExtension && !pChild->drawable.pScreen->myNum) {
2932
win = (PanoramiXRes*)LookupIDByType(pChild->drawable.id,
2935
win->u.win.visibility = VisibilityNotViewable;
2938
(* Unrealize)(pChild);
2939
DeleteWindowFromAnyEvents(pChild, FALSE);
2940
if (pChild->viewable)
2942
#ifdef DO_SAVE_UNDERS
2943
if (pChild->saveUnder)
2944
deltaSaveUndersViewable--;
2946
pChild->viewable = FALSE;
2947
if (pChild->backStorage)
2948
(*pChild->drawable.pScreen->SaveDoomedAreas)(
2949
pChild, &pChild->clipList, 0, 0);
2950
(* MarkUnrealizedWindow)(pChild, pWin, fromConfigure);
2951
pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;
2953
if (pChild->firstChild)
2955
pChild = pChild->firstChild;
2959
while (!pChild->nextSib && (pChild != pWin))
2960
pChild = pChild->parent;
2963
pChild = pChild->nextSib;
2969
* If the window is already unmapped, this request has no effect.
2970
* Otherwise, the window is unmapped and an UnMapNotify event is
2971
* generated. Cannot unmap a root window.
2975
UnmapWindow(register WindowPtr pWin, Bool fromConfigure)
2977
register WindowPtr pParent;
2979
Bool wasRealized = (Bool)pWin->realized;
2980
Bool wasViewable = (Bool)pWin->viewable;
2981
ScreenPtr pScreen = pWin->drawable.pScreen;
2982
WindowPtr pLayerWin = pWin;
2984
if ((!pWin->mapped) || (!(pParent = pWin->parent)))
2986
if (SubStrSend(pWin, pParent) && MapUnmapEventsEnabled(pWin))
2988
event.u.u.type = UnmapNotify;
2989
event.u.unmapNotify.window = pWin->drawable.id;
2990
event.u.unmapNotify.fromConfigure = fromConfigure;
2991
DeliverEvents(pWin, &event, 1, NullWindow);
2993
if (wasViewable && !fromConfigure)
2995
pWin->valdata = UnmapValData;
2996
(*pScreen->MarkOverlappedWindows)(pWin, pWin->nextSib, &pLayerWin);
2997
(*pScreen->MarkWindow)(pLayerWin->parent);
2999
pWin->mapped = FALSE;
3001
UnrealizeTree(pWin, fromConfigure);
3006
(*pScreen->ValidateTree)(pLayerWin->parent, pWin, VTUnmap);
3007
(*pScreen->HandleExposures)(pLayerWin->parent);
3009
#ifdef DO_SAVE_UNDERS
3010
if (DO_SAVE_UNDERS(pWin))
3012
if ( (*pScreen->ChangeSaveUnder)(pLayerWin, pWin->nextSib) )
3014
(*pScreen->PostChangeSaveUnder)(pLayerWin, pWin->nextSib);
3017
pWin->DIXsaveUnder = FALSE;
3018
#endif /* DO_SAVE_UNDERS */
3019
if (!fromConfigure && pScreen->PostValidateTree)
3020
(*pScreen->PostValidateTree)(pLayerWin->parent, pWin, VTUnmap);
3022
if (wasRealized && !fromConfigure)
3023
WindowsRestructured ();
3029
* Performs an UnmapWindow request with the specified mode on all mapped
3030
* children of the window, in bottom to top stacking order.
3034
UnmapSubwindows(register WindowPtr pWin)
3036
register WindowPtr pChild, pHead;
3038
Bool wasRealized = (Bool)pWin->realized;
3039
Bool wasViewable = (Bool)pWin->viewable;
3040
Bool anyMarked = FALSE;
3042
WindowPtr pLayerWin = NULL;
3043
ScreenPtr pScreen = pWin->drawable.pScreen;
3045
if (!pWin->firstChild)
3047
parentNotify = SubSend(pWin);
3048
pHead = RealChildHead(pWin);
3051
pLayerWin = (*pScreen->GetLayerWindow)(pWin);
3053
for (pChild = pWin->lastChild; pChild != pHead; pChild = pChild->prevSib)
3057
if (parentNotify || StrSend(pChild))
3059
event.u.u.type = UnmapNotify;
3060
event.u.unmapNotify.window = pChild->drawable.id;
3061
event.u.unmapNotify.fromConfigure = xFalse;
3062
DeliverEvents(pChild, &event, 1, NullWindow);
3064
if (pChild->viewable)
3066
pChild->valdata = UnmapValData;
3069
pChild->mapped = FALSE;
3070
if (pChild->realized)
3071
UnrealizeTree(pChild, FALSE);
3074
#ifdef DO_SAVE_UNDERS
3075
pChild->DIXsaveUnder = FALSE;
3076
#endif /* DO_SAVE_UNDERS */
3077
if (pChild->backStorage)
3078
(*pScreen->SaveDoomedAreas)(
3079
pChild, &pChild->clipList, 0, 0);
3087
if (pLayerWin->parent == pWin)
3088
(*pScreen->MarkWindow)(pWin);
3092
(*pScreen->MarkOverlappedWindows)(pWin, pLayerWin,
3094
(*pScreen->MarkWindow)(pLayerWin->parent);
3096
/* Windows between pWin and pLayerWin may not have been marked */
3099
while (ptmp != pLayerWin->parent)
3101
(*pScreen->MarkWindow)(ptmp);
3102
ptmp = ptmp->parent;
3104
pHead = pWin->firstChild;
3106
(*pScreen->ValidateTree)(pLayerWin->parent, pHead, VTUnmap);
3107
(*pScreen->HandleExposures)(pLayerWin->parent);
3109
#ifdef DO_SAVE_UNDERS
3110
if (DO_SAVE_UNDERS(pWin))
3112
if ( (*pScreen->ChangeSaveUnder)(pLayerWin, pLayerWin))
3113
(*pScreen->PostChangeSaveUnder)(pLayerWin, pLayerWin);
3115
#endif /* DO_SAVE_UNDERS */
3116
if (anyMarked && pScreen->PostValidateTree)
3117
(*pScreen->PostValidateTree)(pLayerWin->parent, pHead, VTUnmap);
3120
WindowsRestructured ();
3125
HandleSaveSet(register ClientPtr client)
3127
register WindowPtr pParent, pWin;
3130
for (j=0; j<client->numSaved; j++)
3132
pWin = SaveSetWindow(client->saveSet[j]);
3134
if (SaveSetToRoot(client->saveSet[j]))
3135
pParent = WindowTable[pWin->drawable.pScreen->myNum];
3139
pParent = pWin->parent;
3140
while (pParent && (wClient (pParent) == client))
3141
pParent = pParent->parent;
3145
if (pParent != pWin->parent)
3147
ReparentWindow(pWin, pParent,
3148
pWin->drawable.x - wBorderWidth (pWin) - pParent->drawable.x,
3149
pWin->drawable.y - wBorderWidth (pWin) - pParent->drawable.y,
3151
if(!pWin->realized && pWin->mapped)
3152
pWin->mapped = FALSE;
3155
if (SaveSetRemap (client->saveSet[j]))
3157
MapWindow(pWin, client);
3160
xfree(client->saveSet);
3161
client->numSaved = 0;
3162
client->saveSet = (SaveSetElt *)NULL;
3167
* \param x,y in root
3168
* \param box "return" value
3171
VisibleBoundingBoxFromPoint(register WindowPtr pWin, int x, int y, BoxPtr box)
3173
if (!pWin->realized)
3175
if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->clipList, x, y, box))
3182
* \param x,y in root
3185
PointInWindowIsVisible(register WindowPtr pWin, int x, int y)
3189
if (!pWin->realized)
3191
if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->borderClip,
3193
&& (!wInputShape(pWin) ||
3194
POINT_IN_REGION(pWin->drawable.pScreen,
3196
x - pWin->drawable.x,
3197
y - pWin->drawable.y, &box)))
3204
NotClippedByChildren(register WindowPtr pWin)
3206
register ScreenPtr pScreen;
3209
pScreen = pWin->drawable.pScreen;
3210
pReg = REGION_CREATE(pScreen, NullBox, 1);
3212
screenIsSaved != SCREEN_SAVER_ON ||
3213
!HasSaverWindow (pWin->drawable.pScreen->myNum))
3215
REGION_INTERSECT(pScreen, pReg, &pWin->borderClip, &pWin->winSize);
3221
SendVisibilityNotify(WindowPtr pWin)
3224
#ifndef NO_XINERAMA_PORT
3225
unsigned int visibility = pWin->visibility;
3228
/* This is not quite correct yet, but it's close */
3229
if(!noPanoramiXExtension) {
3234
Scrnum = pWin->drawable.pScreen->myNum;
3236
win = PanoramiXFindIDByScrnum(XRT_WINDOW, pWin->drawable.id, Scrnum);
3238
if(!win || (win->u.win.visibility == visibility))
3241
switch(visibility) {
3242
case VisibilityUnobscured:
3243
for(i = 0; i < PanoramiXNumScreens; i++) {
3244
if(i == Scrnum) continue;
3246
pWin2 = (WindowPtr)LookupIDByType(win->info[i].id, RT_WINDOW);
3249
if(pWin2->visibility == VisibilityPartiallyObscured)
3252
if(!i) pWin = pWin2;
3256
case VisibilityPartiallyObscured:
3258
pWin2 = (WindowPtr)LookupIDByType(win->info[0].id, RT_WINDOW);
3259
if (pWin2) pWin = pWin2;
3262
case VisibilityFullyObscured:
3263
for(i = 0; i < PanoramiXNumScreens; i++) {
3264
if(i == Scrnum) continue;
3266
pWin2 = (WindowPtr)LookupIDByType(win->info[i].id, RT_WINDOW);
3269
if(pWin2->visibility != VisibilityFullyObscured)
3272
if(!i) pWin = pWin2;
3278
win->u.win.visibility = visibility;
3282
event.u.u.type = VisibilityNotify;
3283
event.u.visibility.window = pWin->drawable.id;
3284
event.u.visibility.state = visibility;
3285
DeliverEvents(pWin, &event, 1, NullWindow);
3288
static WindowPtr windowDisableMapUnmapEvents;
3291
DisableMapUnmapEvents(WindowPtr pWin)
3293
assert (windowDisableMapUnmapEvents == NULL);
3295
windowDisableMapUnmapEvents = pWin;
3299
EnableMapUnmapEvents(WindowPtr pWin)
3301
assert (windowDisableMapUnmapEvents != NULL);
3303
windowDisableMapUnmapEvents = NULL;
3307
MapUnmapEventsEnabled(WindowPtr pWin)
3309
return pWin != windowDisableMapUnmapEvents;
3312
#define RANDOM_WIDTH 32
3315
static void DrawLogo(
3321
SaveScreens(int on, int mode)
3327
if (on == SCREEN_SAVER_FORCER)
3329
UpdateCurrentTimeIf();
3330
lastDeviceEventTime = currentTime;
3331
if (mode == ScreenSaverReset)
3332
what = SCREEN_SAVER_OFF;
3334
what = SCREEN_SAVER_ON;
3341
if (what == screenIsSaved)
3342
type = SCREEN_SAVER_CYCLE;
3344
for (i = 0; i < screenInfo.numScreens; i++)
3346
if (on == SCREEN_SAVER_FORCER)
3347
(* screenInfo.screens[i]->SaveScreen) (screenInfo.screens[i], on);
3348
if (savedScreenInfo[i].ExternalScreenSaver)
3350
if ((*savedScreenInfo[i].ExternalScreenSaver)
3351
(screenInfo.screens[i], type, on == SCREEN_SAVER_FORCER))
3354
if (type == screenIsSaved)
3357
case SCREEN_SAVER_OFF:
3358
if (savedScreenInfo[i].blanked == SCREEN_IS_BLANKED)
3360
(* screenInfo.screens[i]->SaveScreen) (screenInfo.screens[i],
3363
else if (HasSaverWindow (i))
3365
savedScreenInfo[i].pWindow = NullWindow;
3366
FreeResource(savedScreenInfo[i].wid, RT_NONE);
3369
case SCREEN_SAVER_CYCLE:
3370
if (savedScreenInfo[i].blanked == SCREEN_IS_TILED)
3372
WindowPtr pWin = savedScreenInfo[i].pWindow;
3373
/* make it look like screen saver is off, so that
3374
* NotClippedByChildren will compute a clip list
3375
* for the root window, so miPaintWindow works
3377
screenIsSaved = SCREEN_SAVER_OFF;
3379
if (logoScreenSaver)
3380
(*pWin->drawable.pScreen->ClearToBackground)(pWin, 0, 0, 0, 0, FALSE);
3382
(*pWin->drawable.pScreen->MoveWindow)(pWin,
3383
(short)(-(rand() % RANDOM_WIDTH)),
3384
(short)(-(rand() % RANDOM_WIDTH)),
3385
pWin->nextSib, VTMove);
3387
if (logoScreenSaver)
3390
screenIsSaved = SCREEN_SAVER_ON;
3393
* Call the DDX saver in case it wants to do something
3396
else if (savedScreenInfo[i].blanked == SCREEN_IS_BLANKED)
3398
(* screenInfo.screens[i]->SaveScreen) (screenInfo.screens[i],
3402
case SCREEN_SAVER_ON:
3403
if (ScreenSaverBlanking != DontPreferBlanking)
3405
if ((* screenInfo.screens[i]->SaveScreen)
3406
(screenInfo.screens[i], what))
3408
savedScreenInfo[i].blanked = SCREEN_IS_BLANKED;
3411
if ((ScreenSaverAllowExposures != DontAllowExposures) &&
3412
TileScreenSaver(i, SCREEN_IS_BLACK))
3414
savedScreenInfo[i].blanked = SCREEN_IS_BLACK;
3418
if ((ScreenSaverAllowExposures != DontAllowExposures) &&
3419
TileScreenSaver(i, SCREEN_IS_TILED))
3421
savedScreenInfo[i].blanked = SCREEN_IS_TILED;
3424
savedScreenInfo[i].blanked = SCREEN_ISNT_SAVED;
3428
screenIsSaved = what;
3429
if (mode == ScreenSaverReset)
3430
SetScreenSaverTimer();
3434
TileScreenSaver(int i, int kind)
3442
unsigned char *srcbits, *mskbits;
3450
case SCREEN_IS_TILED:
3451
switch (WindowTable[i]->backgroundState) {
3452
case BackgroundPixel:
3453
attributes[attri++] = WindowTable[i]->background.pixel;
3454
mask |= CWBackPixel;
3456
case BackgroundPixmap:
3457
attributes[attri++] = None;
3458
mask |= CWBackPixmap;
3464
case SCREEN_IS_BLACK:
3465
attributes[attri++] = WindowTable[i]->drawable.pScreen->blackPixel;
3466
mask |= CWBackPixel;
3469
mask |= CWOverrideRedirect;
3470
attributes[attri++] = xTrue;
3473
* create a blank cursor
3480
srcbits = (unsigned char *)xalloc( BitmapBytePad(32)*16);
3481
mskbits = (unsigned char *)xalloc( BitmapBytePad(32)*16);
3482
if (!srcbits || !mskbits)
3490
for (j=0; j<BitmapBytePad(32)*16; j++)
3491
srcbits[j] = mskbits[j] = 0x0;
3492
cursor = AllocCursor(srcbits, mskbits, &cm, 0, 0, 0, 0, 0, 0);
3495
cursorID = FakeClientID(0);
3496
if (AddResource (cursorID, RT_CURSOR, (pointer) cursor))
3498
attributes[attri] = cursorID;
3511
pWin = savedScreenInfo[i].pWindow =
3512
CreateWindow(savedScreenInfo[i].wid,
3514
-RANDOM_WIDTH, -RANDOM_WIDTH,
3515
(unsigned short)screenInfo.screens[i]->width + RANDOM_WIDTH,
3516
(unsigned short)screenInfo.screens[i]->height + RANDOM_WIDTH,
3517
0, InputOutput, mask, attributes, 0, serverClient,
3518
wVisual (WindowTable[i]), &result);
3521
FreeResource (cursorID, RT_NONE);
3526
if (!AddResource(pWin->drawable.id, RT_WINDOW,
3527
(pointer)savedScreenInfo[i].pWindow))
3530
if (mask & CWBackPixmap)
3532
MakeRootTile (pWin);
3533
(*pWin->drawable.pScreen->ChangeWindowAttributes)(pWin, CWBackPixmap);
3535
MapWindow(pWin, serverClient);
3537
if (kind == SCREEN_IS_TILED && logoScreenSaver)
3544
* FindWindowWithOptional
3546
* search ancestors of the given window for an entry containing
3547
* a WindowOpt structure. Assumptions: some parent will
3548
* contain the structure.
3552
FindWindowWithOptional (register WindowPtr w)
3556
while (!w->optional);
3561
* CheckWindowOptionalNeed
3563
* check each optional entry in the given window to see if
3564
* the value is satisfied by the default rules. If so,
3565
* release the optional record
3569
CheckWindowOptionalNeed (register WindowPtr w)
3571
register WindowOptPtr optional;
3572
register WindowOptPtr parentOptional;
3576
optional = w->optional;
3577
if (optional->dontPropagateMask != DontPropagateMasks[w->dontPropagate])
3579
if (optional->otherEventMasks != 0)
3581
if (optional->otherClients != NULL)
3583
if (optional->passiveGrabs != NULL)
3585
if (optional->userProps != NULL)
3587
if (optional->backingBitPlanes != ~0L)
3589
if (optional->backingPixel != 0)
3592
if (optional->boundingShape != NULL)
3594
if (optional->clipShape != NULL)
3596
if (optional->inputShape != NULL)
3600
if (optional->inputMasks != NULL)
3603
parentOptional = FindWindowWithOptional(w)->optional;
3604
if (optional->visual != parentOptional->visual)
3606
if (optional->cursor != None &&
3607
(optional->cursor != parentOptional->cursor ||
3608
w->parent->cursorIsNone))
3610
if (optional->colormap != parentOptional->colormap)
3612
DisposeWindowOptional (w);
3616
* MakeWindowOptional
3618
* create an optional record and initialize it with the default
3623
MakeWindowOptional (register WindowPtr pWin)
3625
register WindowOptPtr optional;
3626
register WindowOptPtr parentOptional;
3630
optional = (WindowOptPtr) xalloc (sizeof (WindowOptRec));
3633
optional->dontPropagateMask = DontPropagateMasks[pWin->dontPropagate];
3634
optional->otherEventMasks = 0;
3635
optional->otherClients = NULL;
3636
optional->passiveGrabs = NULL;
3637
optional->userProps = NULL;
3638
optional->backingBitPlanes = ~0L;
3639
optional->backingPixel = 0;
3641
optional->boundingShape = NULL;
3642
optional->clipShape = NULL;
3643
optional->inputShape = NULL;
3646
optional->inputMasks = NULL;
3648
parentOptional = FindWindowWithOptional(pWin)->optional;
3649
optional->visual = parentOptional->visual;
3650
if (!pWin->cursorIsNone)
3652
optional->cursor = parentOptional->cursor;
3653
optional->cursor->refcnt++;
3657
optional->cursor = None;
3659
optional->colormap = parentOptional->colormap;
3660
pWin->optional = optional;
3665
DisposeWindowOptional (register WindowPtr pWin)
3667
if (!pWin->optional)
3670
* everything is peachy. Delete the optional record
3674
* TOG changed this code to:
3676
* if (pWin->cursorIsNone == FALSE)
3677
* FreeCursor (pWin->optional->cursor, (Cursor)0);
3678
* pWin->cursorIsNone = TRUE;
3680
* This is blatently wrong; windows without optionals can have
3681
* two different cursor values, either None or sharing their
3682
* parents cursor. This difference is controlled by the
3683
* cursorIsNone value; when TRUE, the window has no cursor,
3684
* when false, it shares its cursor with its parent; TOG
3685
* made it impossible for a window to have a cursor without
3686
* an optional record.
3688
if (pWin->optional->cursor)
3690
FreeCursor (pWin->optional->cursor, (Cursor)0);
3691
pWin->cursorIsNone = FALSE;
3694
pWin->cursorIsNone = TRUE;
3695
xfree (pWin->optional);
3696
pWin->optional = NULL;
3701
DrawLogo(WindowPtr pWin)
3706
unsigned int width, height, size;
3709
DDXPointRec poly[4];
3710
ChangeGCVal fore[2], back[2];
3712
BITS32 fmask, bmask;
3715
pDraw = (DrawablePtr)pWin;
3716
pScreen = pDraw->pScreen;
3717
x = -pWin->origin.x;
3718
y = -pWin->origin.y;
3719
width = pScreen->width;
3720
height = pScreen->height;
3721
pGC = GetScratchGC(pScreen->rootDepth, pScreen);
3725
if ((rand() % 100) <= 17) /* make the probability for white fairly low */
3726
fore[0].val = pScreen->whitePixel;
3728
fore[0].val = pScreen->blackPixel;
3729
if ((pWin->backgroundState == BackgroundPixel) &&
3730
(cmap = (ColormapPtr)LookupIDByType(wColormap (pWin), RT_COLORMAP))) {
3731
Pixel querypixels[2];
3733
querypixels[0] = fore[0].val;
3734
querypixels[1] = pWin->background.pixel;
3735
QueryColors(cmap, 2, querypixels, rgb);
3736
if ((rgb[0].red == rgb[1].red) &&
3737
(rgb[0].green == rgb[1].green) &&
3738
(rgb[0].blue == rgb[1].blue)) {
3739
if (fore[0].val == pScreen->blackPixel)
3740
fore[0].val = pScreen->whitePixel;
3742
fore[0].val = pScreen->blackPixel;
3745
fore[1].val = FillSolid;
3746
fmask = GCForeground|GCFillStyle;
3747
if (pWin->backgroundState == BackgroundPixel) {
3748
back[0].val = pWin->background.pixel;
3749
back[1].val = FillSolid;
3750
bmask = GCForeground|GCFillStyle;
3754
dixChangeGC(NullClient, pGC, GCTileStipXOrigin|GCTileStipYOrigin,
3756
back[0].val = FillTiled;
3757
back[1].ptr = pWin->background.pixmap;
3758
bmask = GCFillStyle|GCTile;
3761
/* should be the same as the reference function XmuDrawLogo() */
3766
size = RANDOM_WIDTH + rand() % (size - RANDOM_WIDTH);
3768
x += rand() % (width - size);
3769
y += rand() % (height - size);
3772
* Draw what will be the thin strokes.
3782
* Point d is 9/44 (~1/5) of the way across.
3786
if (thin < 1) thin = 1;
3788
d31 = thin + thin + gap;
3789
poly[0].x = x + size; poly[0].y = y;
3790
poly[1].x = x + size-d31; poly[1].y = y;
3791
poly[2].x = x + 0; poly[2].y = y + size;
3792
poly[3].x = x + d31; poly[3].y = y + size;
3793
dixChangeGC(NullClient, pGC, fmask, NULL, fore);
3794
ValidateGC(pDraw, pGC);
3795
(*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);
3798
* Erase area not needed for lower thin stroke.
3808
poly[0].x = x + d31/2; poly[0].y = y + size;
3809
poly[1].x = x + size / 2; poly[1].y = y + size/2;
3810
poly[2].x = x + (size/2)+(d31-(d31/2)); poly[2].y = y + size/2;
3811
poly[3].x = x + d31; poly[3].y = y + size;
3812
dixChangeGC(NullClient, pGC, bmask, NULL, back);
3813
ValidateGC(pDraw, pGC);
3814
(*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);
3817
* Erase area not needed for upper thin stroke.
3827
poly[0].x = x + size - d31/2; poly[0].y = y;
3828
poly[1].x = x + size / 2; poly[1].y = y + size/2;
3829
poly[2].x = x + (size/2)-(d31-(d31/2)); poly[2].y = y + size/2;
3830
poly[3].x = x + size - d31; poly[3].y = y;
3831
ValidateGC(pDraw, pGC);
3832
(*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);
3835
* Draw thick stroke.
3836
* Point b is 1/4 of the way across.
3847
poly[0].x = x; poly[0].y = y;
3848
poly[1].x = x + size/4; poly[1].y = y;
3849
poly[2].x = x + size; poly[2].y = y + size;
3850
poly[3].x = x + size - size/4; poly[3].y = y + size;
3851
dixChangeGC(NullClient, pGC, fmask, NULL, fore);
3852
ValidateGC(pDraw, pGC);
3853
(*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);
3856
* Erase to create gap.
3865
poly[0].x = x + size- thin; poly[0].y = y;
3866
poly[1].x = x + size-( thin+gap); poly[1].y = y;
3867
poly[2].x = x + thin; poly[2].y = y + size;
3868
poly[3].x = x + thin + gap; poly[3].y = y + size;
3869
dixChangeGC(NullClient, pGC, bmask, NULL, back);
3870
ValidateGC(pDraw, pGC);
3871
(*pGC->ops->FillPolygon)(pDraw, pGC, Convex, CoordModeOrigin, 4, poly);
added
removed
dix/window.c
