/*
* Change frame stacking.
*/
static void xprRestackFrame(RootlessFrameID wid, RootlessFrameID nextWid) {
xp_window_changes wc;
unsigned int mask = XP_STACKING;
TA_SERVER();
/* Stack frame below nextWid it if it exists, or raise
frame above everything otherwise. */
if(nextWid == NULL) {
wc.stack_mode = XP_MAPPED_ABOVE;
wc.sibling = 0;
} else {
wc.stack_mode = XP_MAPPED_BELOW;
wc.sibling = x_cvt_vptr_to_uint(nextWid);
}
if(window_hash) {
RootlessWindowRec *winRec = x_hash_table_lookup(window_hash, wid, NULL);
if(winRec) {
if(XQuartzIsRootless)
wc.window_level = normal_window_levels[winRec->level];
else if(XQuartzShieldingWindowLevel)
wc.window_level = XQuartzShieldingWindowLevel + 1;
else
wc.window_level = rooted_window_levels[winRec->level];
mask |= XP_WINDOW_LEVEL;
}
}
xprConfigureWindow(x_cvt_vptr_to_uint(wid), mask, &wc);
}
static void xprEventHandler(int screenNum, xEventPtr xe, DeviceIntPtr dev, int nevents) {
int i;
TA_SERVER();
DEBUG_LOG("DarwinEventHandler(%d, %p, %p, %d)\n", screenNum, xe, dev, nevents);
for (i=0; i<nevents; i++) {
switch(xe[i].u.u.type) {
case kXquartzWindowState:
DEBUG_LOG("kXquartzWindowState\n");
RootlessNativeWindowStateChanged(xprGetXWindow(xe[i].u.clientMessage.u.l.longs0),
xe[i].u.clientMessage.u.l.longs1);
break;
case kXquartzWindowMoved:
DEBUG_LOG("kXquartzWindowMoved\n");
RootlessNativeWindowMoved(xprGetXWindow(xe[i].u.clientMessage.u.l.longs0));
break;
case kXquartzBringAllToFront:
DEBUG_LOG("kXquartzBringAllToFront\n");
RootlessOrderAllWindows();
break;
}
}
}
/*
* Flush drawing updates to the screen.
*/
static void
xprUpdateRegion(RootlessFrameID wid, RegionPtr pDamage)
{
TA_SERVER();
xp_flush_window(x_cvt_vptr_to_uint(wid));
}
/*
* Mark damaged rectangles as requiring redisplay to screen.
*/
static void
xprDamageRects(RootlessFrameID wid, int nrects, const BoxRec *rects,
int shift_x, int shift_y)
{
TA_SERVER();
xp_mark_window(x_cvt_vptr_to_uint(wid), nrects, rects, shift_x, shift_y);
}
/*
* Called to check if the frame should be reordered when it is restacked.
*/
static Bool xprDoReorderWindow(RootlessWindowPtr pFrame)
{
WindowPtr pWin = pFrame->win;
TA_SERVER();
return AppleWMDoReorderWindow(pWin);
}
static inline xp_error
xprConfigureWindow(xp_window_id id, unsigned int mask,
const xp_window_changes *values)
{
TA_SERVER();
return xp_configure_window(id, mask, values);
}
/*
* Called after the window associated with a frame has been switched
* to a new top-level parent.
*/
static void
xprSwitchWindow(RootlessWindowPtr pFrame, WindowPtr oldWin)
{
DeleteProperty(serverClient, oldWin, xa_native_window_id());
TA_SERVER();
xprSetNativeProperty(pFrame);
}
/*
* Copy area in frame to another part of frame.
* Used to accelerate scrolling.
*/
static void
xprCopyWindow(RootlessFrameID wid, int dstNrects, const BoxRec *dstRects,
int dx, int dy)
{
TA_SERVER();
xp_copy_window(x_cvt_vptr_to_uint(wid), x_cvt_vptr_to_uint(wid),
dstNrects, dstRects, dx, dy);
}
/*
* Stop drawing to a frame.
*/
static void
xprStopDrawing(RootlessFrameID wid, Bool flush)
{
xp_error err;
TA_SERVER();
err = xp_unlock_window(x_cvt_vptr_to_uint(wid), flush);
if(err != Success)
FatalError("Could not unlock window %i after drawing.", (int)x_cvt_vptr_to_uint(wid));
}
/*
* Move a frame on screen.
*/
static void
xprMoveFrame(RootlessFrameID wid, ScreenPtr pScreen, int newX, int newY)
{
xp_window_changes wc;
TA_SERVER();
wc.x = newX;
wc.y = newY;
// ErrorF("xprMoveFrame(%d, %p, %d, %d)\n", wid, pScreen, newX, newY);
xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_ORIGIN, &wc);
}
/*
* Initialize XPR implementation
*/
Bool
xprInit(ScreenPtr pScreen)
{
RootlessInit(pScreen, &xprRootlessProcs);
TA_SERVER();
rootless_CopyBytes_threshold = xp_copy_bytes_threshold;
rootless_CopyWindow_threshold = xp_scroll_area_threshold;
return TRUE;
}
/*
* Unmap a frame.
*/
static void
xprUnmapFrame(RootlessFrameID wid)
{
xp_window_changes wc;
TA_SERVER();
wc.stack_mode = XP_UNMAPPED;
wc.sibling = 0;
xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_STACKING, &wc);
}
/*
* Stop drawing to a frame.
*/
static void
xprStopDrawing(RootlessFrameID wid, Bool flush)
{
xp_error err;
TA_SERVER();
err = xp_unlock_window(x_cvt_vptr_to_uint(wid), flush);
/* This should be a FatalError, but we started tripping over it. Make it a
* FatalError after http://xquartz.macosforge.org/trac/ticket/482 is fixed.
*/
if(err != Success)
ErrorF("Could not unlock window %d after drawing (%d).", (int)x_cvt_vptr_to_uint(wid), (int)err);
}
/*
* Destroy a frame.
*/
static void
xprDestroyFrame(RootlessFrameID wid)
{
xp_error err;
TA_SERVER();
pthread_mutex_lock(&window_hash_mutex);
x_hash_table_remove(window_hash, wid);
pthread_mutex_unlock(&window_hash_mutex);
err = xp_destroy_window(x_cvt_vptr_to_uint(wid));
if (err != Success)
FatalError("Could not destroy window %d (%d).", (int)x_cvt_vptr_to_uint(wid), (int)err);
}
/*
* Start drawing to a frame.
* Prepare for direct access to its backing buffer.
*/
static void
xprStartDrawing(RootlessFrameID wid, char **pixelData, int *bytesPerRow)
{
void *data[2];
unsigned int rowbytes[2];
xp_error err;
TA_SERVER();
err = xp_lock_window(x_cvt_vptr_to_uint(wid), NULL, NULL, data, rowbytes, NULL);
if (err != Success)
FatalError("Could not lock window %d for drawing (%d).", (int)x_cvt_vptr_to_uint(wid), (int)err);
*pixelData = data[0];
*bytesPerRow = rowbytes[0];
}
static void
xprSetNativeProperty(RootlessWindowPtr pFrame)
{
xp_error err;
unsigned int native_id;
long data;
TA_SERVER();
err = xp_get_native_window(x_cvt_vptr_to_uint(pFrame->wid), &native_id);
if (err == Success)
{
/* FIXME: move this to AppleWM extension */
data = native_id;
dixChangeWindowProperty(serverClient, pFrame->win, xa_native_window_id(),
XA_INTEGER, 32, PropModeReplace, 1, &data, TRUE);
}
}
/*
* Resize and move a frame.
*/
static void
xprResizeFrame(RootlessFrameID wid, ScreenPtr pScreen,
int newX, int newY, unsigned int newW, unsigned int newH,
unsigned int gravity)
{
xp_window_changes wc;
TA_SERVER();
wc.x = newX;
wc.y = newY;
wc.width = newW;
wc.height = newH;
wc.bit_gravity = gravity;
/* It's unlikely that being async will save us anything here.
But it can't hurt. */
xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_BOUNDS, &wc);
}
/*
* Change the frame's shape.
*/
static void
xprReshapeFrame(RootlessFrameID wid, RegionPtr pShape)
{
xp_window_changes wc;
TA_SERVER();
if (pShape != NULL)
{
wc.shape_nrects = RegionNumRects(pShape);
wc.shape_rects = RegionRects(pShape);
}
else
{
wc.shape_nrects = -1;
wc.shape_rects = NULL;
}
wc.shape_tx = wc.shape_ty = 0;
xprConfigureWindow(x_cvt_vptr_to_uint(wid), XP_SHAPE, &wc);
}
/*
* xprHideWindows
* Hide or unhide all top level windows. This is called for application hide/
* unhide events if the window manager is not Apple-WM aware. Xplugin windows
* do not hide or unhide themselves.
*/
void
xprHideWindows(Bool hide)
{
int screen;
WindowPtr pRoot, pWin;
TA_SERVER();
for (screen = 0; screen < screenInfo.numScreens; screen++) {
RootlessFrameID prevWid = NULL;
pRoot = screenInfo.screens[screen]->root;
for (pWin = pRoot->firstChild; pWin; pWin = pWin->nextSib) {
RootlessWindowRec *winRec = WINREC(pWin);
if (winRec != NULL) {
if (hide) {
xprUnmapFrame(winRec->wid);
} else {
BoxRec box;
xprRestackFrame(winRec->wid, prevWid);
prevWid = winRec->wid;
box.x1 = 0;
box.y1 = 0;
box.x2 = winRec->width;
box.y2 = winRec->height;
xprDamageRects(winRec->wid, 1, &box, 0, 0);
RootlessQueueRedisplay(screenInfo.screens[screen]);
}
}
}
}
}
/*
* Create and display a new frame.
*/
static Bool
xprCreateFrame(RootlessWindowPtr pFrame, ScreenPtr pScreen,
int newX, int newY, RegionPtr pShape)
{
WindowPtr pWin = pFrame->win;
xp_window_changes wc;
unsigned int mask = 0;
xp_error err;
TA_SERVER();
wc.x = newX;
wc.y = newY;
wc.width = pFrame->width;
wc.height = pFrame->height;
wc.bit_gravity = XP_GRAVITY_NONE;
mask |= XP_BOUNDS;
if (pWin->drawable.depth == 8)
{
wc.depth = XP_DEPTH_INDEX8;
wc.colormap = xprColormapCallback;
wc.colormap_data = pScreen;
mask |= XP_COLORMAP;
}
else if (pWin->drawable.depth == 15)
wc.depth = XP_DEPTH_RGB555;
else if (pWin->drawable.depth == 24)
wc.depth = XP_DEPTH_ARGB8888;
else
wc.depth = XP_DEPTH_NIL;
mask |= XP_DEPTH;
if (pShape != NULL)
{
wc.shape_nrects = RegionNumRects(pShape);
wc.shape_rects = RegionRects(pShape);
wc.shape_tx = wc.shape_ty = 0;
mask |= XP_SHAPE;
}
pFrame->level = !IsRoot (pWin) ? AppleWMWindowLevelNormal : AppleWMNumWindowLevels;
if(XQuartzIsRootless)
wc.window_level = normal_window_levels[pFrame->level];
else if(XQuartzShieldingWindowLevel)
wc.window_level = XQuartzShieldingWindowLevel + 1;
else
wc.window_level = rooted_window_levels[pFrame->level];
mask |= XP_WINDOW_LEVEL;
err = xp_create_window(mask, &wc, (xp_window_id *) &pFrame->wid);
if (err != Success)
{
return FALSE;
}
if (window_hash == NULL)
{
window_hash = x_hash_table_new(NULL, NULL, NULL, NULL);
pthread_mutex_init(&window_hash_mutex, NULL);
}
pthread_mutex_lock(&window_hash_mutex);
x_hash_table_insert(window_hash, pFrame->wid, pFrame);
pthread_mutex_unlock(&window_hash_mutex);
xprSetNativeProperty(pFrame);
return TRUE;
}
