1660 lines
50 KiB
C
1660 lines
50 KiB
C
/*
|
|
* Rootless window management
|
|
*/
|
|
/*
|
|
* Copyright (c) 2001 Greg Parker. All Rights Reserved.
|
|
* Copyright (c) 2002-2004 Torrey T. Lyons. All Rights Reserved.
|
|
* Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name(s) of the above copyright
|
|
* holders shall not be used in advertising or otherwise to promote the sale,
|
|
* use or other dealings in this Software without prior written authorization.
|
|
*/
|
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
#include <dix-config.h>
|
|
#endif
|
|
|
|
#include <stddef.h> /* For NULL */
|
|
#include <limits.h> /* For CHAR_BIT */
|
|
#include <assert.h>
|
|
#include <X11/Xatom.h>
|
|
#ifdef __APPLE__
|
|
#include <Xplugin.h>
|
|
#include "mi.h"
|
|
#include "pixmapstr.h"
|
|
#include "windowstr.h"
|
|
//#include <X11/extensions/applewm.h>
|
|
extern int darwinMainScreenX, darwinMainScreenY;
|
|
extern Bool no_configure_window;
|
|
#endif
|
|
#include "fb.h"
|
|
|
|
#include "rootlessCommon.h"
|
|
#include "rootlessWindow.h"
|
|
|
|
#define SCREEN_TO_GLOBAL_X \
|
|
(pScreen->x + rootlessGlobalOffsetX)
|
|
#define SCREEN_TO_GLOBAL_Y \
|
|
(pScreen->y + rootlessGlobalOffsetY)
|
|
|
|
#define DEFINE_ATOM_HELPER(func,atom_name) \
|
|
static Atom func (void) { \
|
|
static unsigned int generation = 0; \
|
|
static Atom atom; \
|
|
if (generation != serverGeneration) { \
|
|
generation = serverGeneration; \
|
|
atom = MakeAtom (atom_name, strlen (atom_name), TRUE); \
|
|
} \
|
|
return atom; \
|
|
}
|
|
|
|
DEFINE_ATOM_HELPER(xa_native_window_id, "_NATIVE_WINDOW_ID")
|
|
|
|
static Bool windows_hidden;
|
|
|
|
// TODO - abstract xp functions
|
|
|
|
#ifdef __APPLE__
|
|
|
|
// XXX: identical to x_cvt_vptr_to_uint ?
|
|
#define MAKE_WINDOW_ID(x) ((xp_window_id)((size_t)(x)))
|
|
|
|
void
|
|
RootlessNativeWindowStateChanged(WindowPtr pWin, unsigned int state)
|
|
{
|
|
RootlessWindowRec *winRec;
|
|
|
|
if (pWin == NULL)
|
|
return;
|
|
|
|
winRec = WINREC(pWin);
|
|
if (winRec == NULL)
|
|
return;
|
|
|
|
winRec->is_offscreen = ((state & XP_WINDOW_STATE_OFFSCREEN) != 0);
|
|
winRec->is_obscured = ((state & XP_WINDOW_STATE_OBSCURED) != 0);
|
|
pWin->unhittable = winRec->is_offscreen;
|
|
}
|
|
|
|
void
|
|
RootlessNativeWindowMoved(WindowPtr pWin)
|
|
{
|
|
xp_box bounds;
|
|
int sx, sy, err;
|
|
XID vlist[2];
|
|
Mask mask;
|
|
ClientPtr pClient;
|
|
RootlessWindowRec *winRec;
|
|
|
|
winRec = WINREC(pWin);
|
|
|
|
if (xp_get_window_bounds(MAKE_WINDOW_ID(winRec->wid), &bounds) != Success)
|
|
return;
|
|
|
|
sx = pWin->drawable.pScreen->x + darwinMainScreenX;
|
|
sy = pWin->drawable.pScreen->y + darwinMainScreenY;
|
|
|
|
/* Fake up a ConfigureWindow packet to resize the window to the current bounds. */
|
|
vlist[0] = (INT16) bounds.x1 - sx;
|
|
vlist[1] = (INT16) bounds.y1 - sy;
|
|
mask = CWX | CWY;
|
|
|
|
/* pretend we're the owner of the window! */
|
|
err =
|
|
dixLookupClient(&pClient, pWin->drawable.id, serverClient,
|
|
DixUnknownAccess);
|
|
if (err != Success) {
|
|
ErrorF("RootlessNativeWindowMoved(): Failed to lookup window: 0x%x\n",
|
|
(unsigned int) pWin->drawable.id);
|
|
return;
|
|
}
|
|
|
|
/* Don't want to do anything to the physical window (avoids
|
|
notification-response feedback loops) */
|
|
|
|
no_configure_window = TRUE;
|
|
ConfigureWindow(pWin, mask, vlist, pClient);
|
|
no_configure_window = FALSE;
|
|
}
|
|
|
|
#endif /* __APPLE__ */
|
|
|
|
/*
|
|
* RootlessCreateWindow
|
|
* For now, don't create a physical window until either the window is
|
|
* realized, or we really need it (e.g. to attach VRAM surfaces to).
|
|
* Do reset the window size so it's not clipped by the root window.
|
|
*/
|
|
Bool
|
|
RootlessCreateWindow(WindowPtr pWin)
|
|
{
|
|
Bool result;
|
|
RegionRec saveRoot;
|
|
|
|
SETWINREC(pWin, NULL);
|
|
dixSetPrivate(&pWin->devPrivates, rootlessWindowOldPixmapPrivateKey, NULL);
|
|
|
|
SCREEN_UNWRAP(pWin->drawable.pScreen, CreateWindow);
|
|
|
|
if (!IsRoot(pWin)) {
|
|
/* win/border size set by DIX, not by wrapped CreateWindow, so
|
|
correct it here. Don't HUGE_ROOT when pWin is the root! */
|
|
|
|
HUGE_ROOT(pWin);
|
|
SetWinSize(pWin);
|
|
SetBorderSize(pWin);
|
|
}
|
|
|
|
result = pWin->drawable.pScreen->CreateWindow(pWin);
|
|
|
|
if (pWin->parent) {
|
|
NORMAL_ROOT(pWin);
|
|
}
|
|
|
|
SCREEN_WRAP(pWin->drawable.pScreen, CreateWindow);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* RootlessDestroyFrame
|
|
* Destroy the physical window associated with the given window.
|
|
*/
|
|
static void
|
|
RootlessDestroyFrame(WindowPtr pWin, RootlessWindowPtr winRec)
|
|
{
|
|
SCREENREC(pWin->drawable.pScreen)->imp->DestroyFrame(winRec->wid);
|
|
free(winRec);
|
|
SETWINREC(pWin, NULL);
|
|
}
|
|
|
|
/*
|
|
* RootlessDestroyWindow
|
|
* Destroy the physical window associated with the given window.
|
|
*/
|
|
Bool
|
|
RootlessDestroyWindow(WindowPtr pWin)
|
|
{
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
Bool result;
|
|
|
|
if (winRec != NULL) {
|
|
RootlessDestroyFrame(pWin, winRec);
|
|
}
|
|
|
|
SCREEN_UNWRAP(pWin->drawable.pScreen, DestroyWindow);
|
|
result = pWin->drawable.pScreen->DestroyWindow(pWin);
|
|
SCREEN_WRAP(pWin->drawable.pScreen, DestroyWindow);
|
|
|
|
return result;
|
|
}
|
|
|
|
static Bool
|
|
RootlessGetShape(WindowPtr pWin, RegionPtr pShape)
|
|
{
|
|
if (wBoundingShape(pWin) == NULL)
|
|
return FALSE;
|
|
|
|
/* wBoundingShape is relative to *inner* origin of window.
|
|
Translate by borderWidth to get the outside-relative position. */
|
|
|
|
RegionNull(pShape);
|
|
RegionCopy(pShape, wBoundingShape(pWin));
|
|
RegionTranslate(pShape, pWin->borderWidth, pWin->borderWidth);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* RootlessReshapeFrame
|
|
* Set the frame shape.
|
|
*/
|
|
static void
|
|
RootlessReshapeFrame(WindowPtr pWin)
|
|
{
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
RegionRec newShape;
|
|
RegionPtr pShape;
|
|
|
|
// If the window is not yet framed, do nothing
|
|
if (winRec == NULL)
|
|
return;
|
|
|
|
if (IsRoot(pWin))
|
|
return;
|
|
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
|
|
pShape = RootlessGetShape(pWin, &newShape) ? &newShape : NULL;
|
|
|
|
#ifdef ROOTLESSDEBUG
|
|
RL_DEBUG_MSG("reshaping...");
|
|
if (pShape != NULL) {
|
|
RL_DEBUG_MSG("numrects %d, extents %d %d %d %d ",
|
|
RegionNumRects(&newShape),
|
|
newShape.extents.x1, newShape.extents.y1,
|
|
newShape.extents.x2, newShape.extents.y2);
|
|
}
|
|
else {
|
|
RL_DEBUG_MSG("no shape ");
|
|
}
|
|
#endif
|
|
|
|
SCREENREC(pWin->drawable.pScreen)->imp->ReshapeFrame(winRec->wid, pShape);
|
|
|
|
if (pShape != NULL)
|
|
RegionUninit(&newShape);
|
|
}
|
|
|
|
/*
|
|
* RootlessSetShape
|
|
* Shape is usually set before a window is mapped and the window will
|
|
* not have a frame associated with it. In this case, the frame will be
|
|
* shaped when the window is framed.
|
|
*/
|
|
void
|
|
RootlessSetShape(WindowPtr pWin, int kind)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
|
|
SCREEN_UNWRAP(pScreen, SetShape);
|
|
pScreen->SetShape(pWin, kind);
|
|
SCREEN_WRAP(pScreen, SetShape);
|
|
|
|
RootlessReshapeFrame(pWin);
|
|
}
|
|
|
|
/* Disallow ParentRelative background on top-level windows
|
|
because the root window doesn't really have the right background.
|
|
*/
|
|
Bool
|
|
RootlessChangeWindowAttributes(WindowPtr pWin, unsigned long vmask)
|
|
{
|
|
Bool result;
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
|
|
RL_DEBUG_MSG("change window attributes start ");
|
|
|
|
SCREEN_UNWRAP(pScreen, ChangeWindowAttributes);
|
|
result = pScreen->ChangeWindowAttributes(pWin, vmask);
|
|
SCREEN_WRAP(pScreen, ChangeWindowAttributes);
|
|
|
|
if (WINREC(pWin)) {
|
|
// disallow ParentRelative background state
|
|
if (pWin->backgroundState == ParentRelative) {
|
|
XID pixel = 0;
|
|
|
|
ChangeWindowAttributes(pWin, CWBackPixel, &pixel, serverClient);
|
|
}
|
|
}
|
|
|
|
RL_DEBUG_MSG("change window attributes end\n");
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* RootlessPositionWindow
|
|
* This is a hook for when DIX moves or resizes a window.
|
|
* Update the frame position now although the physical window is moved
|
|
* in RootlessMoveWindow. (x, y) are *inside* position. After this,
|
|
* mi and fb are expecting the pixmap to be at the new location.
|
|
*/
|
|
Bool
|
|
RootlessPositionWindow(WindowPtr pWin, int x, int y)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
Bool result;
|
|
|
|
RL_DEBUG_MSG("positionwindow start (win 0x%x @ %i, %i)\n", pWin, x, y);
|
|
|
|
if (winRec) {
|
|
if (winRec->is_drawing) {
|
|
// Reset frame's pixmap and move it to the new position.
|
|
int bw = wBorderWidth(pWin);
|
|
|
|
winRec->pixmap->devPrivate.ptr = winRec->pixelData;
|
|
SetPixmapBaseToScreen(winRec->pixmap, x - bw, y - bw);
|
|
}
|
|
}
|
|
|
|
SCREEN_UNWRAP(pScreen, PositionWindow);
|
|
result = pScreen->PositionWindow(pWin, x, y);
|
|
SCREEN_WRAP(pScreen, PositionWindow);
|
|
|
|
RL_DEBUG_MSG("positionwindow end\n");
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* RootlessInitializeFrame
|
|
* Initialize some basic attributes of the frame. Note that winRec
|
|
* may already have valid data in it, so don't overwrite anything
|
|
* valuable.
|
|
*/
|
|
static void
|
|
RootlessInitializeFrame(WindowPtr pWin, RootlessWindowRec * winRec)
|
|
{
|
|
DrawablePtr d = &pWin->drawable;
|
|
int bw = wBorderWidth(pWin);
|
|
|
|
winRec->win = pWin;
|
|
|
|
winRec->x = d->x - bw;
|
|
winRec->y = d->y - bw;
|
|
winRec->width = d->width + 2 * bw;
|
|
winRec->height = d->height + 2 * bw;
|
|
winRec->borderWidth = bw;
|
|
}
|
|
|
|
/*
|
|
* RootlessEnsureFrame
|
|
* Make sure the given window is framed. If the window doesn't have a
|
|
* physical window associated with it, attempt to create one. If that
|
|
* is unsuccessful, return NULL.
|
|
*/
|
|
static RootlessWindowRec *
|
|
RootlessEnsureFrame(WindowPtr pWin)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
RootlessWindowRec *winRec;
|
|
RegionRec shape;
|
|
RegionPtr pShape = NULL;
|
|
|
|
if (WINREC(pWin) != NULL)
|
|
return WINREC(pWin);
|
|
|
|
if (!IsTopLevel(pWin) && !IsRoot(pWin))
|
|
return NULL;
|
|
|
|
if (pWin->drawable.class != InputOutput)
|
|
return NULL;
|
|
|
|
winRec = malloc(sizeof(RootlessWindowRec));
|
|
|
|
if (!winRec)
|
|
return NULL;
|
|
|
|
RootlessInitializeFrame(pWin, winRec);
|
|
|
|
winRec->is_drawing = FALSE;
|
|
winRec->is_reorder_pending = FALSE;
|
|
winRec->pixmap = NULL;
|
|
winRec->wid = NULL;
|
|
winRec->level = 0;
|
|
|
|
SETWINREC(pWin, winRec);
|
|
|
|
// Set the frame's shape if the window is shaped
|
|
if (RootlessGetShape(pWin, &shape))
|
|
pShape = &shape;
|
|
|
|
RL_DEBUG_MSG("creating frame ");
|
|
|
|
if (!SCREENREC(pScreen)->imp->CreateFrame(winRec, pScreen,
|
|
winRec->x + SCREEN_TO_GLOBAL_X,
|
|
winRec->y + SCREEN_TO_GLOBAL_Y,
|
|
pShape)) {
|
|
RL_DEBUG_MSG("implementation failed to create frame!\n");
|
|
free(winRec);
|
|
SETWINREC(pWin, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
if (pWin->drawable.depth == 8)
|
|
RootlessFlushWindowColormap(pWin);
|
|
|
|
if (pShape != NULL)
|
|
RegionUninit(&shape);
|
|
|
|
return winRec;
|
|
}
|
|
|
|
/*
|
|
* RootlessRealizeWindow
|
|
* The frame is usually created here and not in CreateWindow so that
|
|
* windows do not eat memory until they are realized.
|
|
*/
|
|
Bool
|
|
RootlessRealizeWindow(WindowPtr pWin)
|
|
{
|
|
Bool result;
|
|
RegionRec saveRoot;
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
|
|
RL_DEBUG_MSG("realizewindow start (win 0x%x) ", pWin);
|
|
|
|
if ((IsTopLevel(pWin) && pWin->drawable.class == InputOutput)) {
|
|
RootlessWindowRec *winRec;
|
|
|
|
winRec = RootlessEnsureFrame(pWin);
|
|
if (winRec == NULL)
|
|
return FALSE;
|
|
|
|
winRec->is_reorder_pending = TRUE;
|
|
|
|
RL_DEBUG_MSG("Top level window ");
|
|
|
|
// Disallow ParentRelative background state on top-level windows.
|
|
// This might have been set before the window was mapped.
|
|
if (pWin->backgroundState == ParentRelative) {
|
|
XID pixel = 0;
|
|
|
|
ChangeWindowAttributes(pWin, CWBackPixel, &pixel, serverClient);
|
|
}
|
|
}
|
|
|
|
if (!IsRoot(pWin))
|
|
HUGE_ROOT(pWin);
|
|
SCREEN_UNWRAP(pScreen, RealizeWindow);
|
|
result = pScreen->RealizeWindow(pWin);
|
|
SCREEN_WRAP(pScreen, RealizeWindow);
|
|
if (!IsRoot(pWin))
|
|
NORMAL_ROOT(pWin);
|
|
|
|
RL_DEBUG_MSG("realizewindow end\n");
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* RootlessFrameForWindow
|
|
* Returns the frame ID for the physical window displaying the given window.
|
|
* If CREATE is true and the window has no frame, attempt to create one.
|
|
*/
|
|
RootlessFrameID
|
|
RootlessFrameForWindow(WindowPtr pWin, Bool create)
|
|
{
|
|
WindowPtr pTopWin;
|
|
RootlessWindowRec *winRec;
|
|
|
|
pTopWin = TopLevelParent(pWin);
|
|
if (pTopWin == NULL)
|
|
return NULL;
|
|
|
|
winRec = WINREC(pTopWin);
|
|
|
|
if (winRec == NULL && create && pWin->drawable.class == InputOutput) {
|
|
winRec = RootlessEnsureFrame(pTopWin);
|
|
}
|
|
|
|
if (winRec == NULL)
|
|
return NULL;
|
|
|
|
return winRec->wid;
|
|
}
|
|
|
|
/*
|
|
* RootlessUnrealizeWindow
|
|
* Unmap the physical window.
|
|
*/
|
|
Bool
|
|
RootlessUnrealizeWindow(WindowPtr pWin)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
Bool result;
|
|
|
|
RL_DEBUG_MSG("unrealizewindow start ");
|
|
|
|
if (winRec) {
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
|
|
SCREENREC(pScreen)->imp->UnmapFrame(winRec->wid);
|
|
|
|
winRec->is_reorder_pending = FALSE;
|
|
}
|
|
|
|
SCREEN_UNWRAP(pScreen, UnrealizeWindow);
|
|
result = pScreen->UnrealizeWindow(pWin);
|
|
SCREEN_WRAP(pScreen, UnrealizeWindow);
|
|
|
|
RL_DEBUG_MSG("unrealizewindow end\n");
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* RootlessReorderWindow
|
|
* Reorder the frame associated with the given window so that it's
|
|
* physically above the window below it in the X stacking order.
|
|
*/
|
|
void
|
|
RootlessReorderWindow(WindowPtr pWin)
|
|
{
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
|
|
if (pWin->realized && winRec != NULL && !winRec->is_reorder_pending &&
|
|
!windows_hidden) {
|
|
WindowPtr newPrevW;
|
|
RootlessWindowRec *newPrev;
|
|
RootlessFrameID newPrevID;
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
|
|
/* Check if the implementation wants the frame to not be reordered
|
|
even though the X11 window is restacked. This can be useful if
|
|
frames are ordered-in with animation so that the reordering is not
|
|
done until the animation is complete. */
|
|
if (SCREENREC(pScreen)->imp->DoReorderWindow) {
|
|
if (!SCREENREC(pScreen)->imp->DoReorderWindow(winRec))
|
|
return;
|
|
}
|
|
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
|
|
/* Find the next window above this one that has a mapped frame.
|
|
* Only include cases where the windows are in the same category of
|
|
* hittability to ensure offscreen windows dont get restacked
|
|
* relative to onscreen ones (but that the offscreen ones maintain
|
|
* their stacking order if they are explicitly asked to Reorder
|
|
*/
|
|
|
|
newPrevW = pWin->prevSib;
|
|
while (newPrevW &&
|
|
(WINREC(newPrevW) == NULL || !newPrevW->realized ||
|
|
newPrevW->unhittable != pWin->unhittable))
|
|
newPrevW = newPrevW->prevSib;
|
|
|
|
newPrev = newPrevW != NULL ? WINREC(newPrevW) : NULL;
|
|
newPrevID = newPrev != NULL ? newPrev->wid : 0;
|
|
|
|
/* If it exists, reorder the frame above us first. */
|
|
|
|
if (newPrev && newPrev->is_reorder_pending) {
|
|
newPrev->is_reorder_pending = FALSE;
|
|
RootlessReorderWindow(newPrevW);
|
|
}
|
|
|
|
SCREENREC(pScreen)->imp->RestackFrame(winRec->wid, newPrevID);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* RootlessRestackWindow
|
|
* This is a hook for when DIX changes the window stacking order.
|
|
* The window has already been inserted into its new position in the
|
|
* DIX window stack. We need to change the order of the physical
|
|
* window to match.
|
|
*/
|
|
void
|
|
RootlessRestackWindow(WindowPtr pWin, WindowPtr pOldNextSib)
|
|
{
|
|
RegionRec saveRoot;
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
|
|
RL_DEBUG_MSG("restackwindow start ");
|
|
if (winRec)
|
|
RL_DEBUG_MSG("restack top level \n");
|
|
|
|
HUGE_ROOT(pWin);
|
|
SCREEN_UNWRAP(pScreen, RestackWindow);
|
|
|
|
if (pScreen->RestackWindow)
|
|
pScreen->RestackWindow(pWin, pOldNextSib);
|
|
|
|
SCREEN_WRAP(pScreen, RestackWindow);
|
|
NORMAL_ROOT(pWin);
|
|
|
|
if (winRec && pWin->viewable) {
|
|
RootlessReorderWindow(pWin);
|
|
}
|
|
|
|
RL_DEBUG_MSG("restackwindow end\n");
|
|
}
|
|
|
|
/*
|
|
* Specialized window copy procedures
|
|
*/
|
|
|
|
// Globals needed during window resize and move.
|
|
static void *gResizeDeathBits = NULL;
|
|
static int gResizeDeathCount = 0;
|
|
static PixmapPtr gResizeDeathPix[2] = { NULL, NULL };
|
|
|
|
static BoxRec gResizeDeathBounds[2];
|
|
static CopyWindowProcPtr gResizeOldCopyWindowProc = NULL;
|
|
|
|
/*
|
|
* RootlessNoCopyWindow
|
|
* CopyWindow() that doesn't do anything. For MoveWindow() of
|
|
* top-level windows.
|
|
*/
|
|
static void
|
|
RootlessNoCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
|
|
{
|
|
// some code expects the region to be translated
|
|
int dx = ptOldOrg.x - pWin->drawable.x;
|
|
int dy = ptOldOrg.y - pWin->drawable.y;
|
|
|
|
RL_DEBUG_MSG("ROOTLESSNOCOPYWINDOW ");
|
|
|
|
RegionTranslate(prgnSrc, -dx, -dy);
|
|
}
|
|
|
|
/*
|
|
* RootlessResizeCopyWindow
|
|
* CopyWindow used during ResizeWindow for gravity moves. Based on
|
|
* fbCopyWindow. The original always draws on the root pixmap, which
|
|
* we don't have. Instead, draw on the parent window's pixmap.
|
|
* Resize version: the old location's pixels are in gResizeCopyWindowSource.
|
|
*/
|
|
static void
|
|
RootlessResizeCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg,
|
|
RegionPtr prgnSrc)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
RegionRec rgnDst;
|
|
int dx, dy;
|
|
|
|
RL_DEBUG_MSG("resizecopywindowFB start (win 0x%x) ", pWin);
|
|
|
|
/* Don't unwrap pScreen->CopyWindow.
|
|
The bogus rewrap with RootlessCopyWindow causes a crash if
|
|
CopyWindow is called again during the same resize. */
|
|
|
|
if (gResizeDeathCount == 0)
|
|
return;
|
|
|
|
RootlessStartDrawing(pWin);
|
|
|
|
dx = ptOldOrg.x - pWin->drawable.x;
|
|
dy = ptOldOrg.y - pWin->drawable.y;
|
|
RegionTranslate(prgnSrc, -dx, -dy);
|
|
RegionNull(&rgnDst);
|
|
RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
|
|
|
|
if (gResizeDeathCount == 1) {
|
|
/* Simple case, we only have a single source pixmap. */
|
|
|
|
miCopyRegion(&gResizeDeathPix[0]->drawable,
|
|
&pScreen->GetWindowPixmap(pWin)->drawable, 0,
|
|
&rgnDst, dx, dy, fbCopyWindowProc, 0, 0);
|
|
}
|
|
else {
|
|
int i;
|
|
RegionRec clip, clipped;
|
|
|
|
/* More complex case, N source pixmaps (usually two). So we
|
|
intersect the destination with each source and copy those bits. */
|
|
|
|
for (i = 0; i < gResizeDeathCount; i++) {
|
|
RegionInit(&clip, gResizeDeathBounds + 0, 1);
|
|
RegionNull(&clipped);
|
|
RegionIntersect(&rgnDst, &clip, &clipped);
|
|
|
|
miCopyRegion(&gResizeDeathPix[i]->drawable,
|
|
&pScreen->GetWindowPixmap(pWin)->drawable, 0,
|
|
&clipped, dx, dy, fbCopyWindowProc, 0, 0);
|
|
|
|
RegionUninit(&clipped);
|
|
RegionUninit(&clip);
|
|
}
|
|
}
|
|
|
|
/* Don't update - resize will update everything */
|
|
RegionUninit(&rgnDst);
|
|
|
|
fbValidateDrawable(&pWin->drawable);
|
|
|
|
RL_DEBUG_MSG("resizecopywindowFB end\n");
|
|
}
|
|
|
|
/*
|
|
* RootlessCopyWindow
|
|
* Update *new* location of window. Old location is redrawn with
|
|
* PaintWindow. Cloned from fbCopyWindow.
|
|
* The original always draws on the root pixmap, which we don't have.
|
|
* Instead, draw on the parent window's pixmap.
|
|
*/
|
|
void
|
|
RootlessCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
RegionRec rgnDst;
|
|
int dx, dy;
|
|
BoxPtr extents;
|
|
int area;
|
|
|
|
RL_DEBUG_MSG("copywindowFB start (win 0x%x) ", pWin);
|
|
|
|
SCREEN_UNWRAP(pScreen, CopyWindow);
|
|
|
|
dx = ptOldOrg.x - pWin->drawable.x;
|
|
dy = ptOldOrg.y - pWin->drawable.y;
|
|
RegionTranslate(prgnSrc, -dx, -dy);
|
|
|
|
RegionNull(&rgnDst);
|
|
RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
|
|
|
|
extents = RegionExtents(&rgnDst);
|
|
area = (extents->x2 - extents->x1) * (extents->y2 - extents->y1);
|
|
|
|
/* If the area exceeds threshold, use the implementation's
|
|
accelerated version. */
|
|
if (area > rootless_CopyWindow_threshold &&
|
|
SCREENREC(pScreen)->imp->CopyWindow) {
|
|
RootlessWindowRec *winRec;
|
|
WindowPtr top;
|
|
|
|
top = TopLevelParent(pWin);
|
|
if (top == NULL) {
|
|
RL_DEBUG_MSG("no parent\n");
|
|
goto out;
|
|
}
|
|
|
|
winRec = WINREC(top);
|
|
if (winRec == NULL) {
|
|
RL_DEBUG_MSG("not framed\n");
|
|
goto out;
|
|
}
|
|
|
|
/* Move region to window local coords */
|
|
RegionTranslate(&rgnDst, -winRec->x, -winRec->y);
|
|
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
|
|
SCREENREC(pScreen)->imp->CopyWindow(winRec->wid,
|
|
RegionNumRects(&rgnDst),
|
|
RegionRects(&rgnDst), dx, dy);
|
|
}
|
|
else {
|
|
RootlessStartDrawing(pWin);
|
|
|
|
miCopyRegion((DrawablePtr) pWin, (DrawablePtr) pWin,
|
|
0, &rgnDst, dx, dy, fbCopyWindowProc, 0, 0);
|
|
|
|
/* prgnSrc has been translated to dst position */
|
|
RootlessDamageRegion(pWin, prgnSrc);
|
|
}
|
|
|
|
out:
|
|
RegionUninit(&rgnDst);
|
|
fbValidateDrawable(&pWin->drawable);
|
|
|
|
SCREEN_WRAP(pScreen, CopyWindow);
|
|
|
|
RL_DEBUG_MSG("copywindowFB end\n");
|
|
}
|
|
|
|
void
|
|
RootlessPaintWindow(WindowPtr pWin, RegionPtr prgn, int what)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
|
|
if (IsFramedWindow(pWin)) {
|
|
RootlessStartDrawing(pWin);
|
|
RootlessDamageRegion(pWin, prgn);
|
|
|
|
if (pWin->backgroundState == ParentRelative) {
|
|
if ((what == PW_BACKGROUND) ||
|
|
(what == PW_BORDER && !pWin->borderIsPixel))
|
|
RootlessSetPixmapOfAncestors(pWin);
|
|
}
|
|
}
|
|
|
|
SCREEN_UNWRAP(pScreen, PaintWindow);
|
|
pScreen->PaintWindow(pWin, prgn, what);
|
|
SCREEN_WRAP(pScreen, PaintWindow);
|
|
}
|
|
|
|
/*
|
|
* Window resize procedures
|
|
*/
|
|
|
|
enum {
|
|
WIDTH_SMALLER = 1,
|
|
HEIGHT_SMALLER = 2,
|
|
};
|
|
|
|
/*
|
|
* ResizeWeighting
|
|
* Choose gravity to avoid local copies. Do that by looking for
|
|
* a corner that doesn't move _relative to the screen_.
|
|
*/
|
|
static inline unsigned int
|
|
ResizeWeighting(int oldX1, int oldY1, int oldX2, int oldY2, int oldBW,
|
|
int newX1, int newY1, int newX2, int newY2, int newBW)
|
|
{
|
|
#ifdef ROOTLESS_RESIZE_GRAVITY
|
|
if (newBW != oldBW)
|
|
return RL_GRAVITY_NONE;
|
|
|
|
if (newX1 == oldX1 && newY1 == oldY1)
|
|
return RL_GRAVITY_NORTH_WEST;
|
|
else if (newX1 == oldX1 && newY2 == oldY2)
|
|
return RL_GRAVITY_SOUTH_WEST;
|
|
else if (newX2 == oldX2 && newY2 == oldY2)
|
|
return RL_GRAVITY_SOUTH_EAST;
|
|
else if (newX2 == oldX2 && newY1 == oldY1)
|
|
return RL_GRAVITY_NORTH_EAST;
|
|
else
|
|
return RL_GRAVITY_NONE;
|
|
#else
|
|
return RL_GRAVITY_NONE;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* StartFrameResize
|
|
* Prepare to resize a top-level window. The old window's pixels are
|
|
* saved and the implementation is told to change the window size.
|
|
* (x,y,w,h) is outer frame of window (outside border)
|
|
*/
|
|
static Bool
|
|
StartFrameResize(WindowPtr pWin, Bool gravity,
|
|
int oldX, int oldY, int oldW, int oldH, int oldBW,
|
|
int newX, int newY, int newW, int newH, int newBW)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
Bool need_window_source = FALSE, resize_after = FALSE;
|
|
|
|
BoxRec rect;
|
|
int oldX2, newX2;
|
|
int oldY2, newY2;
|
|
unsigned int weight;
|
|
|
|
oldX2 = oldX + oldW, newX2 = newX + newW;
|
|
oldY2 = oldY + oldH, newY2 = newY + newH;
|
|
|
|
/* Decide which resize weighting to use */
|
|
weight = ResizeWeighting(oldX, oldY, oldW, oldH, oldBW,
|
|
newX, newY, newW, newH, newBW);
|
|
|
|
/* Compute intersection between old and new rects */
|
|
rect.x1 = max(oldX, newX);
|
|
rect.y1 = max(oldY, newY);
|
|
rect.x2 = min(oldX2, newX2);
|
|
rect.y2 = min(oldY2, newY2);
|
|
|
|
RL_DEBUG_MSG("RESIZE TOPLEVEL WINDOW with gravity %i ", gravity);
|
|
RL_DEBUG_MSG("%d %d %d %d %d %d %d %d %d %d\n",
|
|
oldX, oldY, oldW, oldH, oldBW, newX, newY, newW, newH, newBW);
|
|
|
|
RootlessRedisplay(pWin);
|
|
|
|
/* If gravity is true, then we need to have a way of recovering all
|
|
the original bits in the window for when X rearranges the contents
|
|
based on the various gravity settings. The obvious way is to just
|
|
snapshot the entire backing store before resizing it, but that
|
|
it slow on large windows.
|
|
|
|
So the optimization here is to use the implementation's resize
|
|
weighting options (if available) to allow us to reason about what
|
|
is left in the backing store after the resize. We can then only
|
|
copy what won't be there after the resize, and do a two-stage copy
|
|
operation.
|
|
|
|
Most of these optimizations are only applied when the top-left
|
|
corner of the window is fixed, since that's the common case. They
|
|
could probably be extended with some thought. */
|
|
|
|
gResizeDeathCount = 0;
|
|
|
|
if (gravity && weight == RL_GRAVITY_NORTH_WEST) {
|
|
unsigned int code = 0;
|
|
|
|
/* Top left corner is anchored. We never need to copy the
|
|
entire window. */
|
|
|
|
need_window_source = TRUE;
|
|
|
|
/* These comparisons were chosen to avoid setting bits when the sizes
|
|
are the same. (So the fastest case automatically gets taken when
|
|
dimensions are unchanging.) */
|
|
|
|
if (newW < oldW)
|
|
code |= WIDTH_SMALLER;
|
|
if (newH < oldH)
|
|
code |= HEIGHT_SMALLER;
|
|
|
|
if (((code ^ (code >> 1)) & 1) == 0) {
|
|
/* Both dimensions are either getting larger, or both
|
|
are getting smaller. No need to copy anything. */
|
|
|
|
if (code == (WIDTH_SMALLER | HEIGHT_SMALLER)) {
|
|
/* Since the window is getting smaller, we can do gravity
|
|
repair on it with it's current size, then resize it
|
|
afterwards. */
|
|
|
|
resize_after = TRUE;
|
|
}
|
|
|
|
gResizeDeathCount = 1;
|
|
}
|
|
else {
|
|
unsigned int copy_rowbytes, Bpp;
|
|
unsigned int copy_rect_width, copy_rect_height;
|
|
BoxRec copy_rect;
|
|
|
|
/* We can get away with a partial copy. 'rect' is the
|
|
intersection between old and new bounds, so copy
|
|
everything to the right of or below the intersection. */
|
|
|
|
RootlessStartDrawing(pWin);
|
|
|
|
if (code == WIDTH_SMALLER) {
|
|
copy_rect.x1 = rect.x2;
|
|
copy_rect.y1 = rect.y1;
|
|
copy_rect.x2 = oldX2;
|
|
copy_rect.y2 = oldY2;
|
|
}
|
|
else if (code == HEIGHT_SMALLER) {
|
|
copy_rect.x1 = rect.x1;
|
|
copy_rect.y1 = rect.y2;
|
|
copy_rect.x2 = oldX2;
|
|
copy_rect.y2 = oldY2;
|
|
}
|
|
else
|
|
OsAbort();
|
|
|
|
Bpp = winRec->win->drawable.bitsPerPixel / 8;
|
|
copy_rect_width = copy_rect.x2 - copy_rect.x1;
|
|
copy_rect_height = copy_rect.y2 - copy_rect.y1;
|
|
copy_rowbytes = ((copy_rect_width * Bpp) + 31) & ~31;
|
|
gResizeDeathBits = xallocarray(copy_rowbytes, copy_rect_height);
|
|
|
|
if (copy_rect_width * copy_rect_height >
|
|
rootless_CopyBytes_threshold &&
|
|
SCREENREC(pScreen)->imp->CopyBytes) {
|
|
SCREENREC(pScreen)->imp->CopyBytes(copy_rect_width * Bpp,
|
|
copy_rect_height,
|
|
((char *) winRec->pixelData)
|
|
+
|
|
((copy_rect.y1 -
|
|
oldY) *
|
|
winRec->bytesPerRow)
|
|
+ (copy_rect.x1 -
|
|
oldX) * Bpp,
|
|
winRec->bytesPerRow,
|
|
gResizeDeathBits,
|
|
copy_rowbytes);
|
|
}
|
|
else {
|
|
fbBlt((FbBits *) (winRec->pixelData
|
|
+
|
|
((copy_rect.y1 - oldY) * winRec->bytesPerRow)
|
|
+ (copy_rect.x1 - oldX) * Bpp),
|
|
winRec->bytesPerRow / sizeof(FbBits), 0,
|
|
(FbBits *) gResizeDeathBits,
|
|
copy_rowbytes / sizeof(FbBits), 0, copy_rect_width * Bpp,
|
|
copy_rect_height, GXcopy, FB_ALLONES, Bpp, 0, 0);
|
|
}
|
|
|
|
gResizeDeathBounds[1] = copy_rect;
|
|
gResizeDeathPix[1]
|
|
= GetScratchPixmapHeader(pScreen, copy_rect_width,
|
|
copy_rect_height,
|
|
winRec->win->drawable.depth,
|
|
winRec->win->drawable.bitsPerPixel,
|
|
winRec->bytesPerRow,
|
|
(void *) gResizeDeathBits);
|
|
|
|
SetPixmapBaseToScreen(gResizeDeathPix[1],
|
|
copy_rect.x1, copy_rect.y1);
|
|
|
|
gResizeDeathCount = 2;
|
|
}
|
|
}
|
|
else if (gravity) {
|
|
/* The general case. Just copy everything. */
|
|
|
|
RootlessStartDrawing(pWin);
|
|
|
|
gResizeDeathBits = xallocarray(winRec->bytesPerRow, winRec->height);
|
|
|
|
memcpy(gResizeDeathBits, winRec->pixelData,
|
|
winRec->bytesPerRow * winRec->height);
|
|
|
|
gResizeDeathBounds[0] = (BoxRec) {
|
|
oldX, oldY, oldX2, oldY2};
|
|
gResizeDeathPix[0]
|
|
= GetScratchPixmapHeader(pScreen, winRec->width,
|
|
winRec->height,
|
|
winRec->win->drawable.depth,
|
|
winRec->win->drawable.bitsPerPixel,
|
|
winRec->bytesPerRow,
|
|
(void *) gResizeDeathBits);
|
|
|
|
SetPixmapBaseToScreen(gResizeDeathPix[0], oldX, oldY);
|
|
gResizeDeathCount = 1;
|
|
}
|
|
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
|
|
winRec->x = newX;
|
|
winRec->y = newY;
|
|
winRec->width = newW;
|
|
winRec->height = newH;
|
|
winRec->borderWidth = newBW;
|
|
|
|
/* Unless both dimensions are getting smaller, Resize the frame
|
|
before doing gravity repair */
|
|
|
|
if (!resize_after) {
|
|
SCREENREC(pScreen)->imp->ResizeFrame(winRec->wid, pScreen,
|
|
newX + SCREEN_TO_GLOBAL_X,
|
|
newY + SCREEN_TO_GLOBAL_Y,
|
|
newW, newH, weight);
|
|
}
|
|
|
|
RootlessStartDrawing(pWin);
|
|
|
|
/* If necessary, create a source pixmap pointing at the current
|
|
window bits. */
|
|
|
|
if (need_window_source) {
|
|
gResizeDeathBounds[0] = (BoxRec) {
|
|
oldX, oldY, oldX2, oldY2};
|
|
gResizeDeathPix[0]
|
|
= GetScratchPixmapHeader(pScreen, oldW, oldH,
|
|
winRec->win->drawable.depth,
|
|
winRec->win->drawable.bitsPerPixel,
|
|
winRec->bytesPerRow, winRec->pixelData);
|
|
|
|
SetPixmapBaseToScreen(gResizeDeathPix[0], oldX, oldY);
|
|
}
|
|
|
|
/* Use custom CopyWindow when moving gravity bits around
|
|
ResizeWindow assumes the old window contents are in the same
|
|
pixmap, but here they're in deathPix instead. */
|
|
|
|
if (gravity) {
|
|
gResizeOldCopyWindowProc = pScreen->CopyWindow;
|
|
pScreen->CopyWindow = RootlessResizeCopyWindow;
|
|
}
|
|
|
|
/* If we can't rely on the window server preserving the bits we
|
|
need in the position we need, copy the pixels in the
|
|
intersection from src to dst. ResizeWindow assumes these pixels
|
|
are already present when making gravity adjustments. pWin
|
|
currently has new-sized pixmap but is in old position.
|
|
|
|
FIXME: border width change! (?) */
|
|
|
|
if (gravity && weight == RL_GRAVITY_NONE) {
|
|
PixmapPtr src, dst;
|
|
|
|
assert(gResizeDeathCount == 1);
|
|
|
|
src = gResizeDeathPix[0];
|
|
dst = pScreen->GetWindowPixmap(pWin);
|
|
|
|
RL_DEBUG_MSG("Resize copy rect %d %d %d %d\n",
|
|
rect.x1, rect.y1, rect.x2, rect.y2);
|
|
|
|
/* rect is the intersection of the old location and new location */
|
|
if (BOX_NOT_EMPTY(rect) && src != NULL && dst != NULL) {
|
|
/* The window drawable still has the old frame position, which
|
|
means that DST doesn't actually point at the origin of our
|
|
physical backing store when adjusted by the drawable.x,y
|
|
position. So sneakily adjust it temporarily while copying.. */
|
|
|
|
((PixmapPtr) dst)->devPrivate.ptr = winRec->pixelData;
|
|
SetPixmapBaseToScreen(dst, newX, newY);
|
|
|
|
fbCopyWindowProc(&src->drawable, &dst->drawable, NULL,
|
|
&rect, 1, 0, 0, FALSE, FALSE, 0, 0);
|
|
|
|
((PixmapPtr) dst)->devPrivate.ptr = winRec->pixelData;
|
|
SetPixmapBaseToScreen(dst, oldX, oldY);
|
|
}
|
|
}
|
|
|
|
return resize_after;
|
|
}
|
|
|
|
static void
|
|
FinishFrameResize(WindowPtr pWin, Bool gravity, int oldX, int oldY,
|
|
unsigned int oldW, unsigned int oldH, unsigned int oldBW,
|
|
int newX, int newY, unsigned int newW, unsigned int newH,
|
|
unsigned int newBW, Bool resize_now)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
int i;
|
|
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
|
|
if (resize_now) {
|
|
unsigned int weight;
|
|
|
|
/* We didn't resize anything earlier, so do it now, now that
|
|
we've finished gravitating the bits. */
|
|
|
|
weight = ResizeWeighting(oldX, oldY, oldW, oldH, oldBW,
|
|
newX, newY, newW, newH, newBW);
|
|
|
|
SCREENREC(pScreen)->imp->ResizeFrame(winRec->wid, pScreen,
|
|
newX + SCREEN_TO_GLOBAL_X,
|
|
newY + SCREEN_TO_GLOBAL_Y,
|
|
newW, newH, weight);
|
|
}
|
|
|
|
/* Redraw everything. FIXME: there must be times when we don't need
|
|
to do this. Perhaps when top-left weighting and no gravity? */
|
|
|
|
RootlessDamageRect(pWin, -newBW, -newBW, newW, newH);
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
if (gResizeDeathPix[i] != NULL) {
|
|
FreeScratchPixmapHeader(gResizeDeathPix[i]);
|
|
gResizeDeathPix[i] = NULL;
|
|
}
|
|
}
|
|
|
|
free(gResizeDeathBits);
|
|
gResizeDeathBits = NULL;
|
|
|
|
if (gravity) {
|
|
pScreen->CopyWindow = gResizeOldCopyWindowProc;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* RootlessMoveWindow
|
|
* If kind==VTOther, window border is resizing (and borderWidth is
|
|
* already changed!!@#$) This case works like window resize, not move.
|
|
*/
|
|
void
|
|
RootlessMoveWindow(WindowPtr pWin, int x, int y, WindowPtr pSib, VTKind kind)
|
|
{
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
CopyWindowProcPtr oldCopyWindowProc = NULL;
|
|
int oldX = 0, oldY = 0, newX = 0, newY = 0;
|
|
unsigned int oldW = 0, oldH = 0, oldBW = 0;
|
|
unsigned int newW = 0, newH = 0, newBW = 0;
|
|
Bool resize_after = FALSE;
|
|
RegionRec saveRoot;
|
|
|
|
RL_DEBUG_MSG("movewindow start \n");
|
|
|
|
if (winRec) {
|
|
if (kind == VTMove) {
|
|
oldX = winRec->x;
|
|
oldY = winRec->y;
|
|
RootlessRedisplay(pWin);
|
|
RootlessStartDrawing(pWin);
|
|
}
|
|
else {
|
|
RL_DEBUG_MSG("movewindow border resizing ");
|
|
|
|
oldBW = winRec->borderWidth;
|
|
oldX = winRec->x;
|
|
oldY = winRec->y;
|
|
oldW = winRec->width;
|
|
oldH = winRec->height;
|
|
|
|
newBW = wBorderWidth(pWin);
|
|
newX = x;
|
|
newY = y;
|
|
newW = pWin->drawable.width + 2 * newBW;
|
|
newH = pWin->drawable.height + 2 * newBW;
|
|
|
|
resize_after = StartFrameResize(pWin, FALSE,
|
|
oldX, oldY, oldW, oldH, oldBW,
|
|
newX, newY, newW, newH, newBW);
|
|
}
|
|
}
|
|
|
|
HUGE_ROOT(pWin);
|
|
SCREEN_UNWRAP(pScreen, MoveWindow);
|
|
|
|
if (winRec) {
|
|
oldCopyWindowProc = pScreen->CopyWindow;
|
|
pScreen->CopyWindow = RootlessNoCopyWindow;
|
|
}
|
|
pScreen->MoveWindow(pWin, x, y, pSib, kind);
|
|
if (winRec) {
|
|
pScreen->CopyWindow = oldCopyWindowProc;
|
|
}
|
|
|
|
NORMAL_ROOT(pWin);
|
|
SCREEN_WRAP(pScreen, MoveWindow);
|
|
|
|
if (winRec) {
|
|
if (kind == VTMove) {
|
|
winRec->x = x;
|
|
winRec->y = y;
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
SCREENREC(pScreen)->imp->MoveFrame(winRec->wid, pScreen,
|
|
x + SCREEN_TO_GLOBAL_X,
|
|
y + SCREEN_TO_GLOBAL_Y);
|
|
}
|
|
else {
|
|
FinishFrameResize(pWin, FALSE, oldX, oldY, oldW, oldH, oldBW,
|
|
newX, newY, newW, newH, newBW, resize_after);
|
|
}
|
|
}
|
|
|
|
RL_DEBUG_MSG("movewindow end\n");
|
|
}
|
|
|
|
/*
|
|
* RootlessResizeWindow
|
|
* Note: (x, y, w, h) as passed to this procedure don't match the frame
|
|
* definition. (x,y) is corner of very outer edge, *outside* border.
|
|
* w,h is width and height *inside* border, *ignoring* border width.
|
|
* The rect (x, y, w, h) doesn't mean anything. (x, y, w+2*bw, h+2*bw)
|
|
* is total rect and (x+bw, y+bw, w, h) is inner rect.
|
|
*/
|
|
void
|
|
RootlessResizeWindow(WindowPtr pWin, int x, int y,
|
|
unsigned int w, unsigned int h, WindowPtr pSib)
|
|
{
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
int oldX = 0, oldY = 0, newX = 0, newY = 0;
|
|
unsigned int oldW = 0, oldH = 0, oldBW = 0, newW = 0, newH = 0, newBW = 0;
|
|
Bool resize_after = FALSE;
|
|
RegionRec saveRoot;
|
|
|
|
RL_DEBUG_MSG("resizewindow start (win 0x%x) ", pWin);
|
|
|
|
if (pWin->parent) {
|
|
if (winRec) {
|
|
oldBW = winRec->borderWidth;
|
|
oldX = winRec->x;
|
|
oldY = winRec->y;
|
|
oldW = winRec->width;
|
|
oldH = winRec->height;
|
|
|
|
newBW = oldBW;
|
|
newX = x;
|
|
newY = y;
|
|
newW = w + 2 * newBW;
|
|
newH = h + 2 * newBW;
|
|
|
|
resize_after = StartFrameResize(pWin, TRUE,
|
|
oldX, oldY, oldW, oldH, oldBW,
|
|
newX, newY, newW, newH, newBW);
|
|
}
|
|
|
|
HUGE_ROOT(pWin);
|
|
SCREEN_UNWRAP(pScreen, ResizeWindow);
|
|
pScreen->ResizeWindow(pWin, x, y, w, h, pSib);
|
|
SCREEN_WRAP(pScreen, ResizeWindow);
|
|
NORMAL_ROOT(pWin);
|
|
|
|
if (winRec) {
|
|
FinishFrameResize(pWin, TRUE, oldX, oldY, oldW, oldH, oldBW,
|
|
newX, newY, newW, newH, newBW, resize_after);
|
|
}
|
|
}
|
|
else {
|
|
/* Special case for resizing the root window */
|
|
BoxRec box;
|
|
|
|
pWin->drawable.x = x;
|
|
pWin->drawable.y = y;
|
|
pWin->drawable.width = w;
|
|
pWin->drawable.height = h;
|
|
|
|
box.x1 = x;
|
|
box.y1 = y;
|
|
box.x2 = x + w;
|
|
box.y2 = y + h;
|
|
RegionUninit(&pWin->winSize);
|
|
RegionInit(&pWin->winSize, &box, 1);
|
|
RegionCopy(&pWin->borderSize, &pWin->winSize);
|
|
RegionCopy(&pWin->clipList, &pWin->winSize);
|
|
RegionCopy(&pWin->borderClip, &pWin->winSize);
|
|
|
|
if (winRec) {
|
|
SCREENREC(pScreen)->imp->ResizeFrame(winRec->wid, pScreen,
|
|
x + SCREEN_TO_GLOBAL_X,
|
|
y + SCREEN_TO_GLOBAL_Y,
|
|
w, h, RL_GRAVITY_NONE);
|
|
}
|
|
|
|
miSendExposures(pWin, &pWin->borderClip,
|
|
pWin->drawable.x, pWin->drawable.y);
|
|
}
|
|
|
|
RL_DEBUG_MSG("resizewindow end\n");
|
|
}
|
|
|
|
/*
|
|
* RootlessRepositionWindow
|
|
* Called by the implementation when a window needs to be repositioned to
|
|
* its correct location on the screen. This routine is typically needed
|
|
* due to changes in the underlying window system, such as a screen layout
|
|
* change.
|
|
*/
|
|
void
|
|
RootlessRepositionWindow(WindowPtr pWin)
|
|
{
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
|
|
if (winRec == NULL)
|
|
return;
|
|
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
SCREENREC(pScreen)->imp->MoveFrame(winRec->wid, pScreen,
|
|
winRec->x + SCREEN_TO_GLOBAL_X,
|
|
winRec->y + SCREEN_TO_GLOBAL_Y);
|
|
|
|
RootlessReorderWindow(pWin);
|
|
}
|
|
|
|
/*
|
|
* RootlessReparentWindow
|
|
* Called after a window has been reparented. Generally windows are not
|
|
* framed until they are mapped. However, a window may be framed early by the
|
|
* implementation calling RootlessFrameForWindow. (e.g. this could be needed
|
|
* to attach a VRAM surface to it.) If the window is subsequently reparented
|
|
* by the window manager before being mapped, we need to give the frame to
|
|
* the new top-level window.
|
|
*/
|
|
void
|
|
RootlessReparentWindow(WindowPtr pWin, WindowPtr pPriorParent)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
WindowPtr pTopWin;
|
|
|
|
/* Check that window is not top-level now, but used to be. */
|
|
if (IsRoot(pWin) || IsRoot(pWin->parent)
|
|
|| IsTopLevel(pWin) || winRec == NULL) {
|
|
goto out;
|
|
}
|
|
|
|
/* If the formerly top-level window has a frame, we want to give the
|
|
frame to its new top-level parent. If we can't do that, we'll just
|
|
have to jettison it... */
|
|
|
|
pTopWin = TopLevelParent(pWin);
|
|
assert(pTopWin != pWin);
|
|
|
|
pWin->unhittable = FALSE;
|
|
|
|
DeleteProperty(serverClient, pWin, xa_native_window_id());
|
|
|
|
if (WINREC(pTopWin) != NULL) {
|
|
/* We're screwed. */
|
|
RootlessDestroyFrame(pWin, winRec);
|
|
}
|
|
else {
|
|
if (!pTopWin->realized && pWin->realized) {
|
|
SCREENREC(pScreen)->imp->UnmapFrame(winRec->wid);
|
|
}
|
|
|
|
/* Switch the frame record from one to the other. */
|
|
|
|
SETWINREC(pWin, NULL);
|
|
SETWINREC(pTopWin, winRec);
|
|
|
|
RootlessInitializeFrame(pTopWin, winRec);
|
|
RootlessReshapeFrame(pTopWin);
|
|
|
|
SCREENREC(pScreen)->imp->ResizeFrame(winRec->wid, pScreen,
|
|
winRec->x + SCREEN_TO_GLOBAL_X,
|
|
winRec->y + SCREEN_TO_GLOBAL_Y,
|
|
winRec->width, winRec->height,
|
|
RL_GRAVITY_NONE);
|
|
|
|
if (SCREENREC(pScreen)->imp->SwitchWindow) {
|
|
SCREENREC(pScreen)->imp->SwitchWindow(winRec, pWin);
|
|
}
|
|
|
|
if (pTopWin->realized && !pWin->realized)
|
|
winRec->is_reorder_pending = TRUE;
|
|
}
|
|
|
|
out:
|
|
if (SCREENREC(pScreen)->ReparentWindow) {
|
|
SCREEN_UNWRAP(pScreen, ReparentWindow);
|
|
pScreen->ReparentWindow(pWin, pPriorParent);
|
|
SCREEN_WRAP(pScreen, ReparentWindow);
|
|
}
|
|
}
|
|
|
|
void
|
|
RootlessFlushWindowColormap(WindowPtr pWin)
|
|
{
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
|
|
if (winRec == NULL)
|
|
return;
|
|
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
|
|
if (SCREENREC(pScreen)->imp->UpdateColormap)
|
|
SCREENREC(pScreen)->imp->UpdateColormap(winRec->wid, pScreen);
|
|
}
|
|
|
|
/*
|
|
* RootlessChangeBorderWidth
|
|
* FIXME: untested!
|
|
* pWin inside corner stays the same; pWin->drawable.[xy] stays the same
|
|
* Frame moves and resizes.
|
|
*/
|
|
void
|
|
RootlessChangeBorderWidth(WindowPtr pWin, unsigned int width)
|
|
{
|
|
RegionRec saveRoot;
|
|
Bool resize_after = FALSE;
|
|
|
|
RL_DEBUG_MSG("change border width ");
|
|
|
|
if (width != wBorderWidth(pWin)) {
|
|
RootlessWindowRec *winRec = WINREC(pWin);
|
|
int oldX = 0, oldY = 0, newX = 0, newY = 0;
|
|
unsigned int oldW = 0, oldH = 0, oldBW = 0;
|
|
unsigned int newW = 0, newH = 0, newBW = 0;
|
|
|
|
if (winRec) {
|
|
oldBW = winRec->borderWidth;
|
|
oldX = winRec->x;
|
|
oldY = winRec->y;
|
|
oldW = winRec->width;
|
|
oldH = winRec->height;
|
|
|
|
newBW = width;
|
|
newX = pWin->drawable.x - newBW;
|
|
newY = pWin->drawable.y - newBW;
|
|
newW = pWin->drawable.width + 2 * newBW;
|
|
newH = pWin->drawable.height + 2 * newBW;
|
|
|
|
resize_after = StartFrameResize(pWin, FALSE,
|
|
oldX, oldY, oldW, oldH, oldBW,
|
|
newX, newY, newW, newH, newBW);
|
|
}
|
|
|
|
HUGE_ROOT(pWin);
|
|
SCREEN_UNWRAP(pWin->drawable.pScreen, ChangeBorderWidth);
|
|
pWin->drawable.pScreen->ChangeBorderWidth(pWin, width);
|
|
SCREEN_WRAP(pWin->drawable.pScreen, ChangeBorderWidth);
|
|
NORMAL_ROOT(pWin);
|
|
|
|
if (winRec) {
|
|
FinishFrameResize(pWin, FALSE, oldX, oldY, oldW, oldH, oldBW,
|
|
newX, newY, newW, newH, newBW, resize_after);
|
|
}
|
|
}
|
|
|
|
RL_DEBUG_MSG("change border width end\n");
|
|
}
|
|
|
|
/*
|
|
* RootlessOrderAllWindows
|
|
* Brings all X11 windows to the top of the window stack
|
|
* (i.e in front of Aqua windows) -- called when X11.app is given focus
|
|
*/
|
|
void
|
|
RootlessOrderAllWindows(Bool include_unhitable)
|
|
{
|
|
int i;
|
|
WindowPtr pWin;
|
|
|
|
if (windows_hidden)
|
|
return;
|
|
|
|
RL_DEBUG_MSG("RootlessOrderAllWindows() ");
|
|
for (i = 0; i < screenInfo.numScreens; i++) {
|
|
if (screenInfo.screens[i] == NULL)
|
|
continue;
|
|
pWin = screenInfo.screens[i]->root;
|
|
if (pWin == NULL)
|
|
continue;
|
|
|
|
for (pWin = pWin->firstChild; pWin != NULL; pWin = pWin->nextSib) {
|
|
if (!pWin->realized)
|
|
continue;
|
|
if (RootlessEnsureFrame(pWin) == NULL)
|
|
continue;
|
|
if (!include_unhitable && pWin->unhittable)
|
|
continue;
|
|
RootlessReorderWindow(pWin);
|
|
}
|
|
}
|
|
RL_DEBUG_MSG("RootlessOrderAllWindows() done");
|
|
}
|
|
|
|
void
|
|
RootlessEnableRoot(ScreenPtr pScreen)
|
|
{
|
|
WindowPtr pRoot;
|
|
|
|
pRoot = pScreen->root;
|
|
|
|
RootlessEnsureFrame(pRoot);
|
|
(*pScreen->ClearToBackground) (pRoot, 0, 0, 0, 0, TRUE);
|
|
RootlessReorderWindow(pRoot);
|
|
}
|
|
|
|
void
|
|
RootlessDisableRoot(ScreenPtr pScreen)
|
|
{
|
|
WindowPtr pRoot;
|
|
RootlessWindowRec *winRec;
|
|
|
|
pRoot = pScreen->root;
|
|
winRec = WINREC(pRoot);
|
|
|
|
if (NULL == winRec)
|
|
return;
|
|
|
|
RootlessDestroyFrame(pRoot, winRec);
|
|
DeleteProperty(serverClient, pRoot, xa_native_window_id());
|
|
}
|
|
|
|
void
|
|
RootlessHideAllWindows(void)
|
|
{
|
|
int i;
|
|
ScreenPtr pScreen;
|
|
WindowPtr pWin;
|
|
RootlessWindowRec *winRec;
|
|
|
|
if (windows_hidden)
|
|
return;
|
|
|
|
windows_hidden = TRUE;
|
|
|
|
for (i = 0; i < screenInfo.numScreens; i++) {
|
|
pScreen = screenInfo.screens[i];
|
|
if (pScreen == NULL)
|
|
continue;
|
|
pWin = pScreen->root;
|
|
if (pWin == NULL)
|
|
continue;
|
|
|
|
for (pWin = pWin->firstChild; pWin != NULL; pWin = pWin->nextSib) {
|
|
if (!pWin->realized)
|
|
continue;
|
|
|
|
RootlessStopDrawing(pWin, FALSE);
|
|
|
|
winRec = WINREC(pWin);
|
|
if (winRec != NULL) {
|
|
if (SCREENREC(pScreen)->imp->HideWindow)
|
|
SCREENREC(pScreen)->imp->HideWindow(winRec->wid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
RootlessShowAllWindows(void)
|
|
{
|
|
int i;
|
|
ScreenPtr pScreen;
|
|
WindowPtr pWin;
|
|
RootlessWindowRec *winRec;
|
|
|
|
if (!windows_hidden)
|
|
return;
|
|
|
|
windows_hidden = FALSE;
|
|
|
|
for (i = 0; i < screenInfo.numScreens; i++) {
|
|
pScreen = screenInfo.screens[i];
|
|
if (pScreen == NULL)
|
|
continue;
|
|
pWin = pScreen->root;
|
|
if (pWin == NULL)
|
|
continue;
|
|
|
|
for (pWin = pWin->firstChild; pWin != NULL; pWin = pWin->nextSib) {
|
|
if (!pWin->realized)
|
|
continue;
|
|
|
|
winRec = RootlessEnsureFrame(pWin);
|
|
if (winRec == NULL)
|
|
continue;
|
|
|
|
RootlessReorderWindow(pWin);
|
|
}
|
|
|
|
RootlessScreenExpose(pScreen);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* SetPixmapOfAncestors
|
|
* Set the Pixmaps on all ParentRelative windows up the ancestor chain.
|
|
*/
|
|
void
|
|
RootlessSetPixmapOfAncestors(WindowPtr pWin)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
WindowPtr topWin = TopLevelParent(pWin);
|
|
RootlessWindowRec *topWinRec = WINREC(topWin);
|
|
|
|
while (pWin->backgroundState == ParentRelative) {
|
|
if (pWin == topWin) {
|
|
// disallow ParentRelative background state on top level
|
|
XID pixel = 0;
|
|
|
|
ChangeWindowAttributes(pWin, CWBackPixel, &pixel, serverClient);
|
|
RL_DEBUG_MSG("Cleared ParentRelative on 0x%x.\n", pWin);
|
|
break;
|
|
}
|
|
|
|
pWin = pWin->parent;
|
|
pScreen->SetWindowPixmap(pWin, topWinRec->pixmap);
|
|
}
|
|
}
|