[deb_xorg-server.git] / mi / micopy.c

/*
 * Copyright © 1998 Keith Packard
 *
 * 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, and that the name of Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif

#include "mi.h"
#include "scrnintstr.h"
#include "gcstruct.h"
#include "pixmap.h"
#include "pixmapstr.h"
#include "windowstr.h"

void
miCopyRegion(DrawablePtr pSrcDrawable,
             DrawablePtr pDstDrawable,
             GCPtr pGC,
             RegionPtr pDstRegion,
             int dx, int dy, miCopyProc copyProc, Pixel bitPlane, void *closure)
{
    int careful;
    Bool reverse;
    Bool upsidedown;
    BoxPtr pbox;
    int nbox;
    BoxPtr pboxNew1, pboxNew2, pboxBase, pboxNext, pboxTmp;

    pbox = RegionRects(pDstRegion);
    nbox = RegionNumRects(pDstRegion);

    /* XXX we have to err on the side of safety when both are windows,
     * because we don't know if IncludeInferiors is being used.
     */
    careful = ((pSrcDrawable == pDstDrawable) ||
               ((pSrcDrawable->type == DRAWABLE_WINDOW) &&
                (pDstDrawable->type == DRAWABLE_WINDOW)));

    pboxNew1 = NULL;
    pboxNew2 = NULL;
    if (careful && dy < 0) {
        upsidedown = TRUE;

        if (nbox > 1) {
            /* keep ordering in each band, reverse order of bands */
            pboxNew1 = (BoxPtr) malloc(sizeof(BoxRec) * nbox);
            if (!pboxNew1)
                return;
            pboxBase = pboxNext = pbox + nbox - 1;
            while (pboxBase >= pbox) {
                while ((pboxNext >= pbox) && (pboxBase->y1 == pboxNext->y1))
                    pboxNext--;
                pboxTmp = pboxNext + 1;
                while (pboxTmp <= pboxBase) {
                    *pboxNew1++ = *pboxTmp++;
                }
                pboxBase = pboxNext;
            }
            pboxNew1 -= nbox;
            pbox = pboxNew1;
        }
    }
    else {
        /* walk source top to bottom */
        upsidedown = FALSE;
    }

    if (careful && dx < 0) {
        /* walk source right to left */
        if (dy <= 0)
            reverse = TRUE;
        else
            reverse = FALSE;

        if (nbox > 1) {
            /* reverse order of rects in each band */
            pboxNew2 = (BoxPtr) malloc(sizeof(BoxRec) * nbox);
            if (!pboxNew2) {
                free(pboxNew1);
                return;
            }
            pboxBase = pboxNext = pbox;
            while (pboxBase < pbox + nbox) {
                while ((pboxNext < pbox + nbox) &&
                       (pboxNext->y1 == pboxBase->y1))
                    pboxNext++;
                pboxTmp = pboxNext;
                while (pboxTmp != pboxBase) {
                    *pboxNew2++ = *--pboxTmp;
                }
                pboxBase = pboxNext;
            }
            pboxNew2 -= nbox;
            pbox = pboxNew2;
        }
    }
    else {
        /* walk source left to right */
        reverse = FALSE;
    }

    (*copyProc) (pSrcDrawable,
                 pDstDrawable,
                 pGC,
                 pbox, nbox, dx, dy, reverse, upsidedown, bitPlane, closure);

    free(pboxNew1);
    free(pboxNew2);
}

RegionPtr
miDoCopy(DrawablePtr pSrcDrawable,
         DrawablePtr pDstDrawable,
         GCPtr pGC,
         int xIn,
         int yIn,
         int widthSrc,
         int heightSrc,
         int xOut, int yOut, miCopyProc copyProc, Pixel bitPlane, void *closure)
{
    RegionPtr prgnSrcClip = NULL;       /* may be a new region, or just a copy */
    Bool freeSrcClip = FALSE;
    RegionPtr prgnExposed = NULL;
    RegionRec rgnDst;
    int dx;
    int dy;
    int numRects;
    int box_x1;
    int box_y1;
    int box_x2;
    int box_y2;
    Bool fastSrc = FALSE;       /* for fast clipping with pixmap source */
    Bool fastDst = FALSE;       /* for fast clipping with one rect dest */
    Bool fastExpose = FALSE;    /* for fast exposures with pixmap source */

    /* Short cut for unmapped windows */

    if (pDstDrawable->type == DRAWABLE_WINDOW &&
        !((WindowPtr) pDstDrawable)->realized) {
        return NULL;
    }

    if (pSrcDrawable->pScreen->SourceValidate) {
        (*pSrcDrawable->pScreen->SourceValidate) (pSrcDrawable, xIn, yIn,
                                                  widthSrc, heightSrc,
                                                  pGC->subWindowMode);
    }

    /* Compute source clip region */
    if (pSrcDrawable->type == DRAWABLE_PIXMAP) {
        if ((pSrcDrawable == pDstDrawable) && (pGC->clientClipType == CT_NONE))
            prgnSrcClip = miGetCompositeClip(pGC);
        else
            fastSrc = TRUE;
    }
    else {
        if (pGC->subWindowMode == IncludeInferiors) {
            /*
             * XFree86 DDX empties the border clip when the
             * VT is inactive, make sure the region isn't empty
             */
            if (!((WindowPtr) pSrcDrawable)->parent &&
                RegionNotEmpty(&((WindowPtr) pSrcDrawable)->borderClip)) {
                /*
                 * special case bitblt from root window in
                 * IncludeInferiors mode; just like from a pixmap
                 */
                fastSrc = TRUE;
            }
            else if ((pSrcDrawable == pDstDrawable) &&
                     (pGC->clientClipType == CT_NONE)) {
                prgnSrcClip = miGetCompositeClip(pGC);
            }
            else {
                prgnSrcClip = NotClippedByChildren((WindowPtr) pSrcDrawable);
                freeSrcClip = TRUE;
            }
        }
        else {
            prgnSrcClip = &((WindowPtr) pSrcDrawable)->clipList;
        }
    }

    xIn += pSrcDrawable->x;
    yIn += pSrcDrawable->y;

    xOut += pDstDrawable->x;
    yOut += pDstDrawable->y;

    box_x1 = xIn;
    box_y1 = yIn;
    box_x2 = xIn + widthSrc;
    box_y2 = yIn + heightSrc;

    dx = xIn - xOut;
    dy = yIn - yOut;

    /* Don't create a source region if we are doing a fast clip */
    if (fastSrc) {
        RegionPtr cclip;

        fastExpose = TRUE;
        /*
         * clip the source; if regions extend beyond the source size,
         * make sure exposure events get sent
         */
        if (box_x1 < pSrcDrawable->x) {
            box_x1 = pSrcDrawable->x;
            fastExpose = FALSE;
        }
        if (box_y1 < pSrcDrawable->y) {
            box_y1 = pSrcDrawable->y;
            fastExpose = FALSE;
        }
        if (box_x2 > pSrcDrawable->x + (int) pSrcDrawable->width) {
            box_x2 = pSrcDrawable->x + (int) pSrcDrawable->width;
            fastExpose = FALSE;
        }
        if (box_y2 > pSrcDrawable->y + (int) pSrcDrawable->height) {
            box_y2 = pSrcDrawable->y + (int) pSrcDrawable->height;
            fastExpose = FALSE;
        }

        /* Translate and clip the dst to the destination composite clip */
        box_x1 -= dx;
        box_x2 -= dx;
        box_y1 -= dy;
        box_y2 -= dy;

        /* If the destination composite clip is one rectangle we can
           do the clip directly.  Otherwise we have to create a full
           blown region and call intersect */

        cclip = miGetCompositeClip(pGC);
        if (RegionNumRects(cclip) == 1) {
            BoxPtr pBox = RegionRects(cclip);

            if (box_x1 < pBox->x1)
                box_x1 = pBox->x1;
            if (box_x2 > pBox->x2)
                box_x2 = pBox->x2;
            if (box_y1 < pBox->y1)
                box_y1 = pBox->y1;
            if (box_y2 > pBox->y2)
                box_y2 = pBox->y2;
            fastDst = TRUE;
        }
    }

    /* Check to see if the region is empty */
    if (box_x1 >= box_x2 || box_y1 >= box_y2) {
        RegionNull(&rgnDst);
    }
    else {
        BoxRec box;

        box.x1 = box_x1;
        box.y1 = box_y1;
        box.x2 = box_x2;
        box.y2 = box_y2;
        RegionInit(&rgnDst, &box, 1);
    }

    /* Clip against complex source if needed */
    if (!fastSrc) {
        RegionIntersect(&rgnDst, &rgnDst, prgnSrcClip);
        RegionTranslate(&rgnDst, -dx, -dy);
    }

    /* Clip against complex dest if needed */
    if (!fastDst) {
        RegionIntersect(&rgnDst, &rgnDst, miGetCompositeClip(pGC));
    }

    /* Do bit blitting */
    numRects = RegionNumRects(&rgnDst);
    if (numRects && widthSrc && heightSrc)
        miCopyRegion(pSrcDrawable, pDstDrawable, pGC,
                     &rgnDst, dx, dy, copyProc, bitPlane, closure);

    /* Pixmap sources generate a NoExposed (we return NULL to do this) */
    if (!fastExpose && pGC->fExpose)
        prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC,
                                        xIn - pSrcDrawable->x,
                                        yIn - pSrcDrawable->y,
                                        widthSrc, heightSrc,
                                        xOut - pDstDrawable->x,
                                        yOut - pDstDrawable->y,
                                        (unsigned long) bitPlane);
    RegionUninit(&rgnDst);
    if (freeSrcClip)
        RegionDestroy(prgnSrcClip);
    return prgnExposed;
}
Commit	Line	Data
a09e091a JB	1	/*
	2	* Copyright © 1998 Keith Packard
	3	*
	4	* Permission to use, copy, modify, distribute, and sell this software and its
	5	* documentation for any purpose is hereby granted without fee, provided that
	6	* the above copyright notice appear in all copies and that both that
	7	* copyright notice and this permission notice appear in supporting
	8	* documentation, and that the name of Keith Packard not be used in
	9	* advertising or publicity pertaining to distribution of the software without
	10	* specific, written prior permission. Keith Packard makes no
	11	* representations about the suitability of this software for any purpose. It
	12	* is provided "as is" without express or implied warranty.
	13	*
	14	* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	15	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	16	* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	17	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	18	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	19	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	20	* PERFORMANCE OF THIS SOFTWARE.
	21	*/
	22
	23	#ifdef HAVE_DIX_CONFIG_H
	24	#include <dix-config.h>
	25	#endif
	26
	27	#include "mi.h"
	28	#include "scrnintstr.h"
	29	#include "gcstruct.h"
	30	#include "pixmap.h"
	31	#include "pixmapstr.h"
	32	#include "windowstr.h"
	33
	34	void
	35	miCopyRegion(DrawablePtr pSrcDrawable,
	36	DrawablePtr pDstDrawable,
	37	GCPtr pGC,
	38	RegionPtr pDstRegion,
	39	int dx, int dy, miCopyProc copyProc, Pixel bitPlane, void *closure)
	40	{
	41	int careful;
	42	Bool reverse;
	43	Bool upsidedown;
	44	BoxPtr pbox;
	45	int nbox;
	46	BoxPtr pboxNew1, pboxNew2, pboxBase, pboxNext, pboxTmp;
	47
	48	pbox = RegionRects(pDstRegion);
	49	nbox = RegionNumRects(pDstRegion);
	50
	51	/* XXX we have to err on the side of safety when both are windows,
	52	* because we don't know if IncludeInferiors is being used.
	53	*/
	54	careful = ((pSrcDrawable == pDstDrawable) \|\|
	55	((pSrcDrawable->type == DRAWABLE_WINDOW) &&
	56	(pDstDrawable->type == DRAWABLE_WINDOW)));
	57
	58	pboxNew1 = NULL;
	59	pboxNew2 = NULL;
	60	if (careful && dy < 0) {
	61	upsidedown = TRUE;
	62
	63	if (nbox > 1) {
	64	/* keep ordering in each band, reverse order of bands */
65	pboxNew1 = (BoxPtr) malloc(sizeof(BoxRec) * nbox);
66	if (!pboxNew1)
67	return;
68	pboxBase = pboxNext = pbox + nbox - 1;
69	while (pboxBase >= pbox) {
70	while ((pboxNext >= pbox) && (pboxBase->y1 == pboxNext->y1))
71	pboxNext--;
72	pboxTmp = pboxNext + 1;
73	while (pboxTmp <= pboxBase) {
74	pboxNew1++ = pboxTmp++;
75	}
76	pboxBase = pboxNext;
77	}
78	pboxNew1 -= nbox;
79	pbox = pboxNew1;
80	}
81	}
82	else {
83	/* walk source top to bottom */
84	upsidedown = FALSE;
85	}
86
87	if (careful && dx < 0) {
88	/* walk source right to left */
89	if (dy <= 0)
90	reverse = TRUE;
91	else
92	reverse = FALSE;
93
94	if (nbox > 1) {
95	/* reverse order of rects in each band */
96	pboxNew2 = (BoxPtr) malloc(sizeof(BoxRec) * nbox);
97	if (!pboxNew2) {
98	free(pboxNew1);
99	return;
100	}
101	pboxBase = pboxNext = pbox;
102	while (pboxBase < pbox + nbox) {
103	while ((pboxNext < pbox + nbox) &&
104	(pboxNext->y1 == pboxBase->y1))
105	pboxNext++;
106	pboxTmp = pboxNext;
107	while (pboxTmp != pboxBase) {
108	pboxNew2++ = --pboxTmp;
109	}
110	pboxBase = pboxNext;
111	}
112	pboxNew2 -= nbox;
113	pbox = pboxNew2;
114	}
115	}
116	else {
117	/* walk source left to right */
118	reverse = FALSE;
119	}
120
121	(*copyProc) (pSrcDrawable,
122	pDstDrawable,
123	pGC,
124	pbox, nbox, dx, dy, reverse, upsidedown, bitPlane, closure);
125
126	free(pboxNew1);
127	free(pboxNew2);
128	}
129
130	RegionPtr
131	miDoCopy(DrawablePtr pSrcDrawable,
132	DrawablePtr pDstDrawable,
133	GCPtr pGC,
134	int xIn,
135	int yIn,
136	int widthSrc,
137	int heightSrc,
138	int xOut, int yOut, miCopyProc copyProc, Pixel bitPlane, void *closure)
139	{
140	RegionPtr prgnSrcClip = NULL; /* may be a new region, or just a copy */
141	Bool freeSrcClip = FALSE;
142	RegionPtr prgnExposed = NULL;
143	RegionRec rgnDst;
144	int dx;
145	int dy;
146	int numRects;
147	int box_x1;
148	int box_y1;
149	int box_x2;
150	int box_y2;
151	Bool fastSrc = FALSE; /* for fast clipping with pixmap source */
152	Bool fastDst = FALSE; /* for fast clipping with one rect dest */
153	Bool fastExpose = FALSE; /* for fast exposures with pixmap source */
154
155	/* Short cut for unmapped windows */
156
157	if (pDstDrawable->type == DRAWABLE_WINDOW &&
158	!((WindowPtr) pDstDrawable)->realized) {
159	return NULL;
160	}
161
162	if (pSrcDrawable->pScreen->SourceValidate) {
163	(*pSrcDrawable->pScreen->SourceValidate) (pSrcDrawable, xIn, yIn,
164	widthSrc, heightSrc,
165	pGC->subWindowMode);
166	}
167
168	/* Compute source clip region */
169	if (pSrcDrawable->type == DRAWABLE_PIXMAP) {
170	if ((pSrcDrawable == pDstDrawable) && (pGC->clientClipType == CT_NONE))
171	prgnSrcClip = miGetCompositeClip(pGC);
172	else
173	fastSrc = TRUE;
174	}
175	else {
176	if (pGC->subWindowMode == IncludeInferiors) {
177	/*
178	* XFree86 DDX empties the border clip when the
179	* VT is inactive, make sure the region isn't empty
180	*/
181	if (!((WindowPtr) pSrcDrawable)->parent &&
182	RegionNotEmpty(&((WindowPtr) pSrcDrawable)->borderClip)) {
183	/*
184	* special case bitblt from root window in
185	* IncludeInferiors mode; just like from a pixmap
186	*/
187	fastSrc = TRUE;
188	}
189	else if ((pSrcDrawable == pDstDrawable) &&
190	(pGC->clientClipType == CT_NONE)) {
191	prgnSrcClip = miGetCompositeClip(pGC);
192	}
193	else {
194	prgnSrcClip = NotClippedByChildren((WindowPtr) pSrcDrawable);
195	freeSrcClip = TRUE;
196	}
197	}
198	else {
199	prgnSrcClip = &((WindowPtr) pSrcDrawable)->clipList;
200	}
201	}
202
203	xIn += pSrcDrawable->x;
204	yIn += pSrcDrawable->y;
205
206	xOut += pDstDrawable->x;
207	yOut += pDstDrawable->y;
208
209	box_x1 = xIn;
210	box_y1 = yIn;
211	box_x2 = xIn + widthSrc;
212	box_y2 = yIn + heightSrc;
213
214	dx = xIn - xOut;
215	dy = yIn - yOut;
216
217	/* Don't create a source region if we are doing a fast clip */
218	if (fastSrc) {
219	RegionPtr cclip;
220
221	fastExpose = TRUE;
222	/*
223	* clip the source; if regions extend beyond the source size,
224	* make sure exposure events get sent
225	*/
226	if (box_x1 < pSrcDrawable->x) {
227	box_x1 = pSrcDrawable->x;
228	fastExpose = FALSE;
229	}
230	if (box_y1 < pSrcDrawable->y) {
231	box_y1 = pSrcDrawable->y;
232	fastExpose = FALSE;
233	}
234	if (box_x2 > pSrcDrawable->x + (int) pSrcDrawable->width) {
235	box_x2 = pSrcDrawable->x + (int) pSrcDrawable->width;
236	fastExpose = FALSE;
237	}
238	if (box_y2 > pSrcDrawable->y + (int) pSrcDrawable->height) {
239	box_y2 = pSrcDrawable->y + (int) pSrcDrawable->height;
240	fastExpose = FALSE;
241	}
242
243	/* Translate and clip the dst to the destination composite clip */
244	box_x1 -= dx;
245	box_x2 -= dx;
246	box_y1 -= dy;
247	box_y2 -= dy;
248
249	/* If the destination composite clip is one rectangle we can
250	do the clip directly. Otherwise we have to create a full
251	blown region and call intersect */
252
253	cclip = miGetCompositeClip(pGC);
254	if (RegionNumRects(cclip) == 1) {
255	BoxPtr pBox = RegionRects(cclip);
256
257	if (box_x1 < pBox->x1)
258	box_x1 = pBox->x1;
259	if (box_x2 > pBox->x2)
260	box_x2 = pBox->x2;
261	if (box_y1 < pBox->y1)
262	box_y1 = pBox->y1;
263	if (box_y2 > pBox->y2)
264	box_y2 = pBox->y2;
265	fastDst = TRUE;
266	}
267	}
268
269	/* Check to see if the region is empty */
270	if (box_x1 >= box_x2 \|\| box_y1 >= box_y2) {
271	RegionNull(&rgnDst);
272	}
273	else {
274	BoxRec box;
275
276	box.x1 = box_x1;
277	box.y1 = box_y1;
278	box.x2 = box_x2;
279	box.y2 = box_y2;
280	RegionInit(&rgnDst, &box, 1);
281	}
282
283	/* Clip against complex source if needed */
284	if (!fastSrc) {
285	RegionIntersect(&rgnDst, &rgnDst, prgnSrcClip);
286	RegionTranslate(&rgnDst, -dx, -dy);
287	}
288
289	/* Clip against complex dest if needed */
290	if (!fastDst) {
291	RegionIntersect(&rgnDst, &rgnDst, miGetCompositeClip(pGC));
292	}
293
294	/* Do bit blitting */
295	numRects = RegionNumRects(&rgnDst);
296	if (numRects && widthSrc && heightSrc)
297	miCopyRegion(pSrcDrawable, pDstDrawable, pGC,
298	&rgnDst, dx, dy, copyProc, bitPlane, closure);
299
300	/* Pixmap sources generate a NoExposed (we return NULL to do this) */
301	if (!fastExpose && pGC->fExpose)
302	prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC,
303	xIn - pSrcDrawable->x,
304	yIn - pSrcDrawable->y,
305	widthSrc, heightSrc,
306	xOut - pDstDrawable->x,
307	yOut - pDstDrawable->y,
308	(unsigned long) bitPlane);
309	RegionUninit(&rgnDst);
310	if (freeSrcClip)
311	RegionDestroy(prgnSrcClip);
312	return prgnExposed;
313	}