client通过发送ConfigureWindow请求配置窗口，配置窗口的内容包括窗口位置、窗口尺寸、窗口栈的调整、窗口边框大小等。X11 Server通过ProcConfigureWindow请求，调用ConfigureWindow实现。

根据掩码获取窗口的新坐标，宽高尺寸（CWX | CWY | CWWidth | CWHeight）等。涉及窗口移动和缩放
根据掩码获取窗口边框大小，窗口栈调整位置等
1. CWBorderWidth：调整窗口边框
2. CWStackMode：调整窗口在栈中的位置，包括：TopIf、BottomIf、Opposite、Above、Below等；其中CWSibling可指定相对哪个兄弟窗口的栈位置变化
3. 重定向ConfigureWindow请求至管理客户端，如：窗口管理器等，发送ConfigureRequest事件
4. 重定向窗口缩放至管理客户端，发送ResizeRequest事件
5. 通过回调ConfigNotify函数告知服务端的X11扩展协议窗口配置变化，如：composite等
6. 通过发送ConfigureNotify事件，通知感兴趣的client窗口配置变化
7. 回调ChangeBorderWidth处理边框
8. 回调MoveWindow处理窗口移动
9. 回调ResizeWindow处理窗口缩放
10. 调用ReflectStackChange处理窗口在窗口栈中的位置变化
11. 调用CheckCursorConfinement处理在窗口以及子窗口上的光标

ReflectStackChange

对pWin窗口进行重排，新暴露的窗口的可见区域需要进行重绘。

// 将pWin重排在pSib之上，若pSib为空，则将pWin重排在栈的底部
static void ReflectStackChange(WindowPtr pWin, WindowPtr pSib, VTKind kind){
    Bool WasViewable = (Bool) pWin->viewable;
    Bool anyMarked;
    WindowPtr pFirstChange;
    WindowPtr pLayerWin;
    ScreenPtr pScreen = pWin->drawable.pScreen;
    if (!pWin->parent)
        return;
    // 更新pWin在窗口栈的位置，并计算第一个在栈中重新暴露的窗口：
    // pWin在pNextSib之上（窗口下移），则为pWin->nextSib
    // pWin在pNextSib之下（窗口上移），则为pWin
    pFirstChange = MoveWindowInStack(pWin, pSib);
    if (WasViewable) {
        // 调用miMarkOverlappedWindows，从pFirstChange开始向后遍历其兄弟窗口，标记被pWin重叠的窗口，若存在返回true
        anyMarked = (*pScreen->MarkOverlappedWindows) (pWin, pFirstChange, &pLayerWin);
        if (pLayerWin != pWin)
            pFirstChange = pLayerWin;
        if (anyMarked) {
            // 调用miValidateTree重新计算pWin父窗口及其子窗口的可见区域，并计算待重新绘制区域（需重新显示的区域）
            (*pScreen->ValidateTree) (pLayerWin->parent, pFirstChange, kind);
            // 调用miHandleValidateExposures，深度优先，先绘制边框，再绘制背景，然后发送Expose事件给客户端绘制
            (*pScreen->HandleExposures) (pLayerWin->parent);
            if (pWin->drawable.pScreen->PostValidateTree)
                (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange, kind);
        }
    }
    if (pWin->realized)
        WindowsRestructured();
}

MarkOverlappedWindows

miMarkOverlappedWindows实现了MarkOverlappedWindows回调功能。该函数主要时过滤一批确定不需要重绘的窗口，识别有可能会需重新绘制的窗口，从而减少后续的计算量。在pWin窗口之上兄弟窗口不存在重绘的需求，可以过滤；在pWin窗口之下的窗口有可能会要求重新绘制，如：pWin窗口缩小了，pWin窗口的边框改变了，pWin窗口移动了等。

// pWin为需重排的窗口，pFirst为第一个改变显示的窗口，pWin和pFirst为同一层窗口
// pWin窗口向下移，pFirst为窗口原堆叠层的pWin的下一个相邻窗口（pWin->nextSib），标记与pWin重叠的窗口
// pWin窗口向上移，pFirst为pWin本身窗口，标记被pWin遮挡的窗口
Bool miMarkOverlappedWindows(WindowPtr pWin, WindowPtr pFirst, WindowPtr *ppLayerWin){
    BoxPtr box;
    WindowPtr pChild, pLast;
    Bool anyMarked = FALSE;
    MarkWindowProcPtr MarkWindow = pWin->drawable.pScreen->MarkWindow;
    if (ppLayerWin)
        *ppLayerWin = pWin;

    if (pWin == pFirst) {
        // Blindly mark pWin and all of its inferiors.   This is a slight overkill 
        // if there are mapped windows that outside pWin's border, 
        // but it's better than wasting time on RectIn checks.
        pChild = pWin;
       // 深度优先遍历，初始化该窗口及其子窗口的窗口和边框区域
       // 子窗口的区域限制在pWin的窗口（winSize）区域内
        while (1) {
            if (pChild->viewable) {
                 // 根据窗口的drawable构建winSize区域，该区域限制在父窗口的winSize范围内
                if (RegionBroken(&pChild->winSize))
                    SetWinSize(pChild);
                // 包括窗口边框的区域，该区域限制在父窗口的winSize范围内
                if (RegionBroken(&pChild->borderSize))
                    SetBorderSize(pChild);
                // miMarkWindow, 构建Validate对象，记录起始坐标
                (*MarkWindow) (pChild);
                if (pChild->firstChild) {
                    pChild = pChild->firstChild;
                    continue;
                }
            }
            while (!pChild->nextSib && (pChild != pWin))
                pChild = pChild->parent;
            // pWin的子窗口遍历完成，退出循环
            if (pChild == pWin)
                break;
            pChild = pChild->nextSib;
        }
        // pWin窗口向上移，pWin为第一个暴露的窗口，可能需要重绘，因此需标记
        anyMarked = TRUE;
       // 下一个相邻窗口
        pFirst = pFirst->nextSib;
    }
    if ((pChild = pFirst)) {
       // pWin区间，窗口向上移，该区域会遮挡相邻窗口，向下移，则会暴露相邻窗口
        box = RegionExtents(&pWin->borderSize);
        pLast = pChild->parent->lastChild;
        while (1) {
            if (pChild->viewable) {
                if (RegionBroken(&pChild->winSize))
                    SetWinSize(pChild);
                if (RegionBroken(&pChild->borderSize))
                    SetBorderSize(pChild);
                // 区域有重叠，这标记该窗口，可能被遮挡，也可能会被暴露
                if (RegionContainsRect(&pChild->borderSize, box)) {
                    // 调用miMarkWindow
                    (*MarkWindow) (pChild);
                    anyMarked = TRUE;
                    if (pChild->firstChild) {
                        pChild = pChild->firstChild;
                        continue;
                    }
                }
            }
            while (!pChild->nextSib && (pChild != pLast))
                pChild = pChild->parent;
            if (pChild == pLast)
                break;
            pChild = pChild->nextSib;
        }
    }
    if (anyMarked)
        (*MarkWindow) (pWin->parent);
    return anyMarked;
}

ValidateTree

计算窗口及其子窗口的clipList，boardList，exposed区域。

计算可能变化的可见区域(totalClip)，为减少重绘开销。有两种方式：
1. 父窗口的borderClip区域减去pChild之上的子窗口区域（boarderSize），这些子窗口区域的显示内容不会改变
2. 所有与移动窗口有重叠的子窗口的可见区域之和，为父窗口的最大可见区域，这些区域的内容会发生变化
过滤优化：在可见区域（totalClip）内，计算子窗口间是否重叠，若无，则不需重绘
子窗口的clipList，boardList，exposed区域，按照深度优先递归计算窗口的可见区域
1. 窗口当可见性发生变化时（Unobscured, PartiallyObscured, FullyObscured），可能发送VisibilityNotify事件
2. 当可见区域发生变化时，回调ClipNotify函数（present_clip_notify/compClipNotify/xf86XVClipNotify）
计算父窗口的可见区域，需重绘区域（exposed）等

int miValidateTree(WindowPtr pParent,  WindowPtr pChild,  VTKind kind) {
    // Total clipping region available to the marked children. 
    // pParent's clipList  merged with the borderClips of all the marked children.
    RegionRec totalClip;  
    RegionRec childClip;        /* The new borderClip for the current child */
    RegionRec childUnion;       /* the space covered by borderSize for all marked children */
    RegionRec exposed;          /* For intermediate calculations */
    WindowPtr pWin;
    Bool overlap;
    int viewvals;
    Bool forward;

    ScreenPtr pScreen = pParent->drawable.pScreen;
    if (pChild == NullWindow)
        pChild = pParent->firstChild;
    RegionNull(&childClip);
    RegionNull(&exposed);

    // compute the area of the parent window occupied by the marked children + the parent itself.  
    // This is the area which can be divied up among the marked children in their new configuration.
    RegionNull(&totalClip);
    viewvals = 0;
    // 计算可能变化的可见区域(totalClip)，有两种方法：
    // 1. 父窗口的borderClip区域减去pChild之上的子窗口区域（boarderSize），这些子窗口区域的显示内容不会改变
    // 2. 所有与移动窗口有重叠的子窗口的可见区域之和，为父窗口的最大可见区域，这些区域的内容会发生变化
    if (RegionBroken(&pParent->clipList) && !RegionBroken(&pParent->borderClip)) {
        // RegionBroken表示数据空间为空，一般来说根窗口的clipList置为broken，因为根窗口时常变化。
        kind = VTBroken;
        // When rebuilding clip lists after out of memory, assume everything is busted.
        forward = TRUE;
        RegionCopy(&totalClip, &pParent->borderClip);
        RegionIntersect(&totalClip, &totalClip, &pParent->winSize);
        // 在pChild之上的相邻窗口，遮挡了pParent，减去pWin的窗口大小（加上边框）
        // 如果pWin为compositor client管理，可能需要透明化，因此不能将其区域去掉
        for (pWin = pParent->firstChild; pWin != pChild; pWin = pWin->nextSib) {
            if (pWin->viewable && !TreatAsTransparent(pWin))
                RegionSubtract(&totalClip, &totalClip, &pWin->borderSize);
        }
        for (pWin = pChild; pWin; pWin = pWin->nextSib)
            if (pWin->valdata && pWin->viewable)
                viewvals++;
        RegionEmpty(&pParent->clipList);
    }
    else {
        // pChild后续相邻窗口的可见区域之和，即为pWin最大可见区域
        if ((pChild->drawable.y < pParent->lastChild->drawable.y) ||
            ((pChild->drawable.y == pParent->lastChild->drawable.y) &&
             (pChild->drawable.x < pParent->lastChild->drawable.x))) {
            forward = TRUE;
            for (pWin = pChild; pWin; pWin = pWin->nextSib) {
                if (pWin->valdata) { // 与移动窗口有重叠
                    RegionAppend(&totalClip, getBorderClip(pWin));
                    if (pWin->viewable)
                        viewvals++;
                }
            }
        }
        else {
            forward = FALSE;
            pWin = pParent->lastChild;
            while (1) {
                if (pWin->valdata) { // 与移动窗口有重叠
                    RegionAppend(&totalClip, getBorderClip(pWin));
                    if (pWin->viewable)
                        viewvals++;
                }
                if (pWin == pChild)
                    break;
                pWin = pWin->prevSib;
            }
        }
        RegionValidate(&totalClip, &overlap);
    }
    // Now go through the children of the root and figure their new borderClips from the totalClip, 
    // passing that off to miComputeClips to handle recursively. 
    // Once that's done, we remove the child from the totalClip to clip any siblings below it.
    overlap = TRUE;
    // 在可见区域（totalClip）内，计算子窗口间是否重叠，若无，则不需重绘
    if (kind != VTStack) {
        // 子窗口的可见区域加上父窗口的可见区域，为父窗口整个可见区域
        RegionUnion(&totalClip, &totalClip, &pParent->clipList);
        if (viewvals > 1) {
            // precompute childUnion to discover whether any of them overlap. 
            // This seems redundant, but performance studies have demonstrated 
            // that the cost of this loop is lower than the cost of multiple Subtracts in the loop below.
            RegionNull(&childUnion);
            if (forward) {
                for (pWin = pChild; pWin; pWin = pWin->nextSib)
                    if (pWin->valdata && pWin->viewable && !TreatAsTransparent(pWin))
                        RegionAppend(&childUnion, &pWin->borderSize);
            }
            else {
                pWin = pParent->lastChild;
                while (1) {
                    if (pWin->valdata && pWin->viewable && !TreatAsTransparent(pWin))
                        RegionAppend(&childUnion, &pWin->borderSize);
                    if (pWin == pChild)
                        break;
                    pWin = pWin->prevSib;
                }
            }
            // 窗口之间是否有重叠，若无重叠，不需要重绘。
            RegionValidate(&childUnion, &overlap);
            if (overlap)
                RegionUninit(&childUnion);
        }
    }
    for (pWin = pChild; pWin != NullWindow; pWin = pWin->nextSib) {
        if (pWin->viewable) {
            if (pWin->valdata) {
                RegionIntersect(&childClip, &totalClip, &pWin->borderSize);
                // 计算pWin及其子窗口的clipList，boardList，exposed区域
                miComputeClips(pWin, pScreen, &childClip, kind, &exposed);
                if (overlap && !TreatAsTransparent(pWin)) {
                    // pWin遮挡了下层的窗口，下层窗口对boarderSize区域不可见，因此可以去掉该区域
                    RegionSubtract(&totalClip, &totalClip, &pWin->borderSize);
                }
            }
            else if (pWin->visibility == VisibilityNotViewable) {
                miTreeObscured(pWin);
            }
        }
        else { // 不可显示，则清空clipList，删除临时数据
            if (pWin->valdata) {
                RegionEmpty(&pWin->clipList);
                if (pScreen->ClipNotify)
                    (*pScreen->ClipNotify) (pWin, 0, 0);
                RegionEmpty(&pWin->borderClip);
                pWin->valdata = NULL;
            }
        }
    }
    RegionUninit(&childClip);
    // 计算父窗口的可剪接区域，需重绘区域等
    if (!overlap) {
        // 没重叠，减去子窗口的可见区域，即为父窗口的可见区域
        RegionSubtract(&totalClip, &totalClip, &childUnion);
        RegionUninit(&childUnion);
    }
    RegionNull(&pParent->valdata->after.exposed);
    RegionNull(&pParent->valdata->after.borderExposed);

    // each case below is responsible for updating the clipList and serial number for the parent window
    switch (kind) {
    case VTStack:
        // 子窗口间的堆叠层次变化，不影响父窗口的clipList区域
        break;
    default:
        // totalClip contains the new clipList for the parent. 
        // Figure out exposures and obscures as per miComputeClips and reset the parent's clipList.
        // 只重绘未绘制区域。clipList中的区域已绘制。边框不需要重绘，因为子窗口从未覆盖边框
        RegionSubtract(&pParent->valdata->after.exposed, &totalClip, &pParent->clipList);
        /* fall through */
    case VTMap:
        // 更新clipList为新的可见区域
        RegionCopy(&pParent->clipList, &totalClip);
        pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
        break;
    }

    RegionUninit(&totalClip);
    RegionUninit(&exposed);
    if (pScreen->ClipNotify)
        (*pScreen->ClipNotify) (pParent, 0, 0);
    return 1;
}

HandleValidateExposures

发送重绘（Expose）事件，采用深度优先遍历窗口树

重绘父窗口图形
1. Server调用PaintWindow绘制边框
2. 调用WindowExposures
  1. Server调用PaintWindow绘制窗口背景
  2. 发送重绘事件给客户端
重绘子窗口图形，流程与上类似

void miHandleValidateExposures(WindowPtr pWin){
    WindowPtr pChild;
    ValidatePtr val;
    WindowExposuresProcPtr WindowExposures;
    pChild = pWin;
    WindowExposures = pChild->drawable.pScreen->WindowExposures;
    // 深度优先，先绘制边框，再绘制背景，然后发送Expose事件给客户端绘制
    while (1) {
        if ((val = pChild->valdata)) {
            if (RegionNotEmpty(&val->after.borderExposed))
                // 调用miPaintWindow
                pWin->drawable.pScreen->PaintWindow(pChild, &val->after.borderExposed, PW_BORDER);
            RegionUninit(&val->after.borderExposed);
            // xf86XVWindowExposures -> miWindowExposures
            (*WindowExposures) (pChild, &val->after.exposed);
            RegionUninit(&val->after.exposed);
            free(val);
            pChild->valdata = NULL;
            if (pChild->firstChild) {
                pChild = pChild->firstChild;
                continue;
            }
        }
        while (!pChild->nextSib && (pChild != pWin))
            pChild = pChild->parent;
        if (pChild == pWin)
            break;
        pChild = pChild->nextSib;
    }
}

void miWindowExposures(WindowPtr pWin, RegionPtr prgn){
    RegionPtr exposures = prgn;
    if (prgn && !RegionNil(prgn)) {
        RegionRec expRec;
        int clientInterested =
            (pWin->eventMask | wOtherEventMasks(pWin)) & ExposureMask;
        if (clientInterested && (RegionNumRects(prgn) > RECTLIMIT)) {
            // If we have LOTS of rectangles, we decide to take the extents and force an exposure on that.
            // This should require much less work overall, on both client and server.
            // This is cheating, but isn't prohibited by the protocol ("spontaneous combustion" :-).
            BoxRec box = *RegionExtents(prgn);
            exposures = &expRec;
            RegionInit(exposures, &box, 1);
            RegionReset(prgn, &box);
            /* miPaintWindow doesn't clip, so we have to */
            RegionIntersect(prgn, prgn, &pWin->clipList);
        }
        // 重绘窗口背景
        pWin->drawable.pScreen->PaintWindow(pWin, prgn, PW_BACKGROUND);
        if (clientInterested) // 发送Expose事件
            miSendExposures(pWin, exposures, pWin->drawable.x, pWin->drawable.y);
        if (exposures == &expRec)
            RegionUninit(exposures);
        RegionEmpty(prgn);
    }
}

WindowsRestructured

处理光标和键盘焦点，并重构光标窗口：

计算获得当前焦点坐标所在窗口（最低级窗口）
若当前焦点窗口与原窗口不同，则将焦点离开原窗口，进入新窗口
如果是光标设备，则重绘光标窗口，根据光标所在窗口特性，可绘制不同的光标图形，一般由miPointerDisplayCursor函数实现，动画光标由AnimCurDisplayCursor实现

void WindowsRestructured(void){
    DeviceIntPtr pDev = inputInfo.devices;
    while (pDev) {
        if (IsMaster(pDev) || IsFloating(pDev)) // 主输入设备或者与主输入设备关联的设备
            CheckMotion(NULL, pDev);
        pDev = pDev->next;
    }
}

Bool CheckMotion(DeviceEvent *ev, DeviceIntPtr pDev){
    WindowPtr prevSpriteWin, newSpriteWin;
    SpritePtr pSprite = pDev->spriteInfo->sprite;
    prevSpriteWin = pSprite->win;
    // ev == NULL
    if (ev && !syncEvents.playingEvents) {
        // skipped
    }
    // 根据精灵的坐标获取包含在坐标的窗口
    newSpriteWin = XYToWindow(pSprite, pSprite->hot.x, pSprite->hot.y);
    if (newSpriteWin != prevSpriteWin) { // 光标所在的窗口发生了变化
        int sourceid;
        if (!ev) {
            UpdateCurrentTimeIf();
            sourceid = pDev->id;        /* when from WindowsRestructured */
        }
        else
            sourceid = ev->sourceid;

        if (prevSpriteWin != NullWindow) {
            // 焦点离开prevSpriteWin窗口，进入newSpriteWin窗口，发送事件给client
            if (!ActivateEnterGrab(pDev, prevSpriteWin, newSpriteWin))
                DoEnterLeaveEvents(pDev, sourceid, prevSpriteWin, newSpriteWin, NotifyNormal);
        }
        pSprite->win = newSpriteWin;
        // 重绘新光标
        PostNewCursor(pDev);
        return FALSE;
    }
    return TRUE;
}

ConfigNotify

ConfigNotify回调通知X11扩展窗口配置发送变化，涉及一个回调函数链，其调用顺序为：

present_config_notify：发送PresentConfigureNotify扩展事件给客户端
compConfigNotify：针对拥有compWindow的窗口进行处理，若窗口尺寸有变化（ResizeWindow），则分配新的pixmap
DRI2ConfigNotify：失效原有的显存内存

// 回调函数原型
// (x, y)相对与父窗口的窗口新坐标，包含边框
// (w,h)窗口的新尺寸（宽高），宽高不包括边框
// bw窗口的边框新大小
// next_sib：窗口的相邻兄弟窗口，及窗口在next_sib窗口之上，这是窗口在窗口栈的新位置；为空表示窗口置底
int ConfigNotify(WindowPtr pWin, int x, int y, int w, int h, int bw, WindowPtr pSib)

present_config_notify

发送PresentConfigureNotify扩展事件给客户端。

static int present_config_notify(WindowPtr window, int x, int y, int w, int h, int bw,  WindowPtr sibling) {
    int ret;
    ScreenPtr screen = window->drawable.pScreen;
    present_screen_priv_ptr screen_priv = present_screen_priv(screen);
    // 发送PresentConfigureNotify扩展事件给客户端
    present_send_config_notify(window, x, y, w, h, bw, sibling, 0);
    unwrap(screen_priv, screen, ConfigNotify);
    // 调用compConfigNotify
    if (screen->ConfigNotify)
        ret = screen->ConfigNotify (window, x, y, w, h, bw, sibling);
    else
        ret = 0;
    wrap(screen_priv, screen, ConfigNotify, present_config_notify);
    return ret;
}

compConfigNotify

针对拥有compWindow的窗口进行处理，若窗口尺寸有变化，则分配新的pixmap，并将父窗口pixmap中新区域的窗口内容拷贝至新的pixmap中，若窗口的色彩深度与父窗口不同，则内容需要进行合成，旧的pixmap缓冲在cw->pOldPixmap中

int compConfigNotify(WindowPtr pWin, int x, int y, int w, int h, int bw, WindowPtr pSib){
    ScreenPtr pScreen = pWin->drawable.pScreen;
    CompScreenPtr cs = GetCompScreen(pScreen);
    Bool ret = 0;
    WindowPtr pParent = pWin->parent;
    int draw_x, draw_y;
    Bool alloc_ret;
    // 调用DRI2ConfigNotify
    if (cs->ConfigNotify) {
        pScreen->ConfigNotify = cs->ConfigNotify;
        ret = (*pScreen->ConfigNotify) (pWin, x, y, w, h, bw, pSib);
        cs->ConfigNotify = pScreen->ConfigNotify;
        pScreen->ConfigNotify = compConfigNotify;
        if (ret)
            return ret;
    }
    if (pWin->redirectDraw == RedirectDrawNone)
        return Success;
    // 计算窗口可绘制区域屏幕坐标，当尺寸不同时，重新分配pixmap
    draw_x = pParent->drawable.x + x + bw;
    draw_y = pParent->drawable.y + y + bw;
    alloc_ret = compReallocPixmap(pWin, draw_x, draw_y, w, h, bw);
    if (alloc_ret == FALSE)
        return BadAlloc;
    return Success;
}

Bool compReallocPixmap(WindowPtr pWin, int draw_x, int draw_y, unsigned int w, unsigned int h, int bw){
    ScreenPtr pScreen = pWin->drawable.pScreen;
    PixmapPtr pOld = (*pScreen->GetWindowPixmap) (pWin);
    PixmapPtr pNew;
    CompWindowPtr cw = GetCompWindow(pWin);
    int pix_x, pix_y;
    int pix_w, pix_h;
    cw->oldx = pOld->screen_x;
    cw->oldy = pOld->screen_y;
    pix_x = draw_x - bw;
    pix_y = draw_y - bw;
    pix_w = w + (bw << 1);
    pix_h = h + (bw << 1);
    if (pix_w != pOld->drawable.width || pix_h != pOld->drawable.height) {
        // 创建一个新的pixmap，包括边框尺寸，从父窗口的画布的新区域中拷贝内容至新的pixmap中
        pNew = compNewPixmap(pWin, pix_x, pix_y, pix_w, pix_h);
        if (!pNew)
            return FALSE;
        // 缓冲旧的pixmap，设置新的pixmap给窗口
        cw->pOldPixmap = pOld;
        compSetPixmap(pWin, pNew, bw);
    }
    else {
        pNew = pOld; // 尺寸不变（包括了边框），这更新坐标信息，旧坐标信息缓冲在cw->oldX/Y中
        cw->pOldPixmap = 0;
    }
    pNew->screen_x = pix_x; // 包含的边框的屏幕坐标
    pNew->screen_y = pix_y;
    return TRUE;
}

MoveWindow

移动窗口涉及窗口原位置遮挡的兄弟窗口需要显示内容，窗口移动后须在新位置显示窗口内容。其实现涉及一个回调函数链，包括：xwayland、composite、machine independent的回调函数。其调用顺序为：

xwl_move_window：更新顶层窗口的视口（viewport）
compMoveWindow：处理compWindow
miMoveWindow：移动窗口，重新计算子窗口的位置和尺寸，显示窗口内容等

// 回调函数原型
// (x, y)相对与父窗口的窗口新坐标
// next_sib：窗口的相邻兄弟窗口，及窗口在next_sib窗口之上，这是窗口在窗口栈的新位置；为空表示窗口置底
// kind：验证窗口树的类型，VTMove：只移动，VTOther：涉及边框的变化
void MoveWindow(WindowPtr window, int x, int y, WindowPtr next_sib, VTKind kind);

xwl_move_window

在非根模式下，额外处理顶级窗口与视口之间的关系，窗口内容在Wayland compositor视口中显示，可能只显示一部分内容。

void xwl_move_window(WindowPtr window, int x, int y, WindowPtr next_sib, VTKind kind){
    ScreenPtr screen = window->drawable.pScreen;
    struct xwl_screen *xwl_screen = xwl_screen_get(screen);
    // 获取xwl_window窗口，window本身或者其祖先窗口对应的xwl_window窗口，存在xwl_window，则比存在一个wl_surface与window对应
    struct xwl_window *xwl_window = xwl_window_from_window(window);
    // 调用compMoveWindow
    screen->MoveWindow = xwl_screen->MoveWindow;
    (*screen->MoveWindow) (window, x, y, next_sib, kind);
    xwl_screen->MoveWindow = screen->MoveWindow;
    screen->MoveWindow = xwl_move_window;
    // window本身有对应的xwl_window窗口，如：窗口管理器创建的装饰窗口
    // 或window是顶层窗口（包括override-redirect和被窗口管理器装饰的顶层窗口）
    if (xwl_window && (xwl_window_get(window) || xwl_window_is_toplevel(window)))
        xwl_window_check_resolution_change_emulation(xwl_window);
}

// 处理窗口与视口（viewport）的关系
void xwl_window_check_resolution_change_emulation(struct xwl_window *xwl_window)
{
    struct xwl_emulated_mode emulated_mode;
    struct xwl_output *xwl_output;
    // Wayland compositor支持wp_viewporter_interface接口，获取一个xwl_output和对应的xwl_emulated_mode
    if (xwl_window_should_enable_viewport(xwl_window, &xwl_output, &emulated_mode))
        xwl_window_enable_viewport(xwl_window, xwl_output, &emulated_mode);
    else if (xwl_window_has_viewport_enabled(xwl_window))
        xwl_window_disable_viewport(xwl_window);
}

// 视口（viewport）与surface建立关系，并设置视口区域大小
static void xwl_window_enable_viewport(struct xwl_window *xwl_window,
                           struct xwl_output *xwl_output, struct xwl_emulated_mode *emulated_mode){
    if (!xwl_window_has_viewport_enabled(xwl_window)) {
        // 绑定视口与曲面（wl_surface）
        xwl_window->viewport = wp_viewporter_get_viewport(xwl_window->xwl_screen->viewporter, xwl_window->surface);
    }
    // 设置窗口的坐标和尺寸
    wp_viewport_set_source(xwl_window->viewport,  wl_fixed_from_int(0), wl_fixed_from_int(0),
                           wl_fixed_from_int(emulated_mode->width), wl_fixed_from_int(emulated_mode->height));
    // 设置视口（viewport）的尺寸，可显示区域
    wp_viewport_set_destination(xwl_window->viewport, xwl_output->width, xwl_output->height);
    // 计算缩放比例
    xwl_window->scale_x = (float)emulated_mode->width  / xwl_output->width;
    xwl_window->scale_y = (float)emulated_mode->height / xwl_output->height;
}

compMoveWindow

回收compWindow中旧的pixmap资源

void compMoveWindow(WindowPtr pWin, int x, int y, WindowPtr pSib, VTKind kind) {
    ScreenPtr pScreen = pWin->drawable.pScreen;
    CompScreenPtr cs = GetCompScreen(pScreen);
    // 调用miMoveWindow
    pScreen->MoveWindow = cs->MoveWindow;
    (*pScreen->MoveWindow) (pWin, x, y, pSib, kind);
    cs->MoveWindow = pScreen->MoveWindow;
    pScreen->MoveWindow = compMoveWindow;
    // 是否旧的pixmap，新pixmap可能在compCOnfigNofity中创建
    compFreeOldPixmap(pWin);
    compCheckTree(pScreen);
}

static void compFreeOldPixmap(WindowPtr pWin) {
    ScreenPtr pScreen = pWin->drawable.pScreen;
    if (pWin->redirectDraw != RedirectDrawNone) {
        // 该窗口存在redirectWindow，且缓冲了旧的pixmap，则释放旧的pixmap
        CompWindowPtr cw = GetCompWindow(pWin);
        if (cw->pOldPixmap) {
            (*pScreen->DestroyPixmap) (cw->pOldPixmap);
            cw->pOldPixmap = NullPixmap;
        }
    }
}

miMoveWindow

实现窗口移动功能，窗口移动涉及原被遮挡窗口内容显示，窗口新位置内容显示，窗口栈的更新等，同时其子窗口也随之移动。

标记在父窗口树中被pWin覆盖的窗口和子窗口，包括pWin本身以及子窗口
更新pWin窗口尺寸和坐标，坐标平移，截取超过父窗口边界的区域
更新pWin子窗口的尺寸和坐标，坐标平移，截取超过pWin窗口边界的区域
根据pWin的新窗口，计算屏幕可能变化的区域，并计算窗口及子窗口的可见区域，重绘区域等。
将pWin窗口的原有效内容迁移至新窗口内
根据窗口exposed向client发送重绘请求

void miMoveWindow(WindowPtr pWin, int x, int y, WindowPtr pNextSib, VTKind kind){
    WindowPtr pParent;
    Bool WasViewable = (Bool) (pWin->viewable);
    short bw;
    RegionPtr oldRegion = NULL;
    DDXPointRec oldpt;
    Bool anyMarked = FALSE;
    ScreenPtr pScreen;
    WindowPtr windowToValidate;
    WindowPtr pLayerWin;
    if (!(pParent = pWin->parent))
        return;
    pScreen = pWin->drawable.pScreen;
    bw = wBorderWidth(pWin);
    oldpt.x = pWin->drawable.x;
    oldpt.y = pWin->drawable.y;
    if (WasViewable) {
        oldRegion = RegionCreate(NullBox, 1);
        // 缓冲原剪接区间
        RegionCopy(oldRegion, &pWin->borderClip);
        // 调用miMarkOverlappedWindows，从pWin开始向后遍历其兄弟窗口，标记被pWin覆盖的窗口（窗口移动前），若存在返回true
        anyMarked = (*pScreen->MarkOverlappedWindows) (pWin, pWin, &pLayerWin);
    }
    // origin (x,y)为窗口可绘制区域的新坐标，相对于父窗口
    pWin->origin.x = x + (int) bw;
    pWin->origin.y = y + (int) bw;
    // (x,y)窗口可绘制区域的屏幕新坐标
    x = pWin->drawable.x = pParent->drawable.x + x + (int) bw;
    y = pWin->drawable.y = pParent->drawable.y + y + (int) bw;
    // 设置窗口区域，若有compWindow，则为窗口实际大小，否则为父窗口范围内窗口区域
    SetWinSize(pWin);
    // 设置包含边框的窗口区域，原理同上
    SetBorderSize(pWin);
    // 回调PositionWindow通知X11扩展窗口位置更新
    // miDbePositionWindow -> compPositionWindow -> fbPositionWindow
    (*pScreen->PositionWindow) (pWin, x, y);
    // 更新pWin在窗口栈的位置，并计算第一个在栈中重新暴露的窗口：
    // pWin在pNextSib之上（窗口下移），则为pWin->nextSib
    // pWin在pNextSib之下（窗口上移），则为pWin
    windowToValidate = MoveWindowInStack(pWin, pNextSib);
    // 重新计算子窗口在新位置的窗口尺寸，由于窗口的移动，可能导致某些内容移出父窗口，则必须截取窗口尺寸
    ResizeChildrenWinSize(pWin, x - oldpt.x, y - oldpt.y, 0, 0);
    if (WasViewable) {
        if (pLayerWin == pWin) // 该条件恒成立，不知为什么需要判断
            // 从windowToValidate开始向后遍历其兄弟窗口，标记与pWin重叠的窗口（窗口移动后（坐标已更新））
            anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, windowToValidate, NULL);
        else
            anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pLayerWin, NULL);
        if (anyMarked) { // 有重叠，有些窗口被遮挡，有些窗口重新显示
            // 调用miValidateTree重新计算pWin父窗口及其子窗口的可见区域，并计算待重新绘制区域（需重新显示的区域）
            (*pScreen->ValidateTree) (pLayerWin->parent, NullWindow, kind);
            // compCopyWindow -> damageCopyWindow -> glamor_copy_window
            // 将window中的内容拷贝至新位置
            (*pWin->drawable.pScreen->CopyWindow) (pWin, oldpt, oldRegion);
            RegionDestroy(oldRegion);
            // 调用miHandleValidateExposures，深度优先，先绘制边框，再绘制背景，然后发送Expose事件给客户端绘制
            (*pScreen->HandleExposures) (pLayerWin->parent);
            if (pScreen->PostValidateTree)
                (*pScreen->PostValidateTree) (pLayerWin->parent, NULL, kind);
        }
    }
    if (pWin->realized) // 重构所有窗口
        WindowsRestructured();
}

compCopyWindow

分两种情况更新新区域内容

窗口有compWindow，若窗口尺寸未变，则创建Damage，告知新区域内容有变化；若窗口尺寸变化时，pixmap为新区域的内容，需将旧pixmap的内容拷贝至pixmap中，更新窗口内容至新区域。
窗口无compWindow，则传递给后续的CopyWindow处理

void compCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{
    ScreenPtr pScreen = pWin->drawable.pScreen;
    CompScreenPtr cs = GetCompScreen(pScreen);
    int dx = 0, dy = 0;
    if (pWin->redirectDraw != RedirectDrawNone) {
        PixmapPtr pPixmap = (*pScreen->GetWindowPixmap) (pWin);
        CompWindowPtr cw = GetCompWindow(pWin);
        if (cw->pOldPixmap) {
            // 窗口尺寸有改变，在compConfigNofity中创建了新的pixmap，旧的pixmap缓冲在pOldPixmap中
            // 将pOldPixmap的内容拷贝至新的pixmap中即可，覆盖新pixmap中响应区域内容
            RegionRec rgnDst;
            GCPtr pGC;
            // 计算窗口移动时产生的坐标偏移
            dx = ptOldOrg.x - pWin->drawable.x;
            dy = ptOldOrg.y - pWin->drawable.y;
            RegionTranslate(prgnSrc, -dx, -dy);
            RegionNull(&rgnDst);
            // 区域限制在borderClip范围内
            RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
            // 坐标转换，从屏幕坐标转换为本地坐标（画布内的坐标）
            RegionTranslate(&rgnDst, -pPixmap->screen_x, -pPixmap->screen_y);
            // 坐标偏移转换为old和new pixmap内的偏移
            dx = dx + pPixmap->screen_x - cw->oldx;
            dy = dy + pPixmap->screen_y - cw->oldy;
            pGC = GetScratchGC(pPixmap->drawable.depth, pScreen);
            if (pGC) {
                BoxPtr pBox = RegionRects(&rgnDst);
                int nBox = RegionNumRects(&rgnDst);
                ValidateGC(&pPixmap->drawable, pGC);
                while (nBox--) {
                    // 调用glamor_copy_area拷贝数据
                    (void) (*pGC->ops->CopyArea) (&cw->pOldPixmap->drawable, &pPixmap->drawable, pGC,
                                                  pBox->x1 + dx, pBox->y1 + dy, pBox->x2 - pBox->x1,
                                                  pBox->y2 - pBox->y1, pBox->x1, pBox->y1);
                    pBox++;
                }
                FreeScratchGC(pGC);
            }
            RegionUninit(&rgnDst);
            return;
        }
        // 矫正旧坐标，加上新pixmap的屏幕坐标与旧pixmap的偏移，方便后续操作区分
        dx = pPixmap->screen_x - cw->oldx;
        dy = pPixmap->screen_y - cw->oldy;
        ptOldOrg.x += dx;
        ptOldOrg.y += dy;
    }

    pScreen->CopyWindow = cs->CopyWindow;
    if (ptOldOrg.x != pWin->drawable.x || ptOldOrg.y != pWin->drawable.y) {
        // 窗口无compWindow，需要将内容从旧坐标移至新坐标
        if (dx || dy)
            RegionTranslate(prgnSrc, dx, dy);
        // damageCopyWindow
        (*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
        if (dx || dy)
            RegionTranslate(prgnSrc, -dx, -dy);
    }
    else {
        // 还原旧坐标，见上的矫正
        ptOldOrg.x -= dx;
        ptOldOrg.y -= dy;
        // 更新prgnSrc至新坐标区域，构建Damage，通知新区域内容有变化
        RegionTranslate(prgnSrc, pWin->drawable.x - ptOldOrg.x, pWin->drawable.y - ptOldOrg.y);
        DamageDamageRegion(&pWin->drawable, prgnSrc);
    }
    cs->CopyWindow = pScreen->CopyWindow;
    pScreen->CopyWindow = compCopyWindow;
    compCheckTree(pWin->drawable.pScreen);
}

damageCopyWindow

创建Damage，记录变化区域

static void damageCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc){
    ScreenPtr pScreen = pWindow->drawable.pScreen;
    damageScrPriv(pScreen);
    if (getWindowDamage(pWindow)) {
        int dx = pWindow->drawable.x - ptOldOrg.x;
        int dy = pWindow->drawable.y - ptOldOrg.y;
        // The region comes in source relative, but the damage occurs at the destination location.
        // Translate back and forth.
        RegionTranslate(prgnSrc, dx, dy);
        damageRegionAppend(&pWindow->drawable, prgnSrc, FALSE, -1);
        RegionTranslate(prgnSrc, -dx, -dy);
    }
    unwrap(pScrPriv, pScreen, CopyWindow);
    // glamor_copy_window
    (*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc);
    damageRegionProcessPending(&pWindow->drawable);
    wrap(pScrPriv, pScreen, CopyWindow, damageCopyWindow);
}

glamor_copy_window

使用openGL拷贝数据

void glamor_copy_window(WindowPtr window, DDXPointRec old_origin, RegionPtr src_region){
    PixmapPtr pixmap = glamor_get_drawable_pixmap(&window->drawable);
    DrawablePtr drawable = &pixmap->drawable;
    RegionRec dst_region;
    int dx = old_origin.x - window->drawable.x;
    int dy = old_origin.y - window->drawable.y;
    RegionTranslate(src_region, -dx, -dy);
    RegionNull(&dst_region);
    RegionIntersect(&dst_region, &window->borderClip, src_region);
    // pixmap的屏幕起始坐标记录在(screen_x, screen_y)
    if (pixmap->screen_x || pixmap->screen_y)
        RegionTranslate(&dst_region, -pixmap->screen_x, -pixmap->screen_y);
    // 在同一个drawable中拷贝数据时，需考虑内容被覆盖的问题
    // miCopyRegion考虑的拷贝方向（从上往下，从左往右），以避免内容被覆盖的问题
    miCopyRegion(drawable, drawable, 0, &dst_region, dx, dy, glamor_copy, 0, 0);
    RegionUninit(&dst_region);
}

// 采用opengl进行拷贝，通过reverse和upsidedown指定了拷贝数据时的方向
// reverse：true为X轴上从右往左拷数据；false为X轴上从左往右拷数据
// upsidedown：true为Y轴上从网上下拷数据；false为Y轴上从下往上拷数据
void glamor_copy(DrawablePtr src, DrawablePtr dst, GCPtr gc,
            BoxPtr box, int nbox, int dx, int dy,
            Bool reverse, Bool upsidedown, Pixel bitplane, void *closure){
    if (nbox == 0)
	return;
    if (glamor_copy_gl(src, dst, gc, box, nbox, dx, dy, reverse, upsidedown, bitplane, closure))
        return;
    glamor_copy_bail(src, dst, gc, box, nbox, dx, dy, reverse, upsidedown, bitplane, closure);
}

ResizeWindow

窗口缩放包含窗口尺寸变化，窗口位置变化等。当窗口尺寸发生变化时，需要计算窗口预留的内容以及子窗口的位置，这些有两个gravity参数标记：bitGravity和winGravity，这些均在miResizeWindow中实现

bitGravity：父窗口尺寸发生变化时，确定父窗口预留的窗口内容，以及在新窗口的放置位置
winGravity：父窗口尺寸发生变化时，子窗口的winGravity指定了如何计算子窗口的坐标

假设父窗口的尺寸变化为(dw, dh)，坐标变化为(dx,dy)，子窗口的原坐标为(origx,origy)，子窗口的winGravity值如表，可计算其新坐标位置。具体实现在ResizeChildrenWinSize中。

winGravity	Deltas	子窗口位置
UnmapGravity	N/A	UnmapWindow
NorthWestGravity	[0, 0]	[origx + dx, origy + dy]
North	[dw/2, 0]	[origx + dx + dw/2, origy + dy]
NorthEast	[dw, 0]	[origx + dx + dw, origy + dy]
West	[0, dh/2]	[origx + dx, origy + dy + dh/2]
Center	[dw/2, dh/2]	[origx + dx + dw/2, origy + dy + dh/2]
East	[dw, dh/2]	[origx + dx + dw, origy + dy + dh/2]
SouthWest	[0, dh]	[origx + dx, origy + dy + dh]
South	[dw/2, dh]	[origx + dx + dw/2, origy + dy + dh]
SouthEast	[dw, dh]	[origx + dx + dw, origy + dy + dh]
StaticGravity	N/A	[origx, origy]

// 回调函数原型
// (x, y)相对与父窗口的窗口新坐标，包含边框
// (width,hight)窗口的新尺寸（宽高），宽高不包括边框
// sib：窗口的相邻兄弟窗口，及窗口在sib窗口之上，这是窗口在窗口栈的新位置；为空表示窗口置底
int ResizeWindow(WindowPtr window, int x, int y, unsigned int width, unsigned int height,, WindowPtr sib)

xwl_resize_window