[deb_xorg-server.git] / hw / xwin / winwindow.c

/*
 *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
 *
 *Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 *"Software"), to deal in the Software without restriction, including
 *without limitation the rights to use, copy, modify, merge, publish,
 *distribute, sublicense, and/or sell copies of the Software, and to
 *permit persons to whom the Software is furnished to do so, subject to
 *the following conditions:
 *
 *The above copyright notice and this permission notice shall be
 *included in all copies or substantial portions of the Software.
 *
 *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
 *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 *Except as contained in this notice, the name of the XFree86 Project
 *shall not be used in advertising or otherwise to promote the sale, use
 *or other dealings in this Software without prior written authorization
 *from the XFree86 Project.
 *
 * Authors:	Harold L Hunt II
 *		Kensuke Matsuzaki
 */

#ifdef HAVE_XWIN_CONFIG_H
#include <xwin-config.h>
#endif
#include "win.h"

/*
 * Prototypes for local functions
 */

static int
 winAddRgn(WindowPtr pWindow, pointer data);

static
    void
 winUpdateRgnRootless(WindowPtr pWindow);

static
    void
 winReshapeRootless(WindowPtr pWin);

#ifdef XWIN_NATIVEGDI
/* See Porting Layer Definition - p. 37 */
/* See mfb/mfbwindow.c - mfbCreateWindow() */

Bool
winCreateWindowNativeGDI(WindowPtr pWin)
{
    Bool fResult = TRUE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winCreateWindowNativeGDI (%p)\n", pWin);
#endif

    WIN_UNWRAP(CreateWindow);
    fResult = (*pScreen->CreateWindow) (pWin);
    WIN_WRAP(CreateWindow, winCreateWindowNativeGDI);

    return fResult;
}

/* See Porting Layer Definition - p. 37 */
/* See mfb/mfbwindow.c - mfbDestroyWindow() */

Bool
winDestroyWindowNativeGDI(WindowPtr pWin)
{
    Bool fResult = TRUE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winDestroyWindowNativeGDI (%p)\n", pWin);
#endif

    WIN_UNWRAP(DestroyWindow);
    fResult = (*pScreen->DestroyWindow) (pWin);
    WIN_WRAP(DestroyWindow, winDestroyWindowNativeGDI);

    return fResult;
}

/* See Porting Layer Definition - p. 37 */
/* See mfb/mfbwindow.c - mfbPositionWindow() */

Bool
winPositionWindowNativeGDI(WindowPtr pWin, int x, int y)
{
    Bool fResult = TRUE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winPositionWindowNativeGDI (%p)\n", pWin);
#endif

    WIN_UNWRAP(PositionWindow);
    fResult = (*pScreen->PositionWindow) (pWin, x, y);
    WIN_WRAP(PositionWindow, winPositionWindowNativeGDI);

    return fResult;
}

/* See Porting Layer Definition - p. 39 */
/* See mfb/mfbwindow.c - mfbCopyWindow() */

void
winCopyWindowNativeGDI(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{
    DDXPointPtr pptSrc;
    DDXPointPtr ppt;
    RegionPtr prgnDst;
    BoxPtr pBox;
    int dx, dy;
    int i, nbox;
    BoxPtr pBoxDst;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if 0
    ErrorF("winCopyWindow\n");
#endif

    /* Create a region for the destination */
    prgnDst = RegionCreate(NULL, 1);

    /* Calculate the shift from the source to the destination */
    dx = ptOldOrg.x - pWin->drawable.x;
    dy = ptOldOrg.y - pWin->drawable.y;

    /* Translate the region from the destination to the source? */
    RegionTranslate(prgnSrc, -dx, -dy);
    RegionIntersect(prgnDst, &pWin->borderClip, prgnSrc);

    /* Get a pointer to the first box in the region to be copied */
    pBox = RegionRects(prgnDst);

    /* Get the number of boxes in the region */
    nbox = RegionNumRects(prgnDst);

    /* Allocate source points for each box */
    if (!(pptSrc = (DDXPointPtr) malloc(nbox * sizeof(DDXPointRec))))
        return;

    /* Set an iterator pointer */
    ppt = pptSrc;

    /* Calculate the source point of each box? */
    for (i = nbox; --i >= 0; ppt++, pBox++) {
        ppt->x = pBox->x1 + dx;
        ppt->y = pBox->y1 + dy;
    }

    /* Setup loop pointers again */
    pBoxDst = RegionRects(prgnDst);
    ppt = pptSrc;

#if 0
    ErrorF("winCopyWindow - x1\tx2\ty1\ty2\tx\ty\n");
#endif

    /* BitBlt each source to the destination point */
    for (i = nbox; --i >= 0; pBoxDst++, ppt++) {
#if 0
        ErrorF("winCopyWindow - %d\t%d\t%d\t%d\t%d\t%d\n",
               pBoxDst->x1, pBoxDst->x2, pBoxDst->y1, pBoxDst->y2,
               ppt->x, ppt->y);
#endif

        BitBlt(pScreenPriv->hdcScreen,
               pBoxDst->x1, pBoxDst->y1,
               pBoxDst->x2 - pBoxDst->x1, pBoxDst->y2 - pBoxDst->y1,
               pScreenPriv->hdcScreen, ppt->x, ppt->y, SRCCOPY);
    }

    /* Cleanup the regions, etc. */
    free(pptSrc);
    RegionDestroy(prgnDst);
}

/* See Porting Layer Definition - p. 37 */
/* See mfb/mfbwindow.c - mfbChangeWindowAttributes() */

Bool
winChangeWindowAttributesNativeGDI(WindowPtr pWin, unsigned long mask)
{
    Bool fResult = TRUE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winChangeWindowAttributesNativeGDI (%p)\n", pWin);
#endif

    WIN_UNWRAP(ChangeWindowAttributes);
    fResult = (*pScreen->ChangeWindowAttributes) (pWin, mask);
    WIN_WRAP(ChangeWindowAttributes, winChangeWindowAttributesNativeGDI);

    /*
     * NOTE: We do not currently need to do anything here.
     */

    return fResult;
}

/* See Porting Layer Definition - p. 37
 * Also referred to as UnrealizeWindow
 */

Bool
winUnmapWindowNativeGDI(WindowPtr pWin)
{
    Bool fResult = TRUE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winUnmapWindowNativeGDI (%p)\n", pWin);
#endif

    WIN_UNWRAP(UnrealizeWindow);
    fResult = (*pScreen->UnrealizeWindow) (pWin);
    WIN_WRAP(UnrealizeWindow, winUnmapWindowNativeGDI);

    return fResult;
}

/* See Porting Layer Definition - p. 37
 * Also referred to as RealizeWindow
 */

Bool
winMapWindowNativeGDI(WindowPtr pWin)
{
    Bool fResult = TRUE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winMapWindowNativeGDI (%p)\n", pWin);
#endif

    WIN_UNWRAP(RealizeWindow);
    fResult = (*pScreen->RealizeWindow) (pWin);
    WIN_WRAP(RealizeWindow, winMapWindowMultiWindow);

    return fResult;

}
#endif

/* See Porting Layer Definition - p. 37 */
/* See mfb/mfbwindow.c - mfbCreateWindow() */

Bool
winCreateWindowRootless(WindowPtr pWin)
{
    Bool fResult = FALSE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winWindowPriv(pWin);
    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winCreateWindowRootless (%p)\n", pWin);
#endif

    WIN_UNWRAP(CreateWindow);
    fResult = (*pScreen->CreateWindow) (pWin);
    WIN_WRAP(CreateWindow, winCreateWindowRootless);

    pWinPriv->hRgn = NULL;

    return fResult;
}

/* See Porting Layer Definition - p. 37 */
/* See mfb/mfbwindow.c - mfbDestroyWindow() */

Bool
winDestroyWindowRootless(WindowPtr pWin)
{
    Bool fResult = FALSE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winWindowPriv(pWin);
    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winDestroyWindowRootless (%p)\n", pWin);
#endif

    WIN_UNWRAP(DestroyWindow);
    fResult = (*pScreen->DestroyWindow) (pWin);
    WIN_WRAP(DestroyWindow, winDestroyWindowRootless);

    if (pWinPriv->hRgn != NULL) {
        DeleteObject(pWinPriv->hRgn);
        pWinPriv->hRgn = NULL;
    }

    winUpdateRgnRootless(pWin);

    return fResult;
}

/* See Porting Layer Definition - p. 37 */
/* See mfb/mfbwindow.c - mfbPositionWindow() */

Bool
winPositionWindowRootless(WindowPtr pWin, int x, int y)
{
    Bool fResult = FALSE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winPositionWindowRootless (%p)\n", pWin);
#endif

    WIN_UNWRAP(PositionWindow);
    fResult = (*pScreen->PositionWindow) (pWin, x, y);
    WIN_WRAP(PositionWindow, winPositionWindowRootless);

    winUpdateRgnRootless(pWin);

    return fResult;
}

/* See Porting Layer Definition - p. 37 */
/* See mfb/mfbwindow.c - mfbChangeWindowAttributes() */

Bool
winChangeWindowAttributesRootless(WindowPtr pWin, unsigned long mask)
{
    Bool fResult = FALSE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winChangeWindowAttributesRootless (%p)\n", pWin);
#endif

    WIN_UNWRAP(ChangeWindowAttributes);
    fResult = (*pScreen->ChangeWindowAttributes) (pWin, mask);
    WIN_WRAP(ChangeWindowAttributes, winChangeWindowAttributesRootless);

    winUpdateRgnRootless(pWin);

    return fResult;
}

/* See Porting Layer Definition - p. 37
 * Also referred to as UnrealizeWindow
 */

Bool
winUnmapWindowRootless(WindowPtr pWin)
{
    Bool fResult = FALSE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winWindowPriv(pWin);
    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winUnmapWindowRootless (%p)\n", pWin);
#endif

    WIN_UNWRAP(UnrealizeWindow);
    fResult = (*pScreen->UnrealizeWindow) (pWin);
    WIN_WRAP(UnrealizeWindow, winUnmapWindowRootless);

    if (pWinPriv->hRgn != NULL) {
        DeleteObject(pWinPriv->hRgn);
        pWinPriv->hRgn = NULL;
    }

    winUpdateRgnRootless(pWin);

    return fResult;
}

/* See Porting Layer Definition - p. 37
 * Also referred to as RealizeWindow
 */

Bool
winMapWindowRootless(WindowPtr pWin)
{
    Bool fResult = FALSE;
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winMapWindowRootless (%p)\n", pWin);
#endif

    WIN_UNWRAP(RealizeWindow);
    fResult = (*pScreen->RealizeWindow) (pWin);
    WIN_WRAP(RealizeWindow, winMapWindowRootless);

    winReshapeRootless(pWin);

    winUpdateRgnRootless(pWin);

    return fResult;
}

void
winSetShapeRootless(WindowPtr pWin, int kind)
{
    ScreenPtr pScreen = pWin->drawable.pScreen;

    winScreenPriv(pScreen);

#if CYGDEBUG
    winTrace("winSetShapeRootless (%p, %i)\n", pWin, kind);
#endif

    WIN_UNWRAP(SetShape);
    (*pScreen->SetShape) (pWin, kind);
    WIN_WRAP(SetShape, winSetShapeRootless);

    winReshapeRootless(pWin);
    winUpdateRgnRootless(pWin);

    return;
}

/*
 * Local function for adding a region to the Windows window region
 */

static
    int
winAddRgn(WindowPtr pWin, pointer data)
{
    int iX, iY, iWidth, iHeight, iBorder;
    HRGN hRgn = *(HRGN *) data;
    HRGN hRgnWin;

    winWindowPriv(pWin);

    /* If pWin is not Root */
    if (pWin->parent != NULL) {
#if CYGDEBUG
        winDebug("winAddRgn ()\n");
#endif
        if (pWin->mapped) {
            iBorder = wBorderWidth(pWin);

            iX = pWin->drawable.x - iBorder;
            iY = pWin->drawable.y - iBorder;

            iWidth = pWin->drawable.width + iBorder * 2;
            iHeight = pWin->drawable.height + iBorder * 2;

            hRgnWin = CreateRectRgn(0, 0, iWidth, iHeight);

            if (hRgnWin == NULL) {
                ErrorF("winAddRgn - CreateRectRgn () failed\n");
                ErrorF("  Rect %d %d %d %d\n",
                       iX, iY, iX + iWidth, iY + iHeight);
            }

            if (pWinPriv->hRgn) {
                if (CombineRgn(hRgnWin, hRgnWin, pWinPriv->hRgn, RGN_AND)
                    == ERROR) {
                    ErrorF("winAddRgn - CombineRgn () failed\n");
                }
            }

            OffsetRgn(hRgnWin, iX, iY);

            if (CombineRgn(hRgn, hRgn, hRgnWin, RGN_OR) == ERROR) {
                ErrorF("winAddRgn - CombineRgn () failed\n");
            }

            DeleteObject(hRgnWin);
        }
        return WT_DONTWALKCHILDREN;
    }
    else {
        return WT_WALKCHILDREN;
    }
}

/*
 * Local function to update the Windows window's region
 */

static
    void
winUpdateRgnRootless(WindowPtr pWin)
{
    HRGN hRgn = CreateRectRgn(0, 0, 0, 0);

    if (hRgn != NULL) {
        WalkTree(pWin->drawable.pScreen, winAddRgn, &hRgn);
        SetWindowRgn(winGetScreenPriv(pWin->drawable.pScreen)->hwndScreen,
                     hRgn, TRUE);
    }
    else {
        ErrorF("winUpdateRgnRootless - CreateRectRgn failed.\n");
    }
}

static
    void
winReshapeRootless(WindowPtr pWin)
{
    int nRects;
    RegionRec rrNewShape;
    BoxPtr pShape, pRects, pEnd;
    HRGN hRgn, hRgnRect;

    winWindowPriv(pWin);

#if CYGDEBUG
    winDebug("winReshapeRootless ()\n");
#endif

    /* Bail if the window is the root window */
    if (pWin->parent == NULL)
        return;

    /* Bail if the window is not top level */
    if (pWin->parent->parent != NULL)
        return;

    /* Free any existing window region stored in the window privates */
    if (pWinPriv->hRgn != NULL) {
        DeleteObject(pWinPriv->hRgn);
        pWinPriv->hRgn = NULL;
    }

    /* Bail if the window has no bounding region defined */
    if (!wBoundingShape(pWin))
        return;

    RegionNull(&rrNewShape);
    RegionCopy(&rrNewShape, wBoundingShape(pWin));
    RegionTranslate(&rrNewShape, pWin->borderWidth, pWin->borderWidth);

    nRects = RegionNumRects(&rrNewShape);
    pShape = RegionRects(&rrNewShape);

    if (nRects > 0) {
        /* Create initial empty Windows region */
        hRgn = CreateRectRgn(0, 0, 0, 0);

        /* Loop through all rectangles in the X region */
        for (pRects = pShape, pEnd = pShape + nRects; pRects < pEnd; pRects++) {
            /* Create a Windows region for the X rectangle */
            hRgnRect = CreateRectRgn(pRects->x1, pRects->y1,
                                     pRects->x2, pRects->y2);
            if (hRgnRect == NULL) {
                ErrorF("winReshapeRootless - CreateRectRgn() failed\n");
            }

            /* Merge the Windows region with the accumulated region */
            if (CombineRgn(hRgn, hRgn, hRgnRect, RGN_OR) == ERROR) {
                ErrorF("winReshapeRootless - CombineRgn() failed\n");
            }

            /* Delete the temporary Windows region */
            DeleteObject(hRgnRect);
        }

        /* Save a handle to the composite region in the window privates */
        pWinPriv->hRgn = hRgn;
    }

    RegionUninit(&rrNewShape);

    return;
}
Commit	Line	Data
a09e091a JB	1	/*
	2	*Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
	3	*
	4	*Permission is hereby granted, free of charge, to any person obtaining
	5	* a copy of this software and associated documentation files (the
	6	*"Software"), to deal in the Software without restriction, including
	7	*without limitation the rights to use, copy, modify, merge, publish,
	8	*distribute, sublicense, and/or sell copies of the Software, and to
	9	*permit persons to whom the Software is furnished to do so, subject to
	10	*the following conditions:
	11	*
	12	*The above copyright notice and this permission notice shall be
	13	*included in all copies or substantial portions of the Software.
	14	*
	15	*THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	16	*EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	17	*MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	18	*NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
	19	*ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
	20	*CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	21	*WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	22	*
	23	*Except as contained in this notice, the name of the XFree86 Project
	24	*shall not be used in advertising or otherwise to promote the sale, use
	25	*or other dealings in this Software without prior written authorization
	26	*from the XFree86 Project.
	27	*
	28	* Authors: Harold L Hunt II
	29	* Kensuke Matsuzaki
	30	*/
	31
	32	#ifdef HAVE_XWIN_CONFIG_H
	33	#include <xwin-config.h>
	34	#endif
	35	#include "win.h"
	36
	37	/*
	38	* Prototypes for local functions
	39	*/
	40
	41	static int
	42	winAddRgn(WindowPtr pWindow, pointer data);
	43
	44	static
	45	void
	46	winUpdateRgnRootless(WindowPtr pWindow);
	47
	48	static
	49	void
	50	winReshapeRootless(WindowPtr pWin);
	51
	52	#ifdef XWIN_NATIVEGDI
	53	/* See Porting Layer Definition - p. 37 */
	54	/* See mfb/mfbwindow.c - mfbCreateWindow() */
	55
	56	Bool
	57	winCreateWindowNativeGDI(WindowPtr pWin)
	58	{
	59	Bool fResult = TRUE;
	60	ScreenPtr pScreen = pWin->drawable.pScreen;
	61
	62	winScreenPriv(pScreen);
	63
	64	#if CYGDEBUG
65	winTrace("winCreateWindowNativeGDI (%p)\n", pWin);
66	#endif
67
68	WIN_UNWRAP(CreateWindow);
69	fResult = (*pScreen->CreateWindow) (pWin);
70	WIN_WRAP(CreateWindow, winCreateWindowNativeGDI);
71
72	return fResult;
73	}
74
75	/* See Porting Layer Definition - p. 37 */
76	/* See mfb/mfbwindow.c - mfbDestroyWindow() */
77
78	Bool
79	winDestroyWindowNativeGDI(WindowPtr pWin)
80	{
81	Bool fResult = TRUE;
82	ScreenPtr pScreen = pWin->drawable.pScreen;
83
84	winScreenPriv(pScreen);
85
86	#if CYGDEBUG
87	winTrace("winDestroyWindowNativeGDI (%p)\n", pWin);
88	#endif
89
90	WIN_UNWRAP(DestroyWindow);
91	fResult = (*pScreen->DestroyWindow) (pWin);
92	WIN_WRAP(DestroyWindow, winDestroyWindowNativeGDI);
93
94	return fResult;
95	}
96
97	/* See Porting Layer Definition - p. 37 */
98	/* See mfb/mfbwindow.c - mfbPositionWindow() */
99
100	Bool
101	winPositionWindowNativeGDI(WindowPtr pWin, int x, int y)
102	{
103	Bool fResult = TRUE;
104	ScreenPtr pScreen = pWin->drawable.pScreen;
105
106	winScreenPriv(pScreen);
107
108	#if CYGDEBUG
109	winTrace("winPositionWindowNativeGDI (%p)\n", pWin);
110	#endif
111
112	WIN_UNWRAP(PositionWindow);
113	fResult = (*pScreen->PositionWindow) (pWin, x, y);
114	WIN_WRAP(PositionWindow, winPositionWindowNativeGDI);
115
116	return fResult;
117	}
118
119	/* See Porting Layer Definition - p. 39 */
120	/* See mfb/mfbwindow.c - mfbCopyWindow() */
121
122	void
123	winCopyWindowNativeGDI(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
124	{
125	DDXPointPtr pptSrc;
126	DDXPointPtr ppt;
127	RegionPtr prgnDst;
128	BoxPtr pBox;
129	int dx, dy;
130	int i, nbox;
131	BoxPtr pBoxDst;
132	ScreenPtr pScreen = pWin->drawable.pScreen;
133
134	winScreenPriv(pScreen);
135
136	#if 0
137	ErrorF("winCopyWindow\n");
138	#endif
139
140	/* Create a region for the destination */
141	prgnDst = RegionCreate(NULL, 1);
142
143	/* Calculate the shift from the source to the destination */
144	dx = ptOldOrg.x - pWin->drawable.x;
145	dy = ptOldOrg.y - pWin->drawable.y;
146
147	/* Translate the region from the destination to the source? */
148	RegionTranslate(prgnSrc, -dx, -dy);
149	RegionIntersect(prgnDst, &pWin->borderClip, prgnSrc);
150
151	/* Get a pointer to the first box in the region to be copied */
152	pBox = RegionRects(prgnDst);
153
154	/* Get the number of boxes in the region */
155	nbox = RegionNumRects(prgnDst);
156
157	/* Allocate source points for each box */
158	if (!(pptSrc = (DDXPointPtr) malloc(nbox * sizeof(DDXPointRec))))
159	return;
160
161	/* Set an iterator pointer */
162	ppt = pptSrc;
163
164	/* Calculate the source point of each box? */
165	for (i = nbox; --i >= 0; ppt++, pBox++) {
166	ppt->x = pBox->x1 + dx;
167	ppt->y = pBox->y1 + dy;
168	}
169
170	/* Setup loop pointers again */
171	pBoxDst = RegionRects(prgnDst);
172	ppt = pptSrc;
173
174	#if 0
175	ErrorF("winCopyWindow - x1\tx2\ty1\ty2\tx\ty\n");
176	#endif
177
178	/* BitBlt each source to the destination point */
179	for (i = nbox; --i >= 0; pBoxDst++, ppt++) {
180	#if 0
181	ErrorF("winCopyWindow - %d\t%d\t%d\t%d\t%d\t%d\n",
182	pBoxDst->x1, pBoxDst->x2, pBoxDst->y1, pBoxDst->y2,
183	ppt->x, ppt->y);
184	#endif
185
186	BitBlt(pScreenPriv->hdcScreen,
187	pBoxDst->x1, pBoxDst->y1,
188	pBoxDst->x2 - pBoxDst->x1, pBoxDst->y2 - pBoxDst->y1,
189	pScreenPriv->hdcScreen, ppt->x, ppt->y, SRCCOPY);
190	}
191
192	/* Cleanup the regions, etc. */
193	free(pptSrc);
194	RegionDestroy(prgnDst);
195	}
196
197	/* See Porting Layer Definition - p. 37 */
198	/* See mfb/mfbwindow.c - mfbChangeWindowAttributes() */
199
200	Bool
201	winChangeWindowAttributesNativeGDI(WindowPtr pWin, unsigned long mask)
202	{
203	Bool fResult = TRUE;
204	ScreenPtr pScreen = pWin->drawable.pScreen;
205
206	winScreenPriv(pScreen);
207
208	#if CYGDEBUG
209	winTrace("winChangeWindowAttributesNativeGDI (%p)\n", pWin);
210	#endif
211
212	WIN_UNWRAP(ChangeWindowAttributes);
213	fResult = (*pScreen->ChangeWindowAttributes) (pWin, mask);
214	WIN_WRAP(ChangeWindowAttributes, winChangeWindowAttributesNativeGDI);
215
216	/*
217	* NOTE: We do not currently need to do anything here.
218	*/
219
220	return fResult;
221	}
222
223	/* See Porting Layer Definition - p. 37
224	* Also referred to as UnrealizeWindow
225	*/
226
227	Bool
228	winUnmapWindowNativeGDI(WindowPtr pWin)
229	{
230	Bool fResult = TRUE;
231	ScreenPtr pScreen = pWin->drawable.pScreen;
232
233	winScreenPriv(pScreen);
234
235	#if CYGDEBUG
236	winTrace("winUnmapWindowNativeGDI (%p)\n", pWin);
237	#endif
238
239	WIN_UNWRAP(UnrealizeWindow);
240	fResult = (*pScreen->UnrealizeWindow) (pWin);
241	WIN_WRAP(UnrealizeWindow, winUnmapWindowNativeGDI);
242
243	return fResult;
244	}
245
246	/* See Porting Layer Definition - p. 37
247	* Also referred to as RealizeWindow
248	*/
249
250	Bool
251	winMapWindowNativeGDI(WindowPtr pWin)
252	{
253	Bool fResult = TRUE;
254	ScreenPtr pScreen = pWin->drawable.pScreen;
255
256	winScreenPriv(pScreen);
257
258	#if CYGDEBUG
259	winTrace("winMapWindowNativeGDI (%p)\n", pWin);
260	#endif
261
262	WIN_UNWRAP(RealizeWindow);
263	fResult = (*pScreen->RealizeWindow) (pWin);
264	WIN_WRAP(RealizeWindow, winMapWindowMultiWindow);
265
266	return fResult;
267
268	}
269	#endif
270
271	/* See Porting Layer Definition - p. 37 */
272	/* See mfb/mfbwindow.c - mfbCreateWindow() */
273
274	Bool
275	winCreateWindowRootless(WindowPtr pWin)
276	{
277	Bool fResult = FALSE;
278	ScreenPtr pScreen = pWin->drawable.pScreen;
279
280	winWindowPriv(pWin);
281	winScreenPriv(pScreen);
282
283	#if CYGDEBUG
284	winTrace("winCreateWindowRootless (%p)\n", pWin);
285	#endif
286
287	WIN_UNWRAP(CreateWindow);
288	fResult = (*pScreen->CreateWindow) (pWin);
289	WIN_WRAP(CreateWindow, winCreateWindowRootless);
290
291	pWinPriv->hRgn = NULL;
292
293	return fResult;
294	}
295
296	/* See Porting Layer Definition - p. 37 */
297	/* See mfb/mfbwindow.c - mfbDestroyWindow() */
298
299	Bool
300	winDestroyWindowRootless(WindowPtr pWin)
301	{
302	Bool fResult = FALSE;
303	ScreenPtr pScreen = pWin->drawable.pScreen;
304
305	winWindowPriv(pWin);
306	winScreenPriv(pScreen);
307
308	#if CYGDEBUG
309	winTrace("winDestroyWindowRootless (%p)\n", pWin);
310	#endif
311
312	WIN_UNWRAP(DestroyWindow);
313	fResult = (*pScreen->DestroyWindow) (pWin);
314	WIN_WRAP(DestroyWindow, winDestroyWindowRootless);
315
316	if (pWinPriv->hRgn != NULL) {
317	DeleteObject(pWinPriv->hRgn);
318	pWinPriv->hRgn = NULL;
319	}
320
321	winUpdateRgnRootless(pWin);
322
323	return fResult;
324	}
325
326	/* See Porting Layer Definition - p. 37 */
327	/* See mfb/mfbwindow.c - mfbPositionWindow() */
328
329	Bool
330	winPositionWindowRootless(WindowPtr pWin, int x, int y)
331	{
332	Bool fResult = FALSE;
333	ScreenPtr pScreen = pWin->drawable.pScreen;
334
335	winScreenPriv(pScreen);
336
337	#if CYGDEBUG
338	winTrace("winPositionWindowRootless (%p)\n", pWin);
339	#endif
340
341	WIN_UNWRAP(PositionWindow);
342	fResult = (*pScreen->PositionWindow) (pWin, x, y);
343	WIN_WRAP(PositionWindow, winPositionWindowRootless);
344
345	winUpdateRgnRootless(pWin);
346
347	return fResult;
348	}
349
350	/* See Porting Layer Definition - p. 37 */
351	/* See mfb/mfbwindow.c - mfbChangeWindowAttributes() */
352
353	Bool
354	winChangeWindowAttributesRootless(WindowPtr pWin, unsigned long mask)
355	{
356	Bool fResult = FALSE;
357	ScreenPtr pScreen = pWin->drawable.pScreen;
358
359	winScreenPriv(pScreen);
360
361	#if CYGDEBUG
362	winTrace("winChangeWindowAttributesRootless (%p)\n", pWin);
363	#endif
364
365	WIN_UNWRAP(ChangeWindowAttributes);
366	fResult = (*pScreen->ChangeWindowAttributes) (pWin, mask);
367	WIN_WRAP(ChangeWindowAttributes, winChangeWindowAttributesRootless);
368
369	winUpdateRgnRootless(pWin);
370
371	return fResult;
372	}
373
374	/* See Porting Layer Definition - p. 37
375	* Also referred to as UnrealizeWindow
376	*/
377
378	Bool
379	winUnmapWindowRootless(WindowPtr pWin)
380	{
381	Bool fResult = FALSE;
382	ScreenPtr pScreen = pWin->drawable.pScreen;
383
384	winWindowPriv(pWin);
385	winScreenPriv(pScreen);
386
387	#if CYGDEBUG
388	winTrace("winUnmapWindowRootless (%p)\n", pWin);
389	#endif
390
391	WIN_UNWRAP(UnrealizeWindow);
392	fResult = (*pScreen->UnrealizeWindow) (pWin);
393	WIN_WRAP(UnrealizeWindow, winUnmapWindowRootless);
394
395	if (pWinPriv->hRgn != NULL) {
396	DeleteObject(pWinPriv->hRgn);
397	pWinPriv->hRgn = NULL;
398	}
399
400	winUpdateRgnRootless(pWin);
401
402	return fResult;
403	}
404
405	/* See Porting Layer Definition - p. 37
406	* Also referred to as RealizeWindow
407	*/
408
409	Bool
410	winMapWindowRootless(WindowPtr pWin)
411	{
412	Bool fResult = FALSE;
413	ScreenPtr pScreen = pWin->drawable.pScreen;
414
415	winScreenPriv(pScreen);
416
417	#if CYGDEBUG
418	winTrace("winMapWindowRootless (%p)\n", pWin);
419	#endif
420
421	WIN_UNWRAP(RealizeWindow);
422	fResult = (*pScreen->RealizeWindow) (pWin);
423	WIN_WRAP(RealizeWindow, winMapWindowRootless);
424
425	winReshapeRootless(pWin);
426
427	winUpdateRgnRootless(pWin);
428
429	return fResult;
430	}
431
432	void
433	winSetShapeRootless(WindowPtr pWin, int kind)
434	{
435	ScreenPtr pScreen = pWin->drawable.pScreen;
436
437	winScreenPriv(pScreen);
438
439	#if CYGDEBUG
440	winTrace("winSetShapeRootless (%p, %i)\n", pWin, kind);
441	#endif
442
443	WIN_UNWRAP(SetShape);
444	(*pScreen->SetShape) (pWin, kind);
445	WIN_WRAP(SetShape, winSetShapeRootless);
446
447	winReshapeRootless(pWin);
448	winUpdateRgnRootless(pWin);
449
450	return;
451	}
452
453	/*
454	* Local function for adding a region to the Windows window region
455	*/
456
457	static
458	int
459	winAddRgn(WindowPtr pWin, pointer data)
460	{
461	int iX, iY, iWidth, iHeight, iBorder;
462	HRGN hRgn = (HRGN ) data;
463	HRGN hRgnWin;
464
465	winWindowPriv(pWin);
466
467	/* If pWin is not Root */
468	if (pWin->parent != NULL) {
469	#if CYGDEBUG
470	winDebug("winAddRgn ()\n");
471	#endif
472	if (pWin->mapped) {
473	iBorder = wBorderWidth(pWin);
474
475	iX = pWin->drawable.x - iBorder;
476	iY = pWin->drawable.y - iBorder;
477
478	iWidth = pWin->drawable.width + iBorder * 2;
479	iHeight = pWin->drawable.height + iBorder * 2;
480
481	hRgnWin = CreateRectRgn(0, 0, iWidth, iHeight);
482
483	if (hRgnWin == NULL) {
484	ErrorF("winAddRgn - CreateRectRgn () failed\n");
485	ErrorF(" Rect %d %d %d %d\n",
486	iX, iY, iX + iWidth, iY + iHeight);
487	}
488
489	if (pWinPriv->hRgn) {
490	if (CombineRgn(hRgnWin, hRgnWin, pWinPriv->hRgn, RGN_AND)
491	== ERROR) {
492	ErrorF("winAddRgn - CombineRgn () failed\n");
493	}
494	}
495
496	OffsetRgn(hRgnWin, iX, iY);
497
498	if (CombineRgn(hRgn, hRgn, hRgnWin, RGN_OR) == ERROR) {
499	ErrorF("winAddRgn - CombineRgn () failed\n");
500	}
501
502	DeleteObject(hRgnWin);
503	}
504	return WT_DONTWALKCHILDREN;
505	}
506	else {
507	return WT_WALKCHILDREN;
508	}
509	}
510
511	/*
512	* Local function to update the Windows window's region
513	*/
514
515	static
516	void
517	winUpdateRgnRootless(WindowPtr pWin)
518	{
519	HRGN hRgn = CreateRectRgn(0, 0, 0, 0);
520
521	if (hRgn != NULL) {
522	WalkTree(pWin->drawable.pScreen, winAddRgn, &hRgn);
523	SetWindowRgn(winGetScreenPriv(pWin->drawable.pScreen)->hwndScreen,
524	hRgn, TRUE);
525	}
526	else {
527	ErrorF("winUpdateRgnRootless - CreateRectRgn failed.\n");
528	}
529	}
530
531	static
532	void
533	winReshapeRootless(WindowPtr pWin)
534	{
535	int nRects;
536	RegionRec rrNewShape;
537	BoxPtr pShape, pRects, pEnd;
538	HRGN hRgn, hRgnRect;
539
540	winWindowPriv(pWin);
541
542	#if CYGDEBUG
543	winDebug("winReshapeRootless ()\n");
544	#endif
545
546	/* Bail if the window is the root window */
547	if (pWin->parent == NULL)
548	return;
549
550	/* Bail if the window is not top level */
551	if (pWin->parent->parent != NULL)
552	return;
553
554	/* Free any existing window region stored in the window privates */
555	if (pWinPriv->hRgn != NULL) {
556	DeleteObject(pWinPriv->hRgn);
557	pWinPriv->hRgn = NULL;
558	}
559
560	/* Bail if the window has no bounding region defined */
561	if (!wBoundingShape(pWin))
562	return;
563
564	RegionNull(&rrNewShape);
565	RegionCopy(&rrNewShape, wBoundingShape(pWin));
566	RegionTranslate(&rrNewShape, pWin->borderWidth, pWin->borderWidth);
567
568	nRects = RegionNumRects(&rrNewShape);
569	pShape = RegionRects(&rrNewShape);
570
571	if (nRects > 0) {
572	/* Create initial empty Windows region */
573	hRgn = CreateRectRgn(0, 0, 0, 0);
574
575	/* Loop through all rectangles in the X region */
576	for (pRects = pShape, pEnd = pShape + nRects; pRects < pEnd; pRects++) {
577	/* Create a Windows region for the X rectangle */
578	hRgnRect = CreateRectRgn(pRects->x1, pRects->y1,
579	pRects->x2, pRects->y2);
580	if (hRgnRect == NULL) {
581	ErrorF("winReshapeRootless - CreateRectRgn() failed\n");
582	}
583
584	/* Merge the Windows region with the accumulated region */
585	if (CombineRgn(hRgn, hRgn, hRgnRect, RGN_OR) == ERROR) {
586	ErrorF("winReshapeRootless - CombineRgn() failed\n");
587	}
588
589	/* Delete the temporary Windows region */
590	DeleteObject(hRgnRect);
591	}
592
593	/* Save a handle to the composite region in the window privates */
594	pWinPriv->hRgn = hRgn;
595	}
596
597	RegionUninit(&rrNewShape);
598
599	return;
600	}