composite/Makefile.am

@@ -9,6 +9,7 @@ endif
 libcomposite_la_SOURCES = 	\
 	compalloc.c		\
 	compext.c		\
+	compevent.c		\
 	compint.h		\
 	compinit.c		\
 	compoverlay.c		\

composite/compalloc.c

@@ -605,8 +605,8 @@ compAllocPixmap(WindowPtr pWin)
     int bw = (int) pWin->borderWidth;
     int x = pWin->drawable.x - bw;
     int y = pWin->drawable.y - bw;
-    int w = pWin->drawable.width + (bw << 1);
-    int h = pWin->drawable.height + (bw << 1);
+    int w = OwnerWindowWidth(pWin) + (bw << 1);
+    int h = OwnerWindowHeight(pWin) + (bw << 1);
     PixmapPtr pPixmap = compNewPixmap(pWin, x, y, w, h);
     CompWindowPtr cw = GetCompWindow(pWin);
 

composite/compevent.c

+/*
+ * Copyright © 2018 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 the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS 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 "compint.h"
+
+static void
+compEventSwap(xGenericEvent *from, xGenericEvent *to)
+{
+    *to = *from;
+    swaps(&to->sequenceNumber);
+    swapl(&to->length);
+    swaps(&to->evtype);
+    switch (from->evtype) {
+    case CompositePixmapNotify: {
+        xCompositePixmapNotify *c = (xCompositePixmapNotify *) to;
+
+        swapl(&c->window);
+        swaps(&c->windowWidth);
+        swaps(&c->windowHeight);
+        swaps(&c->pixmapWidth);
+        swaps(&c->pixmapHeight);
+        break;
+    }
+    case CompositeOwnerWindowSizeNotify:
+    {
+        xCompositeOwnerWindowSizeNotify *c = (xCompositeOwnerWindowSizeNotify *) to;
+        swapl(&c->window);
+        swaps(&c->windowWidth);
+        swaps(&c->windowHeight);
+        swaps(&c->ownerWidth);
+        swaps(&c->ownerHeight);
+        break;
+    }
+    }
+}
+
+static void
+compDeliverEvents(WindowPtr pWin, CompEventWindowPtr *head, xEvent *event, CARD32 mask)
+{
+    CompEventWindowPtr  cew;
+
+    for (cew = *head; cew; cew = cew->next) {
+        if (cew->eventMask & mask)
+            WriteEventsToClient(clients[CLIENT_ID(cew->id)], 1, event);
+    }
+}
+
+void
+compSendPixmapNotify(WindowPtr pWin, PixmapPtr pPix)
+{
+    CompEventWindowPtr  *head = GetCompEventWindowHead(pWin);
+
+    if (*head) {
+        xCompositePixmapNotify pn = {
+            .type = GenericEvent,
+            .extension = CompositeReqCode,
+            .length = (sizeof(xCompositePixmapNotify) - 32) >> 2,
+            .evtype = CompositePixmapNotify,
+            .window = pWin->drawable.id,
+            .windowWidth = pWin->drawable.width,
+            .windowHeight = pWin->drawable.height,
+            .pixmapWidth = pPix ? pPix->drawable.width : 0,
+            .pixmapHeight = pPix ? pPix->drawable.height : 0,
+        };
+
+        compDeliverEvents(pWin, head, (xEvent *) &pn, CompositePixmapNotifyMask);
+    }
+}
+
+void
+compSendOwnerWindowSizeNotify(WindowPtr pWin)
+{
+    CompEventWindowPtr  *head = GetCompEventWindowHead(pWin);
+
+    if (*head) {
+        xCompositeOwnerWindowSizeNotify pn = {
+            .type = GenericEvent,
+            .extension = CompositeReqCode,
+            .length = (sizeof(xCompositeOwnerWindowSizeNotify) - 32) >> 2,
+            .evtype = CompositeOwnerWindowSizeNotify,
+            .window = pWin->drawable.id,
+            .windowWidth = pWin->drawable.width,
+            .windowHeight = pWin->drawable.height,
+            .ownerWidth = wOwnerWidth(pWin),
+            .ownerHeight = wOwnerHeight(pWin),
+        };
+
+        compDeliverEvents(pWin, head, (xEvent *) &pn, CompositeOwnerWindowSizeNotifyMask);
+    }
+}
+
+void
+compFreeEventWindow(WindowPtr pWin, XID id)
+{
+    CompEventWindowPtr  *next = GetCompEventWindowHead(pWin);
+    CompEventWindowPtr  cew;
+
+    for (cew = *next; cew; cew = *next) {
+        if (cew->id == id) {
+            *next = cew->next;
+            free(cew);
+            return;
+        }
+        next = &cew->next;
+    }
+}
+
+void
+compFreeEvents(WindowPtr pWin)
+{
+    CompEventWindowPtr  *head = GetCompEventWindowHead(pWin);
+
+    while (*head)
+        FreeResource((*head)->id, RT_NONE);
+}
+
+int
+compSelectInput(ClientPtr pClient, WindowPtr pWin, CARD32 event_mask)
+{
+    CompEventWindowPtr  *head = GetCompEventWindowHead(pWin);
+    CompEventWindowPtr  cew;
+
+    for (cew = *head; cew; cew = cew->next)
+        if (pClient->clientAsMask == CLIENT_BITS(cew->id))
+            break;
+
+    if (cew) {
+        if (!event_mask) {
+            FreeResource(cew->id, RT_NONE);
+            return Success;
+        }
+    } else {
+        cew = calloc (1, sizeof (CompEventWindowRec));
+        if (!cew)
+            return BadAlloc;
+        cew->next = *head;
+        *head = cew;
+        cew->id = FakeClientID(pClient->index);
+    }
+    cew->eventMask = event_mask;
+    return Success;
+}
+
+void
+compEventInit(void)
+{
+    GERegisterExtension(CompositeReqCode, compEventSwap);
+}

composite/compext.c

@@ -50,13 +50,14 @@
 #include "protocol-versions.h"
 #include "extinit.h"
 
-static CARD8 CompositeReqCode;
+CARD8 CompositeReqCode;
 static DevPrivateKeyRec CompositeClientPrivateKeyRec;
 
 #define CompositeClientPrivateKey (&CompositeClientPrivateKeyRec)
 RESTYPE CompositeClientWindowType;
 RESTYPE CompositeClientSubwindowsType;
 RESTYPE CompositeClientOverlayType;
+RESTYPE CompositeEventWindowType;
 
 typedef struct _CompositeClient {
     int major_version;
@@ -93,6 +94,15 @@ FreeCompositeClientOverlay(void *value, XID ccwid)
     return Success;
 }
 
+static int
+FreeCompositeEventWindow(void *value, XID cewid)
+{
+    WindowPtr pWin = value;
+
+    compFreeEventWindow(pWin, cewid);
+    return Success;
+}
+
 static int
 ProcCompositeQueryVersion(ClientPtr client)
 {
@@ -354,15 +364,88 @@ ProcCompositeReleaseOverlayWindow(ClientPtr client)
     return Success;
 }
 
+static int
+ProcCompositeSelectInput(ClientPtr client)
+{
+    REQUEST(xCompositeSelectInputReq);
+    WindowPtr pWin;
+
+    REQUEST_SIZE_MATCH(xCompositeSelectInputReq);
+    VERIFY_WINDOW(pWin, stuff->window, client, DixGetAttrAccess);
+
+    if (stuff->eventMask & ~(CompositeAllEvents)) {
+        client->errorValue = stuff->eventMask;
+        return BadValue;
+    }
+
+    return compSelectInput(client, pWin, stuff->eventMask);
+}
+
+static int
+ProcCompositeSetOwnerWindowSize(ClientPtr client)
+{
+    REQUEST(xCompositeSetOwnerWindowSizeReq);
+    WindowPtr pWin;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xCompositeSetOwnerWindowSizeReq);
+    VERIFY_WINDOW(pWin, stuff->window, client, DixGetAttrAccess);
+
+    if (!pWin->parent)
+        return BadMatch;
+
+    if ((stuff->width == 0) != (stuff->height == 0))
+        return BadMatch;
+
+    rc = compSetOwnerSize(pWin, stuff->width, stuff->height, client);
+    if (rc != Success)
+        return rc;
+    return compSendOwnerSizeCoreEvents(pWin);
+}
+
+static int
+ProcCompositeGetOwnerWindowSize(ClientPtr client)
+{
+    REQUEST(xCompositeGetOwnerWindowSizeReq);
+    xCompositeGetOwnerWindowSizeReply rep;
+    WindowPtr pWin;
+
+    REQUEST_SIZE_MATCH(xCompositeGetOwnerWindowSizeReq);
+    VERIFY_WINDOW(pWin, stuff->window, client, DixGetAttrAccess);
+
+    rep = (xCompositeGetOwnerWindowSizeReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .width = wOwnerWidth(pWin),
+        .height = wOwnerHeight(pWin)
+    };
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.width);
+        swaps(&rep.height);
+    }
+
+    WriteToClient(client, sz_xCompositeGetOwnerWindowSizeReply, &rep);
+
+    return Success;
+}
+
 static int (*ProcCompositeVector[CompositeNumberRequests]) (ClientPtr) = {
-ProcCompositeQueryVersion,
-        ProcCompositeRedirectWindow,
-        ProcCompositeRedirectSubwindows,
-        ProcCompositeUnredirectWindow,
-        ProcCompositeUnredirectSubwindows,
-        ProcCompositeCreateRegionFromBorderClip,
-        ProcCompositeNameWindowPixmap,
-        ProcCompositeGetOverlayWindow, ProcCompositeReleaseOverlayWindow,};
+    ProcCompositeQueryVersion,
+    ProcCompositeRedirectWindow,
+    ProcCompositeRedirectSubwindows,
+    ProcCompositeUnredirectWindow,
+    ProcCompositeUnredirectSubwindows,
+    ProcCompositeCreateRegionFromBorderClip,
+    ProcCompositeNameWindowPixmap,
+    ProcCompositeGetOverlayWindow,
+    ProcCompositeReleaseOverlayWindow,
+    ProcCompositeSelectInput,
+    ProcCompositeSetOwnerWindowSize,
+    ProcCompositeGetOwnerWindowSize,
+};
 
 static int
 ProcCompositeDispatch(ClientPtr client)
@@ -477,6 +560,42 @@ SProcCompositeReleaseOverlayWindow(ClientPtr client)
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
+static int _X_COLD
+SProcCompositeSelectInput(ClientPtr client)
+{
+    REQUEST(xCompositeSelectInputReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xCompositeSelectInputReq);
+    swapl(&stuff->window);
+    swapl(&stuff->eventMask);
+    return (*ProcCompositeVector[stuff->compositeReqType]) (client);
+}
+
+static int _X_COLD
+SProcCompositeSetOwnerWindowSize(ClientPtr client)
+{
+    REQUEST(xCompositeSetOwnerWindowSizeReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xCompositeSetOwnerWindowSizeReq);
+    swapl(&stuff->window);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    return (*ProcCompositeVector[stuff->compositeReqType]) (client);
+}
+
+static int _X_COLD
+SProcCompositeGetOwnerWindowSize(ClientPtr client)
+{
+    REQUEST(xCompositeGetOwnerWindowSizeReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xCompositeGetOwnerWindowSizeReq);
+    swapl(&stuff->window);
+    return (*ProcCompositeVector[stuff->compositeReqType]) (client);
+}
+
 static int
 (*SProcCompositeVector[CompositeNumberRequests]) (ClientPtr) = {
     SProcCompositeQueryVersion,
@@ -488,6 +607,9 @@ static int
     SProcCompositeNameWindowPixmap,
     SProcCompositeGetOverlayWindow,
     SProcCompositeReleaseOverlayWindow,
+    SProcCompositeSelectInput,
+    SProcCompositeSetOwnerWindowSize,
+    SProcCompositeGetOwnerWindowSize,
 };
 
 static int _X_COLD
@@ -569,6 +691,11 @@ CompositeExtensionInit(void)
     if (!CompositeClientOverlayType)
         return;
 
+    CompositeEventWindowType = CreateNewResourceType
+        (FreeCompositeEventWindow, "CompositeEventWindow");
+    if (!CompositeEventWindowType)
+        return;
+
     if (!dixRegisterPrivateKey(&CompositeClientPrivateKeyRec, PRIVATE_CLIENT,
                                sizeof(CompositeClientRec)))
         return;
@@ -584,6 +711,8 @@ CompositeExtensionInit(void)
         return;
     CompositeReqCode = (CARD8) extEntry->base;
 
+    compEventInit();
+
     /* Initialization succeeded */
     noCompositeExtension = FALSE;
 }
@@ -904,6 +1033,40 @@ PanoramiXCompositeReleaseOverlayWindow(ClientPtr client)
     return Success;
 }
 
+static int
+PanoramiXCompositeSetOwnerWindowSize(ClientPtr client)
+{
+    PanoramiXRes *win;
+    int rc = 0, j;
+
+    REQUEST(xCompositeSetOwnerWindowSizeReq);
+
+    REQUEST_SIZE_MATCH(xCompositeSetOwnerWindowSizeReq);
+
+    if ((rc = dixLookupResourceByType((void **) &win, stuff->window, XRT_WINDOW,
+                                      client, DixUnknownAccess))) {
+        client->errorValue = stuff->window;
+        return rc;
+    }
+
+    FOR_NSCREENS_FORWARD(j) {
+        stuff->window = win->info[j].id;
+        rc = (*PanoramiXSaveCompositeVector[stuff->compositeReqType]) (client);
+        if (rc != Success)
+            break;
+    }
+
+    return rc;
+}
+
+static int
+PanoramiXCompositeGetOwnerWindowSize(ClientPtr client)
+{
+    REQUEST(xCompositeGetOwnerWindowSizeReq);
+
+    return (*PanoramiXSaveCompositeVector[stuff->compositeReqType]) (client);
+}
+
 void
 PanoramiXCompositeInit(void)
 {
@@ -928,6 +1091,10 @@ PanoramiXCompositeInit(void)
         PanoramiXCompositeGetOverlayWindow;
     ProcCompositeVector[X_CompositeReleaseOverlayWindow] =
         PanoramiXCompositeReleaseOverlayWindow;
+    ProcCompositeVector[X_CompositeSetOwnerWindowSize] =
+        PanoramiXCompositeSetOwnerWindowSize;
+    ProcCompositeVector[X_CompositeGetOwnerWindowSize] =
+        PanoramiXCompositeGetOwnerWindowSize;
 }
 
 void

composite/compinit.c

@@ -51,6 +51,7 @@
 DevPrivateKeyRec CompScreenPrivateKeyRec;
 DevPrivateKeyRec CompWindowPrivateKeyRec;
 DevPrivateKeyRec CompSubwindowsPrivateKeyRec;
+DevPrivateKeyRec CompEventWindowPrivateKeyRec;
 
 static Bool
 compCloseScreen(ScreenPtr pScreen)
@@ -376,6 +377,8 @@ compScreenInit(ScreenPtr pScreen)
         return FALSE;
     if (!dixRegisterPrivateKey(&CompSubwindowsPrivateKeyRec, PRIVATE_WINDOW, 0))
         return FALSE;
+    if (!dixRegisterPrivateKey(&CompEventWindowPrivateKeyRec, PRIVATE_WINDOW, 0))
+        return FALSE;
 
     if (GetCompScreen(pScreen))
         return TRUE;

composite/compint.h

@@ -106,6 +106,12 @@ typedef struct _CompSubwindows {
     CompClientWindowPtr clients;
 } CompSubwindowsRec, *CompSubwindowsPtr;
 
+typedef struct _CompEventWindow {
+    struct _CompEventWindow *next;
+    XID id;
+    CARD32 eventMask;
+} CompEventWindowRec, *CompEventWindowPtr;
+
 #ifndef COMP_INCLUDE_RGB24_VISUAL
 #define COMP_INCLUDE_RGB24_VISUAL 0
 #endif
@@ -172,6 +178,8 @@ typedef struct _CompScreen {
     SourceValidateProcPtr SourceValidate;
 } CompScreenRec, *CompScreenPtr;
 
+extern CARD8 CompositeReqCode;
+
 extern DevPrivateKeyRec CompScreenPrivateKeyRec;
 
 #define CompScreenPrivateKey (&CompScreenPrivateKeyRec)
@@ -184,12 +192,18 @@ extern DevPrivateKeyRec CompSubwindowsPrivateKeyRec;
 
 #define CompSubwindowsPrivateKey (&CompSubwindowsPrivateKeyRec)
 
+extern DevPrivateKeyRec CompEventWindowPrivateKeyRec;
+
+#define CompEventWindowPrivateKey (&CompEventWindowPrivateKeyRec)
+
 #define GetCompScreen(s) ((CompScreenPtr) \
     dixLookupPrivate(&(s)->devPrivates, CompScreenPrivateKey))
 #define GetCompWindow(w) ((CompWindowPtr) \
     dixLookupPrivate(&(w)->devPrivates, CompWindowPrivateKey))
 #define GetCompSubwindows(w) ((CompSubwindowsPtr) \
     dixLookupPrivate(&(w)->devPrivates, CompSubwindowsPrivateKey))
+#define GetCompEventWindowHead(w) ((CompEventWindowPtr *) \
+    dixLookupPrivateAddr(&(w)->devPrivates, CompEventWindowPrivateKey))
 
 extern RESTYPE CompositeClientSubwindowsType;
 extern RESTYPE CompositeClientOverlayType;
@@ -238,6 +252,28 @@ compReallocPixmap(WindowPtr pWin, int x, int y,
 
 void compMarkAncestors(WindowPtr pWin);
 
+/*
+ * compevent.c
+ */
+
+void
+compSendPixmapNotify(WindowPtr pWin, PixmapPtr pPix);
+
+void
+compSendOwnerWindowSizeNotify(WindowPtr pWin);
+
+void
+compFreeEventWindow(WindowPtr pWin, XID id);
+
+void
+compFreeEvents(WindowPtr pWin);
+
+int
+compSelectInput(ClientPtr pClient, WindowPtr pWin, CARD32 event_mask);
+
+void
+compEventInit(void);
+
 /*
  * compinit.c
  */
@@ -336,6 +372,12 @@ int
 compConfigNotify(WindowPtr pWin, int x, int y, int w, int h,
                  int bw, WindowPtr pSib);
 
+int
+compSetOwnerSize(WindowPtr pWin, CARD16 ownerWidth, CARD16 ownerHeight, ClientPtr client);
+
+int
+compSendOwnerSizeCoreEvents(WindowPtr pWin);
+
 void PanoramiXCompositeInit(void);
 void PanoramiXCompositeReset(void);
 

composite/compwindow.c

@@ -120,6 +120,9 @@ compSetPixmapVisitWindow(WindowPtr pWindow, void *data)
     if (pWindow != pVisit->pWindow && pWindow->redirectDraw != RedirectDrawNone)
         return WT_DONTWALKCHILDREN;
     (*pScreen->SetWindowPixmap) (pWindow, pVisit->pPixmap);
+
+    compSendPixmapNotify(pWindow, pVisit->pPixmap);
+
     /*
      * Recompute winSize and borderSize.  This is duplicate effort
      * when resizing pixmaps, but necessary when changing redirection.
@@ -604,6 +607,8 @@ compDestroyWindow(WindowPtr pWin)
     while ((csw = GetCompSubwindows(pWin)))
         FreeResource(csw->clients->id, RT_NONE);
 
+    compFreeEvents(pWin);
+
     if (pWin->redirectDraw != RedirectDrawNone) {
         PixmapPtr pPixmap = (*pScreen->GetWindowPixmap) (pWin);
 
@@ -617,6 +622,56 @@ compDestroyWindow(WindowPtr pWin)
     return ret;
 }
 
+static Bool
+compScaleBox(BoxPtr pBox, double xscale, double yscale)
+{
+    pBox->x1 = floor((pBox->x1 - 0.5) * xscale);
+    pBox->x2 = ceil ((pBox->x2 + 0.5) * xscale);
+    pBox->y1 = floor((pBox->y1 - 0.5) * yscale);
+    pBox->y2 = ceil ((pBox->y2 + 0.5) * yscale);
+    assert (pBox->x1 <= pBox->x2 && pBox->y1 <= pBox->y2);
+    return pBox->x1 < pBox->x2 && pBox->y1 < pBox->y2;
+}
+
+static void
+compScaleRegion(RegionPtr pRegion, double xscale, double yscale)
+{
+    if (!compScaleBox(&pRegion->extents, xscale, yscale)) {
+        RegionEmpty(pRegion);
+        return;
+    }
+    if (pRegion->data != NULL)
+    {
+        BoxPtr pBox = RegionRects(pRegion);
+        int nBox = RegionNumRects(pRegion);
+        Bool overlap;
+
+        while (nBox--) {
+            if (compScaleBox(pBox, xscale, yscale))
+                pBox++;
+            else {
+                memmove(pBox, pBox + 1, nBox * sizeof (*pBox));
+                if (--pRegion->data->numRects == 0) {
+                    break;
+                }
+            }
+        }
+        switch (pRegion->data->numRects) {
+        case 0:
+            RegionEmpty(pRegion);
+            break;
+        case 1:
+            pRegion->extents = RegionRects(pRegion)[0];
+            RegionUninit(pRegion);
+            break;
+        default:
+            pRegion->extents = (BoxRec) { 0, 0, 0, 0 };
+            RegionValidate(pRegion, &overlap);
+            break;
+        }
+    }
+}
+
 void
 compSetRedirectBorderClip(WindowPtr pWin, RegionPtr pRegion)
 {
@@ -637,6 +692,13 @@ compSetRedirectBorderClip(WindowPtr pWin, RegionPtr pRegion)
     /*
      * Report that as damaged so it will be redrawn
      */
+    if (RegionNotEmpty(&damage) && wOwnerSized(pWin)) {
+        RegionTranslate(&damage, -pWin->drawable.x, -pWin->drawable.y);
+        compScaleRegion(&damage,
+                        (double) wOwnerWidth(pWin) / (double) pWin->drawable.width,
+                        (double) wOwnerHeight(pWin) / (double) pWin->drawable.height);
+        RegionTranslate(&damage, pWin->drawable.x, pWin->drawable.y);
+    }
     DamageDamageRegion(&pWin->drawable, &damage);
     RegionUninit(&damage);
     /*
@@ -665,6 +727,8 @@ compWindowUpdateAutomatic(WindowPtr pWin)
     PictFormatPtr pSrcFormat = PictureWindowFormat(pWin);
     PictFormatPtr pDstFormat = PictureWindowFormat(pWin->parent);
     int error;
+    CARD16 width = pSrcPixmap->drawable.width;
+    CARD16 height = pSrcPixmap->drawable.height;
     RegionPtr pRegion = DamageRegion(cw->damage);
     PicturePtr pSrcPicture = CreatePicture(0, &pSrcPixmap->drawable,
                                            pSrcFormat,
@@ -678,6 +742,36 @@ compWindowUpdateAutomatic(WindowPtr pWin)
                                            &subwindowMode,
                                            serverClient,
                                            &error);
+    /*
+     * Scale
+     */
+    if (wOwnerSized(pWin)) {
+        CARD16 bw = pWin->borderWidth;
+        CARD16  actualWidth = pWin->drawable.width;
+        CARD16  actualHeight = pWin->drawable.height;
+        CARD16  clientWidth = wOwnerWidth(pWin);
+        CARD16  clientHeight = wOwnerHeight(pWin);
+
+        if (actualWidth != clientWidth || actualHeight != clientHeight) {
+            double              xscale = (double) clientWidth / (double) actualWidth;
+            double              yscale = (double) clientHeight / (double) actualHeight;
+            double              trans_x = (1.0 - xscale) * bw;
+            double              trans_y = (1.0 - yscale) * bw;
+            PictTransform       transform = (PictTransform) {
+                .matrix = {
+                    { pixman_double_to_fixed(xscale), 0, pixman_double_to_fixed(trans_x) },
+                    { 0, pixman_double_to_fixed(yscale), pixman_double_to_fixed(trans_y) },
+                    { 0, 0, pixman_int_to_fixed(1) }
+                }
+            };
+
+            SetPictureTransform(pSrcPicture, &transform);
+            compScaleRegion(pRegion, 1.0/xscale, 1.0/yscale);
+            width = pWin->drawable.width + bw * 2;
+            height = pWin->drawable.height + bw * 2;
+            SetPictureFilter(pSrcPicture, FilterBilinear, -1, NULL, 0);
+        }
+    }
 
     /*
      * First move the region from window to screen coordinates
@@ -707,7 +801,7 @@ compWindowUpdateAutomatic(WindowPtr pWin)
                      0, 0,      /* msk_x, msk_y */
                      pSrcPixmap->screen_x - pParent->drawable.x,
                      pSrcPixmap->screen_y - pParent->drawable.y,
-                     pSrcPixmap->drawable.width, pSrcPixmap->drawable.height);
+                     width, height);
     FreePicture(pSrcPicture, 0);
     FreePicture(pDstPicture, 0);
     /*
@@ -807,9 +901,111 @@ compConfigNotify(WindowPtr pWin, int x, int y, int w, int h,
 
     draw_x = pParent->drawable.x + x + bw;
     draw_y = pParent->drawable.y + y + bw;
+
+    if (wOwnerSized(pWin)) {
+        w = wOwnerWidth(pWin);
+        h = wOwnerHeight(pWin);
+    }
+
     alloc_ret = compReallocPixmap(pWin, draw_x, draw_y, w, h, bw);
 
     if (alloc_ret == FALSE)
         return BadAlloc;
     return Success;
 }
+
+#define SubSend(pWin) \
+    ((pWin->eventMask|wOtherEventMasks(pWin)) & SubstructureNotifyMask)
+
+#define StrSend(pWin) \
+    ((pWin->eventMask|wOtherEventMasks(pWin)) & StructureNotifyMask)
+
+#define SubStrSend(pWin,pParent) (StrSend(pWin) || SubSend(pParent))
+
+int
+compSetOwnerSize(WindowPtr pWin, CARD16 ownerWidth, CARD16 ownerHeight, ClientPtr client)
+{
+    Bool wasSet = wOwnerSized(pWin);
+
+    if (pWin->optional || ownerWidth != 0 || ownerHeight != 0) {
+        if (!pWin->optional && !MakeWindowOptional(pWin))
+            return BadAlloc;
+        pWin->optional->ownerWidth = ownerWidth;
+        pWin->optional->ownerHeight = ownerHeight;
+        CheckWindowOptionalNeed(pWin);
+    }
+
+    if (!wasSet) {
+        /* Redirect if we're going from un-set to set */
+        if (wOwnerSized(pWin))
+            compRedirectWindow(serverClient, pWin, CompositeRedirectAutomatic);
+    } else {
+        /* Unredirect if we're going from set to unset */
+        if (!wOwnerSized(pWin))
+            compUnredirectWindow(serverClient, pWin, CompositeRedirectAutomatic);
+    }
+
+    compSendOwnerWindowSizeNotify(pWin);
+
+    return Success;
+}
+
+int
+compSendOwnerSizeCoreEvents(WindowPtr pWin)
+{
+    WindowPtr pParent = pWin->parent;
+    WindowPtr pSib = pWin->nextSib;
+    INT16 x, y;
+    CARD16 bw = pWin->borderWidth;
+    CARD16 w = pWin->drawable.width, h = pWin->drawable.height;
+
+    if (pParent) {
+        x = pWin->drawable.x - pParent->drawable.x - (int) bw;
+        y = pWin->drawable.y - pParent->drawable.y - (int) bw;
+    }
+    else {
+        x = pWin->drawable.x;
+        y = pWin->drawable.y;
+    }
+
+    if (pWin->drawable.pScreen->ConfigNotify) {
+        int ret;
+
+        ret =
+            (*pWin->drawable.pScreen->ConfigNotify) (pWin, x, y, w, h, bw,
+                                                     pSib);
+        if (ret) {
+            return ret;
+        }
+    }
+
+    /* Tell the owner (and everyone else too, what the heck) about the
+     * size. Note that the size will be rewritten as the event is
+     * delivered to be the owner size when sending the event to the
+     * owner
+     */
+
+    if (SubStrSend(pWin, pParent)) {
+
+        xEvent event = {
+            .u.configureNotify.window = pWin->drawable.id,
+            .u.configureNotify.aboveSibling = pSib ? pSib->drawable.id : None,
+            .u.configureNotify.x = x,
+            .u.configureNotify.y = y,
+            .u.configureNotify.width = w,
+            .u.configureNotify.height = h,
+            .u.configureNotify.borderWidth = bw,
+            .u.configureNotify.override = pWin->overrideRedirect
+        };
+        event.u.u.type = ConfigureNotify;
+#ifdef PANORAMIX
+        if (!noPanoramiXExtension && (!pParent || !pParent->parent)) {
+            event.u.configureNotify.x += screenInfo.screens[0]->x;
+            event.u.configureNotify.y += screenInfo.screens[0]->y;
+        }
+#endif
+        DeliverEvents(pWin, &event, 1, NullWindow);
+    }
+    (*pWin->drawable.pScreen->ResizeWindow) (pWin, x, y, w, h, pSib);
+    return Success;
+}

composite/meson.build

 srcs_composite = [
 	'compalloc.c',
 	'compext.c',
+	'compevent.c',
 	'compinit.c',
 	'compoverlay.c',
 	'compwindow.c',

dix/dispatch.c

@@ -963,6 +963,11 @@ GetGeometry(ClientPtr client, xGetGeometryReply * rep)
         rep->x = pWin->origin.x - wBorderWidth(pWin);
         rep->y = pWin->origin.y - wBorderWidth(pWin);
         rep->borderWidth = pWin->borderWidth;
+
+        if (wOwnerSized(pWin) && client->clientAsMask == CLIENT_BITS(pWin->drawable.id)) {
+            rep->width = wOwnerWidth(pWin);
+            rep->height = wOwnerHeight(pWin);
+        }
     }
     else {                      /* DRAWABLE_PIXMAP */
 

dix/events.c

@@ -171,6 +171,8 @@ Equipment Corporation.
 #define LastEventMask OwnerGrabButtonMask
 #define AllEventMasks (LastEventMask|(LastEventMask-1))
 
+#define SEND_EVENT_BIT 0x80
+
 /* @return the core event type or 0 if the event is not a core event */
 static inline int
 core_get_type(const xEvent *event)
@@ -2075,7 +2077,7 @@ ActivateImplicitGrab(DeviceIntPtr dev, ClientPtr client, WindowPtr win,
 /**
  * Attempt event delivery to the client owning the window.
  */
-static enum EventDeliveryState
+enum EventDeliveryState
 DeliverToWindowOwner(DeviceIntPtr dev, WindowPtr win,
                      xEvent *events, int count, Mask filter, GrabPtr grab)
 {
@@ -2250,9 +2252,25 @@ DeliverEventsToWindow(DeviceIntPtr pDev, WindowPtr pWin, xEvent
     /* Deliver to window owner */
     if ((filter == CantBeFiltered) || core_get_type(pEvents) != 0) {
         enum EventDeliveryState rc;
+        CARD16 saveWidth = 0, saveHeight = 0;
+
+        if (filter == StructureNotifyMask &&
+            (pEvents->u.u.type & ~(SEND_EVENT_BIT)) == ConfigureNotify &&
+            wOwnerSized(pWin))
+        {
+            saveWidth = pEvents->u.configureNotify.width;
+            saveHeight = pEvents->u.configureNotify.height;
+            pEvents->u.configureNotify.width = wOwnerWidth(pWin);
+            pEvents->u.configureNotify.height = wOwnerHeight(pWin);
+        }
 
         rc = DeliverToWindowOwner(pDev, pWin, pEvents, count, filter, grab);
 
+        if (saveWidth != 0) {
+            pEvents->u.configureNotify.width = saveWidth;
+            pEvents->u.configureNotify.height = saveHeight;
+        }
+
         switch (rc) {
         case EVENT_SKIP:
             return 0;
@@ -2496,6 +2514,43 @@ FindChildForEvent(SpritePtr pSprite, WindowPtr event)
     return child;
 }
 
+typedef struct {
+    INT16       i_root_x;
+    INT16       i_root_y;
+    FP1616      fp_root_x;
+    FP1616      fp_root_y;
+} EventRootCoordRec, *EventRootCoordPtr;
+
+static void
+SaveEventRootCoord(xEvent *xE, EventRootCoordPtr coord)
+{
+    if (xi2_get_type(xE) != 0) {
+        xXIDeviceEvent *event = (xXIDeviceEvent *) xE;
+        coord->i_root_x = 0;
+        coord->i_root_y = 0;
+        coord->fp_root_x = event->root_x;
+        coord->fp_root_y = event->root_y;
+    } else {
+        coord->i_root_x = XE_KBPTR.rootX;
+        coord->i_root_y = XE_KBPTR.rootY;
+        coord->fp_root_x = 0;
+        coord->fp_root_y = 0;
+    }
+}
+
+static void
+RestoreEventRootCoord(xEvent *xE, EventRootCoordPtr coord)
+{
+    if (xi2_get_type(xE) != 0) {
+        xXIDeviceEvent *event = (xXIDeviceEvent *) xE;
+        event->root_x = coord->fp_root_x;
+        event->root_y = coord->fp_root_y;
+    } else {
+        XE_KBPTR.rootX = coord->i_root_x;
+        XE_KBPTR.rootY = coord->i_root_y;
+    }
+}
+
 /**
  * Adjust event fields to comply with the window properties.
  *
@@ -2544,6 +2599,16 @@ FixUpEventFromWindow(SpritePtr pSprite,
         }
 
         if (pSprite->hot.pScreen == pWin->drawable.pScreen) {
+            double      xd, yd;
+
+            xd = fp1616_to_double(event->root_x);
+            yd = fp1616_to_double(event->root_y);
+
+            ScaleRootCoordinate(pWin, &xd, &yd);
+ 
+            event->root_x = double_to_fp1616(xd);
+            event->root_y = double_to_fp1616(yd);
+
             event->event_x = event->root_x - double_to_fp1616(pWin->drawable.x);
             event->event_y = event->root_y - double_to_fp1616(pWin->drawable.y);
             event->child = child;
@@ -2563,7 +2628,16 @@ FixUpEventFromWindow(SpritePtr pSprite,
     else {
         XE_KBPTR.root = RootWindow(pSprite)->drawable.id;
         XE_KBPTR.event = pWin->drawable.id;
+
         if (pSprite->hot.pScreen == pWin->drawable.pScreen) {
+            double      xd = XE_KBPTR.rootX;
+            double      yd = XE_KBPTR.rootY;
+
+            ScaleRootCoordinate(pWin, &xd, &yd);
+
+            XE_KBPTR.rootX = floor (xd + 0.5);
+            XE_KBPTR.rootY = floor (yd + 0.5);
+
             XE_KBPTR.sameScreen = xTrue;
             XE_KBPTR.child = child;
             XE_KBPTR.eventX = XE_KBPTR.rootX - pWin->drawable.x;
@@ -2644,9 +2718,13 @@ DeliverEvent(DeviceIntPtr dev, xEvent *xE, int count,
     int deliveries = 0;
 
     if (XaceHook(XACE_SEND_ACCESS, NULL, dev, win, xE, count) == Success) {
+        EventRootCoordRec coord;
         filter = GetEventFilter(dev, xE);
+
+        SaveEventRootCoord(xE, &coord);
         FixUpEventFromWindow(pSprite, xE, win, child, FALSE);
         deliveries = DeliverEventsToWindow(dev, win, xE, count, filter, grab);
+        RestoreEventRootCoord(xE, &coord);
     }
 
     return deliveries;
@@ -2882,6 +2960,25 @@ XYToWindow(SpritePtr pSprite, int x, int y)
     return (*pScreen->XYToWindow)(pScreen, pSprite, x, y);
 }
 
+void
+OwnerScaleCoordinate(WindowPtr pWin, double *xd, double *yd)
+{
+    if (wOwnerSized(pWin)) {
+        *xd = (*xd - pWin->drawable.x) * (double) wOwnerWidth(pWin) /
+            (double) pWin->drawable.width + pWin->drawable.x;
+        *yd = (*yd - pWin->drawable.y) * (double) wOwnerHeight(pWin) /
+            (double) pWin->drawable.height + pWin->drawable.y;
+    }
+}
+
+void
+ScaleRootCoordinate(WindowPtr pWin, double *xd, double *yd)
+{
+    if (pWin->parent)
+        ScaleRootCoordinate(pWin->parent, xd, yd);
+    OwnerScaleCoordinate(pWin, xd, yd);
+}
+
 /**
  * Ungrab a currently FocusIn grabbed device and grab the device on the
  * given window. If the win given is the NoneWin, the device is ungrabbed if
@@ -5326,8 +5423,6 @@ CloseDownEvents(void)
     InputEventList = NULL;
 }
 
-#define SEND_EVENT_BIT 0x80
-
 /**
  * Server-side protocol handling for SendEvent request.
  *

dix/window.c

@@ -132,6 +132,7 @@ Equipment Corporation.
 #include "privates.h"
 #include "xace.h"
 #include "exevents.h"
+#include "compint.h"
 
 #include <X11/Xatom.h>          /* must come after server includes */
 
@@ -2209,7 +2210,10 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
     short x, y, beforeX, beforeY;
     unsigned short w = pWin->drawable.width,
         h = pWin->drawable.height, bw = pWin->borderWidth;
+    unsigned short ow = 0;
+    unsigned short oh = 0;
     int rc, action, smode = Above;
+    Bool resize_owner = FALSE;
 
     if ((pWin->drawable.class == InputOnly) && (mask & CWBorderWidth))
         return BadMatch;
@@ -2217,6 +2221,16 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
     if ((mask & CWSibling) && !(mask & CWStackMode))
         return BadMatch;
 
+    /*
+     * If the owner attempts to resize a window with an owner size
+     * set, then redirect that request to one changing the owner size
+     * instead of the current size
+     */
+    if (CLIENT_BITS(pWin->drawable.id) == client->clientAsMask) {
+        ow = wOwnerWidth(pWin);
+        oh = wOwnerHeight(pWin);
+    }
+
     pVlist = vlist;
 
     if (pParent) {
@@ -2239,13 +2253,24 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
     else if (mask & (CWX | CWY | CWWidth | CWHeight)) {
         GET_INT16(CWX, x);
         GET_INT16(CWY, y);
-        GET_CARD16(CWWidth, w);
-        GET_CARD16(CWHeight, h);
-        if (!w || !h) {
-            client->errorValue = 0;
-            return BadValue;
+        if (ow || oh) {
+            GET_CARD16(CWWidth, ow);
+            GET_CARD16(CWHeight, oh);
+            if (!ow || !oh) {
+                client->errorValue = 0;
+                return BadValue;
+            }
+            action = MOVE_WIN;
+            resize_owner = TRUE;
+        } else {
+            GET_CARD16(CWWidth, w);
+            GET_CARD16(CWHeight, h);
+            if (!w || !h) {
+                client->errorValue = 0;
+                return BadValue;
+            }
+            action = RESIZE_WIN;
         }
-        action = RESIZE_WIN;
     }
     tmask = mask & ~ChangeMask;
     while (tmask) {
@@ -2281,6 +2306,11 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
             return BadValue;
         }
     }
+
+    /* Change owner size if requested; there's no redirection for this */
+    if (resize_owner)
+        compSetOwnerSize(pWin, ow, oh, client);
+
     /* root really can't be reconfigured, so just return */
     if (!pParent)
         return Success;
@@ -3023,6 +3053,7 @@ NotClippedByChildren(WindowPtr pWin)
     if (pWin->parent ||
         screenIsSaved != SCREEN_SAVER_ON ||
         !HasSaverWindow(pWin->drawable.pScreen)) {
+        /* XXX wClientSized */
         RegionIntersect(pReg, &pWin->borderClip, &pWin->winSize);
     }
     return pReg;
@@ -3386,6 +3417,10 @@ CheckWindowOptionalNeed(WindowPtr w)
             pNode = pNode->next;
         }
     }
+    if (optional->ownerWidth != 0)
+        return;
+    if (optional->ownerHeight != 0)
+        return;
 
     parentOptional = FindWindowWithOptional(w)->optional;
     if (optional->visual != parentOptional->visual)
@@ -3428,6 +3463,8 @@ MakeWindowOptional(WindowPtr pWin)
     optional->inputShape = NULL;
     optional->inputMasks = NULL;
     optional->deviceCursors = NULL;
+    optional->ownerWidth = 0;
+    optional->ownerHeight = 0;
 
     parentOptional = FindWindowWithOptional(pWin)->optional;
     optional->visual = parentOptional->visual;

include/dix.h

@@ -393,6 +393,10 @@ CheckPassiveGrabsOnWindow(WindowPtr /* pWin */ ,
                           BOOL /* checkCore */ ,
                           BOOL /* activate */ );
 
+extern _X_EXPORT enum EventDeliveryState
+DeliverToWindowOwner(DeviceIntPtr dev, WindowPtr win,
+                     xEvent *events, int count, Mask filter, GrabPtr grab);
+
 extern _X_EXPORT int
 DeliverEventsToWindow(DeviceIntPtr /* pWin */ ,
                       WindowPtr /* pWin */ ,

include/input.h

@@ -607,6 +607,8 @@ void FixUpEventFromWindow(SpritePtr pSprite,
                           xEvent *xE,
                           WindowPtr pWin, Window child, Bool calcChild);
 extern Bool PointInBorderSize(WindowPtr pWin, int x, int y);
+extern void OwnerScaleCoordinate(WindowPtr pWin, double *xd, double *yd);
+extern void ScaleRootCoordinate(WindowPtr pWin, double *xd, double *yd);
 extern WindowPtr XYToWindow(SpritePtr pSprite, int x, int y);
 extern int EventIsDeliverable(DeviceIntPtr dev, int evtype, WindowPtr win);
 extern Bool ActivatePassiveGrab(DeviceIntPtr dev, GrabPtr grab,

include/windowstr.h

@@ -93,6 +93,8 @@ typedef struct _WindowOpt {
     RegionPtr inputShape;       /* default: NULL */
     struct _OtherInputMasks *inputMasks;        /* default: NULL */
     DevCursorList deviceCursors;        /* default: NULL */
+    CARD16 ownerWidth;         /* default: 0 */
+    CARD16 ownerHeight;        /* default: 0 */
 } WindowOptRec, *WindowOptPtr;
 
 #define BackgroundPixel	    2L
@@ -197,9 +199,30 @@ extern _X_EXPORT Mask DontPropagateMasks[];
 #define wBoundingShape(w)	wUseDefault(w, boundingShape, NULL)
 #define wClipShape(w)		wUseDefault(w, clipShape, NULL)
 #define wInputShape(w)          wUseDefault(w, inputShape, NULL)
+#define wOwnerWidth(w)          wUseDefault(w, ownerWidth, 0)
+#define wOwnerHeight(w)         wUseDefault(w, ownerHeight, 0)
+#define wOwnerSized(w)          (wOwnerWidth(w) != 0 && wOwnerHeight(w) != 0)
 #define wClient(w)		(clients[CLIENT_ID((w)->drawable.id)])
 #define wBorderWidth(w)		((int) (w)->borderWidth)
 
+static inline CARD16
+OwnerWindowWidth(WindowPtr pWin)
+{
+    CARD16 width = wOwnerWidth(pWin);
+    if (width)
+        return width;
+    return pWin->drawable.width;
+}
+
+static inline CARD16
+OwnerWindowHeight(WindowPtr pWin)
+{
+    CARD16 height = wOwnerHeight(pWin);
+    if (height)
+        return height;
+    return pWin->drawable.height;
+}
+
 /* true when w needs a border drawn. */
 
 #define HasBorder(w)	((w)->borderWidth || wClipShape(w))

mi/mivaltree.c

@@ -206,6 +206,10 @@ miComputeClips(WindowPtr pParent,
     RegionRec childUnion;
     Bool overlap;
     RegionPtr borderVisible;
+    RegionPtr parentWinSize = &pParent->winSize;
+#ifdef COMPOSITE
+    RegionRec scaleWinSize;
+#endif
 
     /*
      * Figure out the new visibility of this window.
@@ -236,7 +240,24 @@ miComputeClips(WindowPtr pParent,
         if (TreatAsTransparent(pParent))
             RegionEmpty(universe);
         compSetRedirectBorderClip (pParent, universe);
-        RegionCopy(universe, &pParent->borderSize);
+        if (wOwnerSized(pParent)) {
+            BoxRec box;
+            int bw = wBorderWidth(pParent);
+
+            box.x1 = pParent->drawable.x;
+            box.y1 = pParent->drawable.y;
+            box.x2 = pParent->drawable.x + wOwnerWidth(pParent);
+            box.y2 = pParent->drawable.y + wOwnerHeight(pParent);
+            RegionInit(&scaleWinSize, &box, 0);
+            parentWinSize = &scaleWinSize;
+            box.x1 = pParent->drawable.x - bw;
+            box.y1 = pParent->drawable.y - bw;
+            box.x2 = pParent->drawable.x + wOwnerWidth(pParent) + bw;
+            box.y2 = pParent->drawable.y + wOwnerHeight(pParent) + bw;
+            RegionReset(universe, &box);
+        } else {
+            RegionCopy(universe, &pParent->borderSize);
+        }
     }
 #endif
 
@@ -374,10 +395,10 @@ miComputeClips(WindowPtr pParent,
         }
         if (HasParentRelativeBorder(pParent) && (dx || dy))
             RegionSubtract(&pParent->valdata->after.borderExposed,
-                           universe, &pParent->winSize);
+                           universe, parentWinSize);
         else
             RegionSubtract(&pParent->valdata->after.borderExposed,
-                           exposed, &pParent->winSize);
+                           exposed, parentWinSize);
 
         RegionCopy(&pParent->borderClip, universe);
 
@@ -387,7 +408,7 @@ miComputeClips(WindowPtr pParent,
          * border from the universe before proceeding.
          */
 
-        RegionIntersect(universe, universe, &pParent->winSize);
+        RegionIntersect(universe, universe, parentWinSize);
     }
     else
         RegionCopy(&pParent->borderClip, universe);

mi/miwindow.c

@@ -750,25 +750,31 @@ miSpriteTrace(SpritePtr pSprite, int x, int y)
 {
     WindowPtr pWin;
     BoxRec box;
+    int t;
+    double xd = x;
+    double yd = y;
+
+    for (t = 0; t < pSprite->spriteTraceGood; t++)
+        OwnerScaleCoordinate(pSprite->spriteTrace[t], &xd, &yd);
 
     pWin = DeepestSpriteWin(pSprite)->firstChild;
     while (pWin) {
         if ((pWin->mapped) &&
-            (x >= pWin->drawable.x - wBorderWidth(pWin)) &&
-            (x < pWin->drawable.x + (int) pWin->drawable.width +
+            (xd >= pWin->drawable.x - wBorderWidth(pWin)) &&
+            (xd < pWin->drawable.x + (int) pWin->drawable.width +
              wBorderWidth(pWin)) &&
-            (y >= pWin->drawable.y - wBorderWidth(pWin)) &&
-            (y < pWin->drawable.y + (int) pWin->drawable.height +
+            (yd >= pWin->drawable.y - wBorderWidth(pWin)) &&
+            (yd < pWin->drawable.y + (int) pWin->drawable.height +
              wBorderWidth(pWin))
             /* When a window is shaped, a further check
              * is made to see if the point is inside
              * borderSize
              */
-            && (!wBoundingShape(pWin) || PointInBorderSize(pWin, x, y))
+            && (!wBoundingShape(pWin) || PointInBorderSize(pWin, xd, yd))
             && (!wInputShape(pWin) ||
                 RegionContainsPoint(wInputShape(pWin),
-                                    x - pWin->drawable.x,
-                                    y - pWin->drawable.y, &box))
+                                    xd - pWin->drawable.x,
+                                    yd - pWin->drawable.y, &box))
             /* In rootless mode windows may be offscreen, even when
              * they're in X's stack. (E.g. if the native window system
              * implements some form of virtual desktop system).
@@ -780,6 +786,7 @@ miSpriteTrace(SpritePtr pSprite, int x, int y)
                                                     pSprite->spriteTraceSize,
                                                     sizeof(WindowPtr));
             }
+            OwnerScaleCoordinate(pWin, &xd, &yd);
             pSprite->spriteTrace[pSprite->spriteTraceGood++] = pWin;
             pWin = pWin->firstChild;
         }

miext/damage/damage.c

@@ -242,7 +242,7 @@ damageRegionAppend(DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
                 continue;
         }
 
-        DAMAGE_DEBUG(("%s %d x %d +%d +%d (target 0x%lx monitor 0x%lx)\n",
+        DAMAGE_DEBUG(("%s %d x %d +%d +%d (target 0x%x monitor 0x%x)\n",
                       where,
                       pDamageRegion->extents.x2 - pDamageRegion->extents.x1,
                       pDamageRegion->extents.y2 - pDamageRegion->extents.y1,
@@ -1548,6 +1548,8 @@ damageSetWindowPixmap(WindowPtr pWindow, PixmapPtr pPixmap)
         DamagePtr *pPrev = getPixmapDamageRef(pPixmap);
 
         while (pDamage) {
+            RegionEmpty(&pDamage->damage);
+            RegionEmpty(&pDamage->pendingDamage);
             damageInsertDamage(pPrev, pDamage);
             pDamage = pDamage->pNextWin;
         }

present/present_screen.c

@@ -178,8 +178,14 @@ present_config_notify(WindowPtr window,
     int ret;
     ScreenPtr screen = window->drawable.pScreen;
     present_screen_priv_ptr screen_priv = present_screen_priv(screen);
+    int pw = w, ph = h;
 
-    present_send_config_notify(window, x, y, w, h, bw, sibling);
+    if (wOwnerSized(window)) {
+        pw = wOwnerWidth(window);
+        ph = wOwnerHeight(window);
+    }
+
+    present_send_config_notify(window, x, y, pw, ph, bw, sibling);
 
     unwrap(screen_priv, screen, ConfigNotify);
     if (screen->ConfigNotify)

render/filter.c

@@ -194,7 +194,7 @@ PictureSetFilterAlias(ScreenPtr pScreen, const char *filter, const char *alias)
 }
 
 PictFilterPtr
-PictureFindFilter(ScreenPtr pScreen, char *name, int len)
+PictureFindFilter(ScreenPtr pScreen, const char *name, int len)
 {
     PictureScreenPtr ps = GetPictureScreen(pScreen);
     int id = PictureGetFilterId(name, len, FALSE);
@@ -280,7 +280,7 @@ PictureResetFilters(ScreenPtr pScreen)
 }
 
 int
-SetPictureFilter(PicturePtr pPicture, char *name, int len, xFixed * params,
+SetPictureFilter(PicturePtr pPicture, const char *name, int len, xFixed * params,
                  int nparams)
 {
     PictFilterPtr pFilter;

render/picturestr.h

@@ -414,14 +414,14 @@ extern _X_EXPORT void
  PictureResetFilters(ScreenPtr pScreen);
 
 extern _X_EXPORT PictFilterPtr
-PictureFindFilter(ScreenPtr pScreen, char *name, int len);
+PictureFindFilter(ScreenPtr pScreen, const char *name, int len);
 
 extern _X_EXPORT int
 SetPicturePictFilter(PicturePtr pPicture, PictFilterPtr pFilter,
                      xFixed * params, int nparams);
 
 extern _X_EXPORT int
-SetPictureFilter(PicturePtr pPicture, char *name, int len,
+SetPictureFilter(PicturePtr pPicture, const char *name, int len,
                  xFixed * params, int nparams);
 
 extern _X_EXPORT Bool