[deb_xorg-server.git] / hw / xnest / Window.c

/*

Copyright 1993 by Davor Matic

Permission to use, copy, modify, distribute, and sell this software
and its documentation for any purpose is hereby granted without fee,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation.  Davor Matic makes no representations about
the suitability of this software for any purpose.  It is provided "as
is" without express or implied warranty.

*/

#ifdef HAVE_XNEST_CONFIG_H
#include <xnest-config.h>
#endif

#include <X11/X.h>
#include <X11/Xproto.h>
#include "gcstruct.h"
#include "window.h"
#include "windowstr.h"
#include "pixmapstr.h"
#include "colormapst.h"
#include "scrnintstr.h"
#include "region.h"

#include "mi.h"

#include "Xnest.h"

#include "Display.h"
#include "Screen.h"
#include "XNGC.h"
#include "Drawable.h"
#include "Color.h"
#include "Visual.h"
#include "Events.h"
#include "Args.h"

DevPrivateKeyRec xnestWindowPrivateKeyRec;

static int
xnestFindWindowMatch(WindowPtr pWin, pointer ptr)
{
    xnestWindowMatch *wm = (xnestWindowMatch *) ptr;

    if (wm->window == xnestWindow(pWin)) {
        wm->pWin = pWin;
        return WT_STOPWALKING;
    }
    else
        return WT_WALKCHILDREN;
}

WindowPtr
xnestWindowPtr(Window window)
{
    xnestWindowMatch wm;
    int i;

    wm.pWin = NullWindow;
    wm.window = window;

    for (i = 0; i < xnestNumScreens; i++) {
        WalkTree(screenInfo.screens[i], xnestFindWindowMatch, (pointer) &wm);
        if (wm.pWin)
            break;
    }

    return wm.pWin;
}

Bool
xnestCreateWindow(WindowPtr pWin)
{
    unsigned long mask;
    XSetWindowAttributes attributes;
    Visual *visual;
    ColormapPtr pCmap;

    if (pWin->drawable.class == InputOnly) {
        mask = 0L;
        visual = CopyFromParent;
    }
    else {
        mask = CWEventMask | CWBackingStore;
        attributes.event_mask = ExposureMask;
        attributes.backing_store = NotUseful;

        if (pWin->parent) {
            if (pWin->optional &&
                pWin->optional->visual != wVisual(pWin->parent)) {
                visual =
                    xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));
                mask |= CWColormap;
                if (pWin->optional->colormap) {
                    dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
                                            RT_COLORMAP, serverClient,
                                            DixUseAccess);
                    attributes.colormap = xnestColormap(pCmap);
                }
                else
                    attributes.colormap = xnestDefaultVisualColormap(visual);
            }
            else
                visual = CopyFromParent;
        }
        else {                  /* root windows have their own colormaps at creation time */
            visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));
            dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
                                    RT_COLORMAP, serverClient, DixUseAccess);
            mask |= CWColormap;
            attributes.colormap = xnestColormap(pCmap);
        }
    }

    xnestWindowPriv(pWin)->window = XCreateWindow(xnestDisplay,
                                                  xnestWindowParent(pWin),
                                                  pWin->origin.x -
                                                  wBorderWidth(pWin),
                                                  pWin->origin.y -
                                                  wBorderWidth(pWin),
                                                  pWin->drawable.width,
                                                  pWin->drawable.height,
                                                  pWin->borderWidth,
                                                  pWin->drawable.depth,
                                                  pWin->drawable.class,
                                                  visual, mask, &attributes);
    xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
    xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
    xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
    xnestWindowPriv(pWin)->width = pWin->drawable.width;
    xnestWindowPriv(pWin)->height = pWin->drawable.height;
    xnestWindowPriv(pWin)->border_width = pWin->borderWidth;
    xnestWindowPriv(pWin)->sibling_above = None;
    if (pWin->nextSib)
        xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
    xnestWindowPriv(pWin)->bounding_shape = RegionCreate(NULL, 1);
    xnestWindowPriv(pWin)->clip_shape = RegionCreate(NULL, 1);

    if (!pWin->parent)          /* only the root window will have the right colormap */
        xnestSetInstalledColormapWindows(pWin->drawable.pScreen);

    return True;
}

Bool
xnestDestroyWindow(WindowPtr pWin)
{
    if (pWin->nextSib)
        xnestWindowPriv(pWin->nextSib)->sibling_above =
            xnestWindowPriv(pWin)->sibling_above;
    RegionDestroy(xnestWindowPriv(pWin)->bounding_shape);
    RegionDestroy(xnestWindowPriv(pWin)->clip_shape);
    XDestroyWindow(xnestDisplay, xnestWindow(pWin));
    xnestWindowPriv(pWin)->window = None;

    if (pWin->optional && pWin->optional->colormap && pWin->parent)
        xnestSetInstalledColormapWindows(pWin->drawable.pScreen);

    return True;
}

Bool
xnestPositionWindow(WindowPtr pWin, int x, int y)
{
    xnestConfigureWindow(pWin,
                         CWParent |
                         CWX | CWY | CWWidth | CWHeight | CWBorderWidth);

    return True;
}

void
xnestConfigureWindow(WindowPtr pWin, unsigned int mask)
{
    unsigned int valuemask;
    XWindowChanges values;

    if (mask & CWParent &&
        xnestWindowPriv(pWin)->parent != xnestWindowParent(pWin)) {
        XReparentWindow(xnestDisplay, xnestWindow(pWin),
                        xnestWindowParent(pWin),
                        pWin->origin.x - wBorderWidth(pWin),
                        pWin->origin.y - wBorderWidth(pWin));
        xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
        xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
        xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
        xnestWindowPriv(pWin)->sibling_above = None;
        if (pWin->nextSib)
            xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
    }

    valuemask = 0;

    if (mask & CWX &&
        xnestWindowPriv(pWin)->x != pWin->origin.x - wBorderWidth(pWin)) {
        valuemask |= CWX;
        values.x =
            xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
    }

    if (mask & CWY &&
        xnestWindowPriv(pWin)->y != pWin->origin.y - wBorderWidth(pWin)) {
        valuemask |= CWY;
        values.y =
            xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
    }

    if (mask & CWWidth && xnestWindowPriv(pWin)->width != pWin->drawable.width) {
        valuemask |= CWWidth;
        values.width = xnestWindowPriv(pWin)->width = pWin->drawable.width;
    }

    if (mask & CWHeight &&
        xnestWindowPriv(pWin)->height != pWin->drawable.height) {
        valuemask |= CWHeight;
        values.height = xnestWindowPriv(pWin)->height = pWin->drawable.height;
    }

    if (mask & CWBorderWidth &&
        xnestWindowPriv(pWin)->border_width != pWin->borderWidth) {
        valuemask |= CWBorderWidth;
        values.border_width =
            xnestWindowPriv(pWin)->border_width = pWin->borderWidth;
    }

    if (valuemask)
        XConfigureWindow(xnestDisplay, xnestWindow(pWin), valuemask, &values);

    if (mask & CWStackingOrder &&
        xnestWindowPriv(pWin)->sibling_above != xnestWindowSiblingAbove(pWin)) {
        WindowPtr pSib;

        /* find the top sibling */
        for (pSib = pWin; pSib->prevSib != NullWindow; pSib = pSib->prevSib);

        /* the top sibling */
        valuemask = CWStackMode;
        values.stack_mode = Above;
        XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values);
        xnestWindowPriv(pSib)->sibling_above = None;

        /* the rest of siblings */
        for (pSib = pSib->nextSib; pSib != NullWindow; pSib = pSib->nextSib) {
            valuemask = CWSibling | CWStackMode;
            values.sibling = xnestWindowSiblingAbove(pSib);
            values.stack_mode = Below;
            XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask,
                             &values);
            xnestWindowPriv(pSib)->sibling_above =
                xnestWindowSiblingAbove(pSib);
        }
    }
}

Bool
xnestChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
{
    XSetWindowAttributes attributes;

    if (mask & CWBackPixmap)
        switch (pWin->backgroundState) {
        case None:
            attributes.background_pixmap = None;
            break;

        case ParentRelative:
            attributes.background_pixmap = ParentRelative;
            break;

        case BackgroundPixmap:
            attributes.background_pixmap = xnestPixmap(pWin->background.pixmap);
            break;

        case BackgroundPixel:
            mask &= ~CWBackPixmap;
            break;
        }

    if (mask & CWBackPixel) {
        if (pWin->backgroundState == BackgroundPixel)
            attributes.background_pixel = xnestPixel(pWin->background.pixel);
        else
            mask &= ~CWBackPixel;
    }

    if (mask & CWBorderPixmap) {
        if (pWin->borderIsPixel)
            mask &= ~CWBorderPixmap;
        else
            attributes.border_pixmap = xnestPixmap(pWin->border.pixmap);
    }

    if (mask & CWBorderPixel) {
        if (pWin->borderIsPixel)
            attributes.border_pixel = xnestPixel(pWin->border.pixel);
        else
            mask &= ~CWBorderPixel;
    }

    if (mask & CWBitGravity)
        attributes.bit_gravity = pWin->bitGravity;

    if (mask & CWWinGravity)    /* dix does this for us */
        mask &= ~CWWinGravity;

    if (mask & CWBackingStore)  /* this is really not useful */
        mask &= ~CWBackingStore;

    if (mask & CWBackingPlanes) /* this is really not useful */
        mask &= ~CWBackingPlanes;

    if (mask & CWBackingPixel)  /* this is really not useful */
        mask &= ~CWBackingPixel;

    if (mask & CWOverrideRedirect)
        attributes.override_redirect = pWin->overrideRedirect;

    if (mask & CWSaveUnder)     /* this is really not useful */
        mask &= ~CWSaveUnder;

    if (mask & CWEventMask)     /* events are handled elsewhere */
        mask &= ~CWEventMask;

    if (mask & CWDontPropagate) /* events are handled elsewhere */
        mask &= ~CWDontPropagate;

    if (mask & CWColormap) {
        ColormapPtr pCmap;

        dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
                                RT_COLORMAP, serverClient, DixUseAccess);

        attributes.colormap = xnestColormap(pCmap);

        xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
    }

    if (mask & CWCursor)        /* this is handeled in cursor code */
        mask &= ~CWCursor;

    if (mask)
        XChangeWindowAttributes(xnestDisplay, xnestWindow(pWin),
                                mask, &attributes);

    return True;
}

Bool
xnestRealizeWindow(WindowPtr pWin)
{
    xnestConfigureWindow(pWin, CWStackingOrder);
    xnestShapeWindow(pWin);
    XMapWindow(xnestDisplay, xnestWindow(pWin));

    return True;
}

Bool
xnestUnrealizeWindow(WindowPtr pWin)
{
    XUnmapWindow(xnestDisplay, xnestWindow(pWin));

    return True;
}

void
xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion)
{
}

void
xnestClipNotify(WindowPtr pWin, int dx, int dy)
{
    xnestConfigureWindow(pWin, CWStackingOrder);
    xnestShapeWindow(pWin);
}

static Bool
xnestWindowExposurePredicate(Display * display, XEvent * event, XPointer ptr)
{
    return (event->type == Expose && event->xexpose.window == *(Window *) ptr);
}

void
xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)
{
    XEvent event;
    Window window;
    BoxRec Box;

    XSync(xnestDisplay, False);

    window = xnestWindow(pWin);

    while (XCheckIfEvent(xnestDisplay, &event,
                         xnestWindowExposurePredicate, (char *) &window)) {

        Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + event.xexpose.x;
        Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + event.xexpose.y;
        Box.x2 = Box.x1 + event.xexpose.width;
        Box.y2 = Box.y1 + event.xexpose.height;

        event.xexpose.type = ProcessedExpose;

        if (RegionContainsRect(pRgn, &Box) != rgnIN)
            XPutBackEvent(xnestDisplay, &event);
    }

    miWindowExposures(pWin, pRgn, other_exposed);
}

void
xnestSetShape(WindowPtr pWin, int kind)
{
    xnestShapeWindow(pWin);
    miSetShape(pWin, kind);
}

static Bool
xnestRegionEqual(RegionPtr pReg1, RegionPtr pReg2)
{
    BoxPtr pBox1, pBox2;
    unsigned int n1, n2;

    if (pReg1 == pReg2)
        return True;

    if (pReg1 == NullRegion || pReg2 == NullRegion)
        return False;

    pBox1 = RegionRects(pReg1);
    n1 = RegionNumRects(pReg1);

    pBox2 = RegionRects(pReg2);
    n2 = RegionNumRects(pReg2);

    if (n1 != n2)
        return False;

    if (pBox1 == pBox2)
        return True;

    if (memcmp(pBox1, pBox2, n1 * sizeof(BoxRec)))
        return False;

    return True;
}

void
xnestShapeWindow(WindowPtr pWin)
{
    Region reg;
    BoxPtr pBox;
    XRectangle rect;
    int i;

    if (!xnestRegionEqual(xnestWindowPriv(pWin)->bounding_shape,
                          wBoundingShape(pWin))) {

        if (wBoundingShape(pWin)) {
            RegionCopy(xnestWindowPriv(pWin)->bounding_shape,
                       wBoundingShape(pWin));

            reg = XCreateRegion();
            pBox = RegionRects(xnestWindowPriv(pWin)->bounding_shape);
            for (i = 0;
                 i < RegionNumRects(xnestWindowPriv(pWin)->bounding_shape);
                 i++) {
                rect.x = pBox[i].x1;
                rect.y = pBox[i].y1;
                rect.width = pBox[i].x2 - pBox[i].x1;
                rect.height = pBox[i].y2 - pBox[i].y1;
                XUnionRectWithRegion(&rect, reg, reg);
            }
            XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
                                ShapeBounding, 0, 0, reg, ShapeSet);
            XDestroyRegion(reg);
        }
        else {
            RegionEmpty(xnestWindowPriv(pWin)->bounding_shape);

            XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
                              ShapeBounding, 0, 0, None, ShapeSet);
        }
    }

    if (!xnestRegionEqual(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin))) {

        if (wClipShape(pWin)) {
            RegionCopy(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin));

            reg = XCreateRegion();
            pBox = RegionRects(xnestWindowPriv(pWin)->clip_shape);
            for (i = 0;
                 i < RegionNumRects(xnestWindowPriv(pWin)->clip_shape); i++) {
                rect.x = pBox[i].x1;
                rect.y = pBox[i].y1;
                rect.width = pBox[i].x2 - pBox[i].x1;
                rect.height = pBox[i].y2 - pBox[i].y1;
                XUnionRectWithRegion(&rect, reg, reg);
            }
            XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
                                ShapeClip, 0, 0, reg, ShapeSet);
            XDestroyRegion(reg);
        }
        else {
            RegionEmpty(xnestWindowPriv(pWin)->clip_shape);

            XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
                              ShapeClip, 0, 0, None, ShapeSet);
        }
    }
}
Commit	Line	Data
a09e091a JB	1	/*
	2
	3	Copyright 1993 by Davor Matic
	4
	5	Permission to use, copy, modify, distribute, and sell this software
	6	and its documentation for any purpose is hereby granted without fee,
	7	provided that the above copyright notice appear in all copies and that
	8	both that copyright notice and this permission notice appear in
	9	supporting documentation. Davor Matic makes no representations about
	10	the suitability of this software for any purpose. It is provided "as
	11	is" without express or implied warranty.
	12
	13	*/
	14
	15	#ifdef HAVE_XNEST_CONFIG_H
	16	#include <xnest-config.h>
	17	#endif
	18
	19	#include <X11/X.h>
	20	#include <X11/Xproto.h>
	21	#include "gcstruct.h"
	22	#include "window.h"
	23	#include "windowstr.h"
	24	#include "pixmapstr.h"
	25	#include "colormapst.h"
	26	#include "scrnintstr.h"
	27	#include "region.h"
	28
	29	#include "mi.h"
	30
	31	#include "Xnest.h"
	32
	33	#include "Display.h"
	34	#include "Screen.h"
	35	#include "XNGC.h"
	36	#include "Drawable.h"
	37	#include "Color.h"
	38	#include "Visual.h"
	39	#include "Events.h"
	40	#include "Args.h"
	41
	42	DevPrivateKeyRec xnestWindowPrivateKeyRec;
	43
	44	static int
	45	xnestFindWindowMatch(WindowPtr pWin, pointer ptr)
	46	{
	47	xnestWindowMatch wm = (xnestWindowMatch ) ptr;
	48
	49	if (wm->window == xnestWindow(pWin)) {
	50	wm->pWin = pWin;
	51	return WT_STOPWALKING;
	52	}
	53	else
	54	return WT_WALKCHILDREN;
	55	}
	56
	57	WindowPtr
	58	xnestWindowPtr(Window window)
	59	{
	60	xnestWindowMatch wm;
	61	int i;
	62
	63	wm.pWin = NullWindow;
	64	wm.window = window;
65
66	for (i = 0; i < xnestNumScreens; i++) {
67	WalkTree(screenInfo.screens[i], xnestFindWindowMatch, (pointer) &wm);
68	if (wm.pWin)
69	break;
70	}
71
72	return wm.pWin;
73	}
74
75	Bool
76	xnestCreateWindow(WindowPtr pWin)
77	{
78	unsigned long mask;
79	XSetWindowAttributes attributes;
80	Visual *visual;
81	ColormapPtr pCmap;
82
83	if (pWin->drawable.class == InputOnly) {
84	mask = 0L;
85	visual = CopyFromParent;
86	}
87	else {
88	mask = CWEventMask \| CWBackingStore;
89	attributes.event_mask = ExposureMask;
90	attributes.backing_store = NotUseful;
91
92	if (pWin->parent) {
93	if (pWin->optional &&
94	pWin->optional->visual != wVisual(pWin->parent)) {
95	visual =
96	xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));
97	mask \|= CWColormap;
98	if (pWin->optional->colormap) {
99	dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
100	RT_COLORMAP, serverClient,
101	DixUseAccess);
102	attributes.colormap = xnestColormap(pCmap);
103	}
104	else
105	attributes.colormap = xnestDefaultVisualColormap(visual);
106	}
107	else
108	visual = CopyFromParent;
109	}
110	else { /* root windows have their own colormaps at creation time */
111	visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));
112	dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
113	RT_COLORMAP, serverClient, DixUseAccess);
114	mask \|= CWColormap;
115	attributes.colormap = xnestColormap(pCmap);
116	}
117	}
118
119	xnestWindowPriv(pWin)->window = XCreateWindow(xnestDisplay,
120	xnestWindowParent(pWin),
121	pWin->origin.x -
122	wBorderWidth(pWin),
123	pWin->origin.y -
124	wBorderWidth(pWin),
125	pWin->drawable.width,
126	pWin->drawable.height,
127	pWin->borderWidth,
128	pWin->drawable.depth,
129	pWin->drawable.class,
130	visual, mask, &attributes);
131	xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
132	xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
133	xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
134	xnestWindowPriv(pWin)->width = pWin->drawable.width;
135	xnestWindowPriv(pWin)->height = pWin->drawable.height;
136	xnestWindowPriv(pWin)->border_width = pWin->borderWidth;
137	xnestWindowPriv(pWin)->sibling_above = None;
138	if (pWin->nextSib)
139	xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
140	xnestWindowPriv(pWin)->bounding_shape = RegionCreate(NULL, 1);
141	xnestWindowPriv(pWin)->clip_shape = RegionCreate(NULL, 1);
142
143	if (!pWin->parent) /* only the root window will have the right colormap */
144	xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
145
146	return True;
147	}
148
149	Bool
150	xnestDestroyWindow(WindowPtr pWin)
151	{
152	if (pWin->nextSib)
153	xnestWindowPriv(pWin->nextSib)->sibling_above =
154	xnestWindowPriv(pWin)->sibling_above;
155	RegionDestroy(xnestWindowPriv(pWin)->bounding_shape);
156	RegionDestroy(xnestWindowPriv(pWin)->clip_shape);
157	XDestroyWindow(xnestDisplay, xnestWindow(pWin));
158	xnestWindowPriv(pWin)->window = None;
159
160	if (pWin->optional && pWin->optional->colormap && pWin->parent)
161	xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
162
163	return True;
164	}
165
166	Bool
167	xnestPositionWindow(WindowPtr pWin, int x, int y)
168	{
169	xnestConfigureWindow(pWin,
170	CWParent \|
171	CWX \| CWY \| CWWidth \| CWHeight \| CWBorderWidth);
172
173	return True;
174	}
175
176	void
177	xnestConfigureWindow(WindowPtr pWin, unsigned int mask)
178	{
179	unsigned int valuemask;
180	XWindowChanges values;
181
182	if (mask & CWParent &&
183	xnestWindowPriv(pWin)->parent != xnestWindowParent(pWin)) {
184	XReparentWindow(xnestDisplay, xnestWindow(pWin),
185	xnestWindowParent(pWin),
186	pWin->origin.x - wBorderWidth(pWin),
187	pWin->origin.y - wBorderWidth(pWin));
188	xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
189	xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
190	xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
191	xnestWindowPriv(pWin)->sibling_above = None;
192	if (pWin->nextSib)
193	xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
194	}
195
196	valuemask = 0;
197
198	if (mask & CWX &&
199	xnestWindowPriv(pWin)->x != pWin->origin.x - wBorderWidth(pWin)) {
200	valuemask \|= CWX;
201	values.x =
202	xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
203	}
204
205	if (mask & CWY &&
206	xnestWindowPriv(pWin)->y != pWin->origin.y - wBorderWidth(pWin)) {
207	valuemask \|= CWY;
208	values.y =
209	xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
210	}
211
212	if (mask & CWWidth && xnestWindowPriv(pWin)->width != pWin->drawable.width) {
213	valuemask \|= CWWidth;
214	values.width = xnestWindowPriv(pWin)->width = pWin->drawable.width;
215	}
216
217	if (mask & CWHeight &&
218	xnestWindowPriv(pWin)->height != pWin->drawable.height) {
219	valuemask \|= CWHeight;
220	values.height = xnestWindowPriv(pWin)->height = pWin->drawable.height;
221	}
222
223	if (mask & CWBorderWidth &&
224	xnestWindowPriv(pWin)->border_width != pWin->borderWidth) {
225	valuemask \|= CWBorderWidth;
226	values.border_width =
227	xnestWindowPriv(pWin)->border_width = pWin->borderWidth;
228	}
229
230	if (valuemask)
231	XConfigureWindow(xnestDisplay, xnestWindow(pWin), valuemask, &values);
232
233	if (mask & CWStackingOrder &&
234	xnestWindowPriv(pWin)->sibling_above != xnestWindowSiblingAbove(pWin)) {
235	WindowPtr pSib;
236
237	/* find the top sibling */
238	for (pSib = pWin; pSib->prevSib != NullWindow; pSib = pSib->prevSib);
239
240	/* the top sibling */
241	valuemask = CWStackMode;
242	values.stack_mode = Above;
243	XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values);
244	xnestWindowPriv(pSib)->sibling_above = None;
245
246	/* the rest of siblings */
247	for (pSib = pSib->nextSib; pSib != NullWindow; pSib = pSib->nextSib) {
248	valuemask = CWSibling \| CWStackMode;
249	values.sibling = xnestWindowSiblingAbove(pSib);
250	values.stack_mode = Below;
251	XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask,
252	&values);
253	xnestWindowPriv(pSib)->sibling_above =
254	xnestWindowSiblingAbove(pSib);
255	}
256	}
257	}
258
259	Bool
260	xnestChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
261	{
262	XSetWindowAttributes attributes;
263
264	if (mask & CWBackPixmap)
265	switch (pWin->backgroundState) {
266	case None:
267	attributes.background_pixmap = None;
268	break;
269
270	case ParentRelative:
271	attributes.background_pixmap = ParentRelative;
272	break;
273
274	case BackgroundPixmap:
275	attributes.background_pixmap = xnestPixmap(pWin->background.pixmap);
276	break;
277
278	case BackgroundPixel:
279	mask &= ~CWBackPixmap;
280	break;
281	}
282
283	if (mask & CWBackPixel) {
284	if (pWin->backgroundState == BackgroundPixel)
285	attributes.background_pixel = xnestPixel(pWin->background.pixel);
286	else
287	mask &= ~CWBackPixel;
288	}
289
290	if (mask & CWBorderPixmap) {
291	if (pWin->borderIsPixel)
292	mask &= ~CWBorderPixmap;
293	else
294	attributes.border_pixmap = xnestPixmap(pWin->border.pixmap);
295	}
296
297	if (mask & CWBorderPixel) {
298	if (pWin->borderIsPixel)
299	attributes.border_pixel = xnestPixel(pWin->border.pixel);
300	else
301	mask &= ~CWBorderPixel;
302	}
303
304	if (mask & CWBitGravity)
305	attributes.bit_gravity = pWin->bitGravity;
306
307	if (mask & CWWinGravity) /* dix does this for us */
308	mask &= ~CWWinGravity;
309
310	if (mask & CWBackingStore) /* this is really not useful */
311	mask &= ~CWBackingStore;
312
313	if (mask & CWBackingPlanes) /* this is really not useful */
314	mask &= ~CWBackingPlanes;
315
316	if (mask & CWBackingPixel) /* this is really not useful */
317	mask &= ~CWBackingPixel;
318
319	if (mask & CWOverrideRedirect)
320	attributes.override_redirect = pWin->overrideRedirect;
321
322	if (mask & CWSaveUnder) /* this is really not useful */
323	mask &= ~CWSaveUnder;
324
325	if (mask & CWEventMask) /* events are handled elsewhere */
326	mask &= ~CWEventMask;
327
328	if (mask & CWDontPropagate) /* events are handled elsewhere */
329	mask &= ~CWDontPropagate;
330
331	if (mask & CWColormap) {
332	ColormapPtr pCmap;
333
334	dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
335	RT_COLORMAP, serverClient, DixUseAccess);
336
337	attributes.colormap = xnestColormap(pCmap);
338
339	xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
340	}
341
342	if (mask & CWCursor) /* this is handeled in cursor code */
343	mask &= ~CWCursor;
344
345	if (mask)
346	XChangeWindowAttributes(xnestDisplay, xnestWindow(pWin),
347	mask, &attributes);
348
349	return True;
350	}
351
352	Bool
353	xnestRealizeWindow(WindowPtr pWin)
354	{
355	xnestConfigureWindow(pWin, CWStackingOrder);
356	xnestShapeWindow(pWin);
357	XMapWindow(xnestDisplay, xnestWindow(pWin));
358
359	return True;
360	}
361
362	Bool
363	xnestUnrealizeWindow(WindowPtr pWin)
364	{
365	XUnmapWindow(xnestDisplay, xnestWindow(pWin));
366
367	return True;
368	}
369
370	void
371	xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion)
372	{
373	}
374
375	void
376	xnestClipNotify(WindowPtr pWin, int dx, int dy)
377	{
378	xnestConfigureWindow(pWin, CWStackingOrder);
379	xnestShapeWindow(pWin);
380	}
381
382	static Bool
383	xnestWindowExposurePredicate(Display * display, XEvent * event, XPointer ptr)
384	{
385	return (event->type == Expose && event->xexpose.window == (Window ) ptr);
386	}
387
388	void
389	xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)
390	{
391	XEvent event;
392	Window window;
393	BoxRec Box;
394
395	XSync(xnestDisplay, False);
396
397	window = xnestWindow(pWin);
398
399	while (XCheckIfEvent(xnestDisplay, &event,
400	xnestWindowExposurePredicate, (char *) &window)) {
401
402	Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + event.xexpose.x;
403	Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + event.xexpose.y;
404	Box.x2 = Box.x1 + event.xexpose.width;
405	Box.y2 = Box.y1 + event.xexpose.height;
406
407	event.xexpose.type = ProcessedExpose;
408
409	if (RegionContainsRect(pRgn, &Box) != rgnIN)
410	XPutBackEvent(xnestDisplay, &event);
411	}
412
413	miWindowExposures(pWin, pRgn, other_exposed);
414	}
415
416	void
417	xnestSetShape(WindowPtr pWin, int kind)
418	{
419	xnestShapeWindow(pWin);
420	miSetShape(pWin, kind);
421	}
422
423	static Bool
424	xnestRegionEqual(RegionPtr pReg1, RegionPtr pReg2)
425	{
426	BoxPtr pBox1, pBox2;
427	unsigned int n1, n2;
428
429	if (pReg1 == pReg2)
430	return True;
431
432	if (pReg1 == NullRegion \|\| pReg2 == NullRegion)
433	return False;
434
435	pBox1 = RegionRects(pReg1);
436	n1 = RegionNumRects(pReg1);
437
438	pBox2 = RegionRects(pReg2);
439	n2 = RegionNumRects(pReg2);
440
441	if (n1 != n2)
442	return False;
443
444	if (pBox1 == pBox2)
445	return True;
446
447	if (memcmp(pBox1, pBox2, n1 * sizeof(BoxRec)))
448	return False;
449
450	return True;
451	}
452
453	void
454	xnestShapeWindow(WindowPtr pWin)
455	{
456	Region reg;
457	BoxPtr pBox;
458	XRectangle rect;
459	int i;
460
461	if (!xnestRegionEqual(xnestWindowPriv(pWin)->bounding_shape,
462	wBoundingShape(pWin))) {
463
464	if (wBoundingShape(pWin)) {
465	RegionCopy(xnestWindowPriv(pWin)->bounding_shape,
466	wBoundingShape(pWin));
467
468	reg = XCreateRegion();
469	pBox = RegionRects(xnestWindowPriv(pWin)->bounding_shape);
470	for (i = 0;
471	i < RegionNumRects(xnestWindowPriv(pWin)->bounding_shape);
472	i++) {
473	rect.x = pBox[i].x1;
474	rect.y = pBox[i].y1;
475	rect.width = pBox[i].x2 - pBox[i].x1;
476	rect.height = pBox[i].y2 - pBox[i].y1;
477	XUnionRectWithRegion(&rect, reg, reg);
478	}
479	XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
480	ShapeBounding, 0, 0, reg, ShapeSet);
481	XDestroyRegion(reg);
482	}
483	else {
484	RegionEmpty(xnestWindowPriv(pWin)->bounding_shape);
485
486	XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
487	ShapeBounding, 0, 0, None, ShapeSet);
488	}
489	}
490
491	if (!xnestRegionEqual(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin))) {
492
493	if (wClipShape(pWin)) {
494	RegionCopy(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin));
495
496	reg = XCreateRegion();
497	pBox = RegionRects(xnestWindowPriv(pWin)->clip_shape);
498	for (i = 0;
499	i < RegionNumRects(xnestWindowPriv(pWin)->clip_shape); i++) {
500	rect.x = pBox[i].x1;
501	rect.y = pBox[i].y1;
502	rect.width = pBox[i].x2 - pBox[i].x1;
503	rect.height = pBox[i].y2 - pBox[i].y1;
504	XUnionRectWithRegion(&rect, reg, reg);
505	}
506	XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
507	ShapeClip, 0, 0, reg, ShapeSet);
508	XDestroyRegion(reg);
509	}
510	else {
511	RegionEmpty(xnestWindowPriv(pWin)->clip_shape);
512
513	XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
514	ShapeClip, 0, 0, None, ShapeSet);
515	}
516	}
517	}