/*
* Screen routines for Mac OS X rootless X server
*
* Greg Parker gparker@cs.stanford.edu
*
* February 2001 Created
* March 3, 2001 Restructured as generic rootless mode
*/
/* 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. */
/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/rootlessScreen.c,v 1.2 2002/04/03 00:06:32 torrey Exp $ */
#include "mi.h"
#include "scrnintstr.h"
#include "gcstruct.h"
#include "pixmapstr.h"
#include "windowstr.h"
#include "propertyst.h"
#include "mivalidate.h"
#include "picturestr.h"
#include "os.h"
#include "servermd.h"
#include "colormapst.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "rootless-common.h"
#include "rootless-window.h"
/* In milcroseconds */
#define REDISPLAY_DELAY 10
#define REDISPLAY_MAX_DELAY 60
extern int RootlessMiValidateTree(WindowPtr pRoot,
WindowPtr pChild, VTKind kind);
extern Bool RootlessCreateGC(GCPtr pGC);
int rootlessGCPrivateIndex = -1;
int rootlessScreenPrivateIndex = -1;
int rootlessWindowPrivateIndex = -1;
void
RootlessUpdateScreenPixmap (ScreenPtr pScreen)
{
RootlessScreenRec *s = SCREENREC(pScreen);
PixmapPtr pPix;
unsigned int rowbytes;
pPix = (*pScreen->GetScreenPixmap) (pScreen);
if (pPix == NULL)
{
pPix = (*pScreen->CreatePixmap) (pScreen, 0, 0, pScreen->rootDepth);
(*pScreen->SetScreenPixmap) (pPix);
}
rowbytes = PixmapBytePad (pScreen->width, pScreen->rootDepth);
if (s->pixmap_data_size < rowbytes)
{
if (s->pixmap_data != NULL)
xfree (s->pixmap_data);
s->pixmap_data_size = rowbytes;
s->pixmap_data = xalloc (s->pixmap_data_size);
if (s->pixmap_data == NULL)
return;
xp_fill_bytes (s->pixmap_data_size, 1, ~0,
s->pixmap_data, s->pixmap_data_size);
pScreen->ModifyPixmapHeader (pPix, pScreen->width, pScreen->height,
pScreen->rootDepth,
BitsPerPixel (pScreen->rootDepth),
0, s->pixmap_data);
/* ModifyPixmapHeader ignores zero arguments, so install rowbytes
by hand. */
pPix->devKind = 0;
}
}
static Bool
RootlessCreateScreenResources (ScreenPtr pScreen)
{
Bool ret = TRUE;
SCREEN_UNWRAP (pScreen, CreateScreenResources);
if (pScreen->CreateScreenResources != NULL)
ret = (*pScreen->CreateScreenResources) (pScreen);
SCREEN_WRAP(pScreen, CreateScreenResources);
if (!ret)
return ret;
/* miCreateScreenResources doesn't like our null framebuffer pointer,
it leaves the screen pixmap with an uninitialized data pointer. So
we gave it depth=0,bits=0, which says, leave it the fsck alone.
So we have some work to do since we need the screen pixmap to be
valid (e.g. CopyArea from the root window) */
RootlessUpdateScreenPixmap (pScreen);
return ret;
}
static Bool
RootlessCloseScreen(int i, ScreenPtr pScreen)
{
RootlessScreenRec *s;
s = SCREENREC(pScreen);
/* FIXME: unwrap everything that was wrapped? */
pScreen->CloseScreen = s->CloseScreen;
if (s->pixmap_data != NULL)
{
xfree (s->pixmap_data);
s->pixmap_data = NULL;
s->pixmap_data_size = 0;
}
xfree(s);
return pScreen->CloseScreen(i, pScreen);
}
static void
RootlessGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,
unsigned int format, unsigned long planeMask, char *pdstLine)
{
ScreenPtr pScreen = pDrawable->pScreen;
SCREEN_UNWRAP(pScreen, GetImage);
if (pDrawable->type == DRAWABLE_WINDOW)
{
int x0, y0, x1, y1;
RootlessWindowRec *winRec;
/* Many apps use GetImage to sync with the visible frame buffer
FIXME: entire screen or just window or all screens? */
RootlessRedisplayScreen (pScreen);
/* RedisplayScreen stops drawing, so we need to start it again */
RootlessStartDrawing ((WindowPtr) pDrawable);
/* Check that we have some place to read from. */
winRec = WINREC (TopLevelParent ((WindowPtr) pDrawable));
if (winRec == NULL)
goto out;
/* Clip to top-level window bounds. */
x0 = pDrawable->x + sx;
y0 = pDrawable->y + sy;
x1 = x0 + w;
y1 = y0 + h;
x0 = MAX (x0, winRec->x);
y0 = MAX (y0, winRec->y);
x1 = MIN (x1, winRec->x + (int) winRec->width);
y1 = MIN (y1, winRec->y + (int) winRec->height);
/* FIXME: if clipped we need to adjust the data returned from
fbGetImage (), since it calculates the destination stride
from the passed in width.. */
sx = x0 - pDrawable->x;
sy = y0 - pDrawable->y;
w = x1 - x0;
h = y1 - y0;
if (w <= 0 || h <= 0)
goto out;
}
pScreen->GetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
out:
SCREEN_WRAP(pScreen, GetImage);
}
/*
* RootlessSourceValidate
* CopyArea and CopyPlane use a GC tied to the destination drawable.
* StartDrawing/StopDrawing wrappers won't be called if source is
* a visible window but the destination isn't. So, we call StartDrawing
* here and leave StopDrawing for the block handler.
*/
static void
RootlessSourceValidate(DrawablePtr pDrawable, int x, int y, int w, int h)
{
SCREEN_UNWRAP(pDrawable->pScreen, SourceValidate);
if (pDrawable->type == DRAWABLE_WINDOW) {
WindowPtr pWin = (WindowPtr)pDrawable;
RootlessStartDrawing(pWin);
}
if (pDrawable->pScreen->SourceValidate) {
pDrawable->pScreen->SourceValidate(pDrawable, x, y, w, h);
}
SCREEN_WRAP(pDrawable->pScreen, SourceValidate);
}
#ifdef RENDER
static void
rootlessComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask,
INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
{
ScreenPtr pScreen = pDst->pDrawable->pScreen;
PictureScreenPtr ps = GetPictureScreen(pScreen);
WindowPtr srcWin, dstWin, maskWin = NULL;
if (pMask) {
maskWin = (pMask->pDrawable->type == DRAWABLE_WINDOW) ?
(WindowPtr)pMask->pDrawable : NULL;
}
srcWin = (pSrc->pDrawable->type == DRAWABLE_WINDOW) ?
(WindowPtr)pSrc->pDrawable : NULL;
dstWin = (pDst->pDrawable->type == DRAWABLE_WINDOW) ?
(WindowPtr)pDst->pDrawable : NULL;
ps->Composite = SCREENREC(pScreen)->Composite;
if (srcWin && IsFramedWindow(srcWin)) RootlessStartDrawing(srcWin);
if (maskWin && IsFramedWindow(maskWin)) RootlessStartDrawing(maskWin);
if (dstWin && IsFramedWindow(dstWin)) RootlessStartDrawing(dstWin);
ps->Composite(op, pSrc, pMask, pDst,
xSrc, ySrc, xMask, yMask,
xDst, yDst, width, height);
if (dstWin && IsFramedWindow(dstWin)) {
RootlessDamageRect(dstWin, xDst, yDst, width, height);
}
ps->Composite = RootlessComposite;
}
static void
RootlessGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
int nlist, GlyphListPtr list, GlyphPtr *glyphs)
{
ScreenPtr pScreen = pDst->pDrawable->pScreen;
PictureScreenPtr ps = GetPictureScreen(pScreen);
int x, y;
int n;
GlyphPtr glyph;
WindowPtr srcWin, dstWin;
srcWin = (pSrc->pDrawable->type == DRAWABLE_WINDOW) ?
(WindowPtr)pSrc->pDrawable : NULL;
dstWin = (pDst->pDrawable->type == DRAWABLE_WINDOW) ?
(WindowPtr)pDst->pDrawable : NULL;
if (srcWin && IsFramedWindow(srcWin)) RootlessStartDrawing(srcWin);
if (dstWin && IsFramedWindow(dstWin)) RootlessStartDrawing(dstWin);
ps->Glyphs = SCREENREC(pScreen)->Glyphs;
ps->Glyphs(op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
ps->Glyphs = RootlessGlyphs;
if (dstWin && IsFramedWindow(dstWin))
{
x = xSrc;
y = ySrc;
while (nlist--)
{
/* Originally this code called DamageRect for the bounding
box of each glyph. But that was causing way too much
time to be spent in CGSBoundingRegionAddRect. So compute
the union of all glyphs in a list and damage that. It
shouldn't be very different. */
x += list->xOff;
y += list->yOff;
n = list->len;
if (n > 0)
{
BoxRec box;
glyph = *glyphs++;
box.x1 = x - glyph->info.x;
box.y1 = y - glyph->info.y;
box.x2 = box.x1 + glyph->info.width;
box.y2 = box.y2 + glyph->info.height;
x += glyph->info.xOff;
y += glyph->info.yOff;
while (--n > 0)
{
short x1, y1, x2, y2;
glyph = *glyphs++;
x1 = x - glyph->info.x;
y1 = y - glyph->info.y;
x2 = x1 + glyph->info.width;
y2 = y1 + glyph->info.height;
box.x1 = MAX (box.x1, x1);
box.y1 = MAX (box.y1, y1);
box.x2 = MAX (box.x2, x2);
box.y2 = MAX (box.y2, y2);
x += glyph->info.xOff;
y += glyph->info.yOff;
}
RootlessDamageBox (dstWin, &box);
}
list++;
}
}
}
#endif /* RENDER */
/* ValidateTree is modified in two ways:
- top-level windows don't clip each other
- windows aren't clipped against root.
These only matter when validating from the root. */
static int
RootlessValidateTree(WindowPtr pParent, WindowPtr pChild, VTKind kind)
{
int result;
RegionRec saveRoot;
ScreenPtr pScreen = pParent->drawable.pScreen;
SCREEN_UNWRAP(pScreen, ValidateTree);
RL_DEBUG_MSG("VALIDATETREE start ");
/* Use our custom version to validate from root */
if (IsRoot(pParent)) {
RL_DEBUG_MSG("custom ");
result = RootlessMiValidateTree(pParent, pChild, kind);
} else {
HUGE_ROOT(pParent);
result = pScreen->ValidateTree(pParent, pChild, kind);
NORMAL_ROOT(pParent);
}
SCREEN_WRAP(pScreen, ValidateTree);
RL_DEBUG_MSG("VALIDATETREE end\n");
return result;
}
/* MarkOverlappedWindows is modified to ignore overlapping top-level
windows. */
static Bool
RootlessMarkOverlappedWindows(WindowPtr pWin, WindowPtr pFirst,
WindowPtr *ppLayerWin)
{
RegionRec saveRoot;
Bool result;
ScreenPtr pScreen = pWin->drawable.pScreen;
SCREEN_UNWRAP(pScreen, MarkOverlappedWindows);
RL_DEBUG_MSG("MARKOVERLAPPEDWINDOWS start ");
HUGE_ROOT(pWin);
if (IsRoot(pWin)) {
/* root - mark nothing */
RL_DEBUG_MSG("is root not marking ");
result = FALSE;
}
else if (! IsTopLevel(pWin)) {
/* not top-level window - mark normally */
result = pScreen->MarkOverlappedWindows(pWin, pFirst, ppLayerWin);
}
else {
/* top-level window - mark children ONLY - NO overlaps with sibs (?)
This code copied from miMarkOverlappedWindows() */
register WindowPtr pChild;
Bool anyMarked = FALSE;
void (* MarkWindow)() = pScreen->MarkWindow;
RL_DEBUG_MSG("is top level! ");
/* single layered systems are easy */
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;
while (1) {
if (pChild->viewable) {
if (REGION_BROKEN (pScreen, &pChild->winSize))
SetWinSize (pChild);
if (REGION_BROKEN (pScreen, &pChild->borderSize))
SetBorderSize (pChild);
(* MarkWindow)(pChild);
if (pChild->firstChild) {
pChild = pChild->firstChild;
continue;
}
}
while (!pChild->nextSib && (pChild != pWin))
pChild = pChild->parent;
if (pChild == pWin)
break;
pChild = pChild->nextSib;
}
anyMarked = TRUE;
pFirst = pFirst->nextSib;
}
if (anyMarked)
(* MarkWindow)(pWin->parent);
result = anyMarked;
}
NORMAL_ROOT(pWin);
SCREEN_WRAP(pScreen, MarkOverlappedWindows);
RL_DEBUG_MSG("MARKOVERLAPPEDWINDOWS end\n");
return result;
}
static void
expose_1 (WindowPtr pWin)
{
WindowPtr pChild;
if (!pWin->realized)
return;
(*pWin->drawable.pScreen->PaintWindowBackground) (pWin, &pWin->borderClip,
PW_BACKGROUND);
/* FIXME: comments in windowstr.h indicate that borderClip doesn't
include subwindow visibility. But I'm not so sure.. so we may
be exposing too much.. */
miSendExposures (pWin, &pWin->borderClip,
pWin->drawable.x, pWin->drawable.y);
for (pChild = pWin->firstChild; pChild != NULL; pChild = pChild->nextSib)
expose_1 (pChild);
}
void
RootlessScreenExpose (ScreenPtr pScreen)
{
expose_1 (WindowTable[pScreen->myNum]);
}
ColormapPtr
RootlessGetColormap (ScreenPtr pScreen)
{
RootlessScreenRec *s = SCREENREC (pScreen);
return s->colormap;
}
static void
RootlessInstallColormap (ColormapPtr pMap)
{
ScreenPtr pScreen = pMap->pScreen;
RootlessScreenRec *s = SCREENREC (pScreen);
SCREEN_UNWRAP(pScreen, InstallColormap);
if (s->colormap != pMap)
{
s->colormap = pMap;
s->colormap_changed = TRUE;
RootlessQueueRedisplay (pScreen);
}
pScreen->InstallColormap (pMap);
SCREEN_WRAP (pScreen, InstallColormap);
}
static void
RootlessUninstallColormap (ColormapPtr pMap)
{
ScreenPtr pScreen = pMap->pScreen;
RootlessScreenRec *s = SCREENREC (pScreen);
SCREEN_UNWRAP(pScreen, UninstallColormap);
if (s->colormap == pMap)
s->colormap = NULL;
pScreen->UninstallColormap (pMap);
SCREEN_WRAP(pScreen, UninstallColormap);
}
static void
RootlessStoreColors (ColormapPtr pMap, int ndef, xColorItem *pdef)
{
ScreenPtr pScreen = pMap->pScreen;
RootlessScreenRec *s = SCREENREC (pScreen);
SCREEN_UNWRAP(pScreen, StoreColors);
if (s->colormap == pMap && ndef > 0)
{
s->colormap_changed = TRUE;
RootlessQueueRedisplay (pScreen);
}
pScreen->StoreColors (pMap, ndef, pdef);
SCREEN_WRAP(pScreen, StoreColors);
}
static CARD32
redisplay_callback (OsTimerPtr timer, CARD32 time, void *arg)
{
RootlessScreenRec *screenRec = arg;
if (!screenRec->redisplay_queued)
{
/* No update needed. Stop the timer. */
screenRec->redisplay_timer_set = FALSE;
return 0;
}
screenRec->redisplay_queued = FALSE;
/* Mark that we should redisplay before waiting for I/O next time */
screenRec->redisplay_expired = TRUE;
/* Reinstall the timer immediately, so we get as close to our
redisplay interval as possible. */
return REDISPLAY_DELAY;
}
void
RootlessQueueRedisplay (ScreenPtr pScreen)
{
RootlessScreenRec *screenRec = SCREENREC (pScreen);
screenRec->redisplay_queued = TRUE;
if (screenRec->redisplay_timer_set)
return;
screenRec->redisplay_timer = TimerSet (screenRec->redisplay_timer,
0, REDISPLAY_DELAY,
redisplay_callback, screenRec);
screenRec->redisplay_timer_set = TRUE;
}
/* Call this function when it might be a good idea to flush updates.
Note that it will unlock window buffers! */
Bool
RootlessMayRedisplay (ScreenPtr pScreen)
{
RootlessScreenRec *screenRec = SCREENREC (pScreen);
if (!screenRec->redisplay_queued)
return FALSE;
/* If the timer has fired, or it's been long enough since the last
update, redisplay everything now. */
if (!screenRec->redisplay_expired)
{
CARD32 now = GetTimeInMillis ();
if (screenRec->last_redisplay + REDISPLAY_MAX_DELAY >= now)
return FALSE;
}
if (screenRec->redisplay_timer_set)
{
TimerCancel (screenRec->redisplay_timer);
screenRec->redisplay_timer_set = FALSE;
}
RootlessRedisplayScreen (screenRec->pScreen);
screenRec->redisplay_expired = FALSE;
return TRUE;
}
/* Flush drawing before blocking on select(). */
static void
RootlessBlockHandler(pointer pbdata, OSTimePtr pTimeout, pointer pReadmask)
{
ScreenPtr pScreen = pbdata;
RootlessScreenRec *screenRec = SCREENREC (pScreen);
if (screenRec->redisplay_expired)
{
screenRec->redisplay_expired = FALSE;
if (screenRec->colormap_changed)
{
RootlessFlushScreenColormaps (screenRec->pScreen);
screenRec->colormap_changed = FALSE;
}
RootlessRedisplayScreen (screenRec->pScreen);
}
}
static void
RootlessWakeupHandler(pointer data, int i, pointer LastSelectMask)
{
}
static Bool
RootlessAllocatePrivates(ScreenPtr pScreen)
{
RootlessScreenRec *s;
static unsigned int rootlessGeneration = -1;
if (rootlessGeneration != serverGeneration) {
rootlessScreenPrivateIndex = AllocateScreenPrivateIndex();
if (rootlessScreenPrivateIndex == -1) return FALSE;
rootlessGCPrivateIndex = AllocateGCPrivateIndex();
if (rootlessGCPrivateIndex == -1) return FALSE;
rootlessWindowPrivateIndex = AllocateWindowPrivateIndex();
if (rootlessWindowPrivateIndex == -1) return FALSE;
rootlessGeneration = serverGeneration;
}
/* no allocation needed for screen privates */
if (!AllocateGCPrivate(pScreen, rootlessGCPrivateIndex,
sizeof(RootlessGCRec)))
return FALSE;
if (!AllocateWindowPrivate(pScreen, rootlessWindowPrivateIndex, 0))
return FALSE;
s = xalloc(sizeof(RootlessScreenRec));
if (! s) return FALSE;
SCREENREC(pScreen) = s;
s->pixmap_data = NULL;
s->pixmap_data_size = 0;
s->redisplay_timer = NULL;
s->redisplay_timer_set = FALSE;
return TRUE;
}
static void
RootlessWrap(ScreenPtr pScreen)
{
RootlessScreenRec *s = (RootlessScreenRec*)
pScreen->devPrivates[rootlessScreenPrivateIndex].ptr;
#define WRAP(a) \
if (pScreen->a) { \
s->a = pScreen->a; \
} else { \
RL_DEBUG_MSG("null screen fn " #a "\n"); \
s->a = NULL; \
} \
pScreen->a = Rootless##a
WRAP(CreateScreenResources);
WRAP(CloseScreen);
WRAP(CreateGC);
WRAP(PaintWindowBackground);
WRAP(PaintWindowBorder);
WRAP(CopyWindow);
WRAP(GetImage);
WRAP(SourceValidate);
WRAP(CreateWindow);
WRAP(DestroyWindow);
WRAP(RealizeWindow);
WRAP(UnrealizeWindow);
WRAP(ReparentWindow);
WRAP(MoveWindow);
WRAP(PositionWindow);
WRAP(ResizeWindow);
WRAP(RestackWindow);
WRAP(ChangeBorderWidth);
WRAP(MarkOverlappedWindows);
WRAP(ValidateTree);
WRAP(ChangeWindowAttributes);
WRAP(InstallColormap);
WRAP(UninstallColormap);
WRAP(StoreColors);
#ifdef SHAPE
WRAP(SetShape);
#endif
#ifdef RENDER
{
/* Composite and Glyphs don't use normal screen wrapping */
PictureScreenPtr ps = GetPictureScreen(pScreen);
s->Composite = ps->Composite;
ps->Composite = rootlessComposite;
s->Glyphs = ps->Glyphs;
ps->Glyphs = RootlessGlyphs;
}
#endif
// WRAP(ClearToBackground); fixme put this back? useful for shaped wins?
// WRAP(RestoreAreas); fixme put this back?
#undef WRAP
}
Bool
RootlessSetupScreen(int index, ScreenPtr pScreen)
{
RootlessScreenRec *s;
/* Add replacements for fb screen functions */
pScreen->PaintWindowBackground = RootlessPaintWindow;
pScreen->PaintWindowBorder = RootlessPaintWindow;
#ifdef RENDER
{
PictureScreenPtr ps = GetPictureScreen(pScreen);
ps->Composite = RootlessComposite;
}
#endif
if (!RootlessAllocatePrivates(pScreen))
return FALSE;
s = ((RootlessScreenRec*)
pScreen->devPrivates[rootlessScreenPrivateIndex].ptr);
s->pScreen = pScreen;
RootlessWrap(pScreen);
if (!RegisterBlockAndWakeupHandlers (RootlessBlockHandler,
RootlessWakeupHandler,
(pointer) pScreen))
{
return FALSE;
}
return TRUE;
}
void
RootlessUpdateRooted (Bool state)
{
int i;
if (!state)
{
for (i = 0; i < screenInfo.numScreens; i++)
RootlessDisableRoot (screenInfo.screens[i]);
}
else
{
for (i = 0; i < screenInfo.numScreens; i++)
RootlessEnableRoot (screenInfo.screens[i]);
}
}