ae7f71a8b3
Composite's automatic redirection is a more general mechanism than the ad-hoc BS machinery, so it's much prettier to implement the one in terms of the other. Composite now wraps ChangeWindowAttributes and activates automatic redirection for windows with backing store requested. The old backing store infrastructure is completely gutted: ABI-visible structures retain the function pointers, but they never get called, and all the open-coded conditionals throughout the DIX layer to implement BS are gone. Note that this is still not a strictly complete implementation of backing store, since Composite will throw the bits away on unmap and therefore WhenMapped and Always hints are equivalent.
475 lines
12 KiB
C
475 lines
12 KiB
C
/*
|
|
* Copyright © 2004 David Reveman
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software
|
|
* and its documentation for any purpose is hereby granted without
|
|
* fee, provided that the above copyright notice appear in all copies
|
|
* and that both that copyright notice and this permission notice
|
|
* appear in supporting documentation, and that the name of
|
|
* David Reveman not be used in advertising or publicity pertaining to
|
|
* distribution of the software without specific, written prior permission.
|
|
* David Reveman makes no representations about the suitability of this
|
|
* software for any purpose. It is provided "as is" without express or
|
|
* implied warranty.
|
|
*
|
|
* DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
|
|
* NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
|
|
* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
|
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
|
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* Author: David Reveman <davidr@novell.com>
|
|
*/
|
|
|
|
#include "xgl.h"
|
|
#include "inputstr.h"
|
|
#include "mipointer.h"
|
|
#include "damage.h"
|
|
#include "fb.h"
|
|
#ifdef MITSHM
|
|
#include "shmint.h"
|
|
static ShmFuncs shmFuncs = { NULL, xglShmPutImage };
|
|
#endif
|
|
#ifdef RENDER
|
|
#include "glyphstr.h"
|
|
#endif
|
|
#ifdef COMPOSITE
|
|
#include "compint.h"
|
|
#endif
|
|
|
|
int xglScreenGeneration = -1;
|
|
int xglScreenPrivateIndex;
|
|
int xglGCPrivateIndex;
|
|
int xglPixmapPrivateIndex;
|
|
int xglWinPrivateIndex;
|
|
|
|
#ifdef RENDER
|
|
int xglGlyphPrivateIndex;
|
|
#endif
|
|
|
|
#define xglQueryBestSize (void *) NoopDDA
|
|
#define xglSaveScreen (void *) NoopDDA
|
|
|
|
#define xglConstrainCursor (void *) NoopDDA
|
|
#define xglCursorLimits (void *) NoopDDA
|
|
#define xglDisplayCursor (void *) NoopDDA
|
|
#define xglRealizeCursor (void *) NoopDDA
|
|
#define xglUnrealizeCursor (void *) NoopDDA
|
|
#define xglRecolorCursor (void *) NoopDDA
|
|
#define xglSetCursorPosition (void *) NoopDDA
|
|
|
|
static Bool
|
|
xglAllocatePrivates (ScreenPtr pScreen)
|
|
{
|
|
xglScreenPtr pScreenPriv;
|
|
|
|
if (xglScreenGeneration != serverGeneration)
|
|
{
|
|
xglScreenPrivateIndex = AllocateScreenPrivateIndex ();
|
|
if (xglScreenPrivateIndex < 0)
|
|
return FALSE;
|
|
|
|
xglGCPrivateIndex = AllocateGCPrivateIndex ();
|
|
if (xglGCPrivateIndex < 0)
|
|
return FALSE;
|
|
|
|
xglPixmapPrivateIndex = AllocatePixmapPrivateIndex ();
|
|
if (xglPixmapPrivateIndex < 0)
|
|
return FALSE;
|
|
|
|
xglWinPrivateIndex = AllocateWindowPrivateIndex ();
|
|
if (xglWinPrivateIndex < 0)
|
|
return FALSE;
|
|
|
|
#ifdef RENDER
|
|
xglGlyphPrivateIndex = AllocateGlyphPrivateIndex ();
|
|
if (xglGlyphPrivateIndex < 0)
|
|
return FALSE;
|
|
#endif
|
|
|
|
xglScreenGeneration = serverGeneration;
|
|
}
|
|
|
|
if (!AllocateGCPrivate (pScreen, xglGCPrivateIndex, sizeof (xglGCRec)))
|
|
return FALSE;
|
|
|
|
if (!AllocatePixmapPrivate (pScreen, xglPixmapPrivateIndex,
|
|
sizeof (xglPixmapRec)))
|
|
return FALSE;
|
|
|
|
if (!AllocateWindowPrivate (pScreen, xglWinPrivateIndex,
|
|
sizeof (xglWinRec)))
|
|
return FALSE;
|
|
|
|
pScreenPriv = xalloc (sizeof (xglScreenRec));
|
|
if (!pScreenPriv)
|
|
return FALSE;
|
|
|
|
XGL_SET_SCREEN_PRIV (pScreen, pScreenPriv);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
xglScreenInit (ScreenPtr pScreen)
|
|
{
|
|
xglScreenPtr pScreenPriv;
|
|
xglVisualPtr v;
|
|
int i, depth, bpp = 0;
|
|
|
|
#ifdef RENDER
|
|
PictureScreenPtr pPictureScreen;
|
|
#endif
|
|
|
|
depth = xglScreenInfo.depth;
|
|
|
|
for (v = xglVisuals; v; v = v->next)
|
|
{
|
|
if (v->pPixel->depth == depth)
|
|
{
|
|
bpp = v->pPixel->masks.bpp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bpp)
|
|
return FALSE;
|
|
|
|
if (!xglAllocatePrivates (pScreen))
|
|
return FALSE;
|
|
|
|
pScreenPriv = XGL_GET_SCREEN_PRIV (pScreen);
|
|
|
|
pScreenPriv->pScreenPixmap = NULL;
|
|
|
|
/* Add any unlisted depths from the pixmap formats */
|
|
for (i = 0; i < screenInfo.numPixmapFormats; i++)
|
|
{
|
|
if (!xglHasVisualTypes (xglVisuals, screenInfo.formats[i].depth))
|
|
xglSetVisualTypes (screenInfo.formats[i].depth, 0, 0, 0, 0);
|
|
}
|
|
|
|
pScreenPriv->pVisual = 0;
|
|
|
|
#ifdef GLXEXT
|
|
pScreenPriv->pGlxVisual = 0;
|
|
#endif
|
|
|
|
pScreenPriv->rootVisual = 0;
|
|
|
|
pScreenPriv->drawable = xglScreenInfo.drawable;
|
|
pScreenPriv->features =
|
|
glitz_drawable_get_features (xglScreenInfo.drawable);
|
|
|
|
GEOMETRY_INIT (pScreen, &pScreenPriv->scratchGeometry,
|
|
GLITZ_GEOMETRY_TYPE_VERTEX,
|
|
pScreenPriv->geometryUsage, 0);
|
|
|
|
pScreenPriv->geometryDataType = xglScreenInfo.geometryDataType;
|
|
pScreenPriv->geometryUsage = xglScreenInfo.geometryUsage;
|
|
pScreenPriv->yInverted = xglScreenInfo.yInverted;
|
|
pScreenPriv->pboMask = xglScreenInfo.pboMask;
|
|
pScreenPriv->lines = xglScreenInfo.lines;
|
|
pScreenPriv->accel = xglScreenInfo.accel;
|
|
|
|
if (monitorResolution == 0)
|
|
monitorResolution = XGL_DEFAULT_DPI;
|
|
|
|
if (!fbSetupScreen (pScreen, NULL,
|
|
xglScreenInfo.width, xglScreenInfo.height,
|
|
monitorResolution, monitorResolution,
|
|
xglScreenInfo.width, bpp))
|
|
return FALSE;
|
|
|
|
pScreen->SaveScreen = xglSaveScreen;
|
|
|
|
pScreen->CreatePixmap = xglCreatePixmap;
|
|
pScreen->DestroyPixmap = xglDestroyPixmap;
|
|
|
|
if (!fbFinishScreenInit (pScreen, NULL,
|
|
xglScreenInfo.width, xglScreenInfo.height,
|
|
monitorResolution, monitorResolution,
|
|
xglScreenInfo.width, bpp))
|
|
return FALSE;
|
|
|
|
#ifdef MITSHM
|
|
ShmRegisterFuncs (pScreen, &shmFuncs);
|
|
#endif
|
|
|
|
#ifdef RENDER
|
|
if (!xglPictureInit (pScreen))
|
|
return FALSE;
|
|
#endif
|
|
|
|
XGL_SCREEN_WRAP (GetImage, xglGetImage);
|
|
XGL_SCREEN_WRAP (GetSpans, xglGetSpans);
|
|
|
|
XGL_SCREEN_WRAP (CopyWindow, xglCopyWindow);
|
|
XGL_SCREEN_WRAP (CreateWindow, xglCreateWindow);
|
|
XGL_SCREEN_WRAP (DestroyWindow, xglDestroyWindow);
|
|
XGL_SCREEN_WRAP (ChangeWindowAttributes, xglChangeWindowAttributes);
|
|
XGL_SCREEN_WRAP (PaintWindowBackground, xglPaintWindowBackground);
|
|
XGL_SCREEN_WRAP (PaintWindowBorder, xglPaintWindowBorder);
|
|
|
|
XGL_SCREEN_WRAP (CreateGC, xglCreateGC);
|
|
|
|
pScreen->ConstrainCursor = xglConstrainCursor;
|
|
pScreen->CursorLimits = xglCursorLimits;
|
|
pScreen->DisplayCursor = xglDisplayCursor;
|
|
pScreen->RealizeCursor = xglRealizeCursor;
|
|
pScreen->UnrealizeCursor = xglUnrealizeCursor;
|
|
pScreen->RecolorCursor = xglRecolorCursor;
|
|
pScreen->SetCursorPosition = xglSetCursorPosition;
|
|
|
|
pScreen->ModifyPixmapHeader = xglModifyPixmapHeader;
|
|
|
|
XGL_SCREEN_WRAP (BitmapToRegion, xglPixmapToRegion);
|
|
|
|
pScreen->GetWindowPixmap = xglGetWindowPixmap;
|
|
|
|
XGL_SCREEN_WRAP (SetWindowPixmap, xglSetWindowPixmap);
|
|
|
|
#ifdef RENDER
|
|
pPictureScreen = GetPictureScreenIfSet (pScreen);
|
|
if (pPictureScreen)
|
|
{
|
|
if (!AllocateGlyphPrivate (pScreen, xglGlyphPrivateIndex,
|
|
sizeof (xglGlyphRec)))
|
|
return FALSE;
|
|
|
|
XGL_PICTURE_SCREEN_WRAP (RealizeGlyph, xglRealizeGlyph);
|
|
XGL_PICTURE_SCREEN_WRAP (UnrealizeGlyph, xglUnrealizeGlyph);
|
|
XGL_PICTURE_SCREEN_WRAP (Composite, xglComposite);
|
|
XGL_PICTURE_SCREEN_WRAP (Glyphs, xglGlyphs);
|
|
XGL_PICTURE_SCREEN_WRAP (Trapezoids, xglTrapezoids);
|
|
XGL_PICTURE_SCREEN_WRAP (AddTraps, xglAddTraps);
|
|
XGL_PICTURE_SCREEN_WRAP (AddTriangles, xglAddTriangles);
|
|
XGL_PICTURE_SCREEN_WRAP (ChangePicture, xglChangePicture);
|
|
XGL_PICTURE_SCREEN_WRAP (ChangePictureTransform,
|
|
xglChangePictureTransform);
|
|
XGL_PICTURE_SCREEN_WRAP (ChangePictureFilter, xglChangePictureFilter);
|
|
}
|
|
#endif
|
|
|
|
if (!fbCreateDefColormap (pScreen))
|
|
return FALSE;
|
|
|
|
#ifdef COMPOSITE
|
|
#warning "composite building"
|
|
if (!compScreenInit (pScreen))
|
|
return FALSE;
|
|
#endif
|
|
|
|
/* Damage is required */
|
|
DamageSetup (pScreen);
|
|
|
|
XGL_SCREEN_WRAP (CloseScreen, xglCloseScreen);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
xglFinishScreenInit (ScreenPtr pScreen)
|
|
{
|
|
xglVisualPtr v;
|
|
|
|
#ifdef RENDER
|
|
glitz_vertex_format_t *format;
|
|
static glitz_color_t clearBlack = { 0x0, 0x0, 0x0, 0x0 };
|
|
static glitz_color_t solidWhite = { 0xffff, 0xffff, 0xffff, 0xffff };
|
|
int i;
|
|
#endif
|
|
|
|
XGL_SCREEN_PRIV (pScreen);
|
|
|
|
xglInitVisuals (pScreen);
|
|
|
|
for (v = pScreenPriv->pVisual; v; v = v->next)
|
|
{
|
|
if (v->vid == pScreen->rootVisual)
|
|
pScreenPriv->rootVisual = v;
|
|
}
|
|
|
|
if (!pScreenPriv->rootVisual || !pScreenPriv->rootVisual->format.surface)
|
|
return FALSE;
|
|
|
|
pScreenPriv->surface =
|
|
glitz_surface_create (pScreenPriv->drawable,
|
|
pScreenPriv->rootVisual->format.surface,
|
|
xglScreenInfo.width, xglScreenInfo.height,
|
|
0, NULL);
|
|
if (!pScreenPriv->surface)
|
|
return FALSE;
|
|
|
|
glitz_surface_attach (pScreenPriv->surface,
|
|
pScreenPriv->drawable,
|
|
GLITZ_DRAWABLE_BUFFER_FRONT_COLOR);
|
|
|
|
#ifdef RENDER
|
|
for (i = 0; i < 33; i++)
|
|
pScreenPriv->glyphCache[i].pScreen = NULL;
|
|
|
|
for (v = pScreenPriv->pVisual; v; v = v->next)
|
|
{
|
|
if (v->pPixel->depth == 8)
|
|
break;
|
|
}
|
|
|
|
pScreenPriv->pSolidAlpha = 0;
|
|
pScreenPriv->trapInfo.pMask = 0;
|
|
|
|
/* An accelerated alpha only Xgl visual is required for trapezoid
|
|
acceleration */
|
|
if (v && v->format.surface)
|
|
{
|
|
glitz_surface_t *mask;
|
|
|
|
mask = glitz_surface_create (pScreenPriv->drawable,
|
|
v->format.surface,
|
|
2, 1, 0, NULL);
|
|
if (mask)
|
|
{
|
|
glitz_set_rectangle (mask, &clearBlack, 0, 0, 1, 1);
|
|
glitz_set_rectangle (mask, &solidWhite, 1, 0, 1, 1);
|
|
|
|
glitz_surface_set_fill (mask, GLITZ_FILL_NEAREST);
|
|
glitz_surface_set_filter (mask, GLITZ_FILTER_BILINEAR, NULL, 0);
|
|
|
|
pScreenPriv->trapInfo.pMask = xglCreateDevicePicture (mask);
|
|
if (!pScreenPriv->trapInfo.pMask)
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
format = &pScreenPriv->trapInfo.format.vertex;
|
|
format->primitive = GLITZ_PRIMITIVE_QUADS;
|
|
format->attributes = GLITZ_VERTEX_ATTRIBUTE_MASK_COORD_MASK;
|
|
|
|
format->mask.type = GLITZ_DATA_TYPE_FLOAT;
|
|
format->mask.size = GLITZ_COORDINATE_SIZE_X;
|
|
format->bytes_per_vertex = sizeof (glitz_float_t);
|
|
|
|
if (pScreenPriv->geometryDataType)
|
|
{
|
|
format->type = GLITZ_DATA_TYPE_FLOAT;
|
|
format->bytes_per_vertex += 2 * sizeof (glitz_float_t);
|
|
format->mask.offset = 2 * sizeof (glitz_float_t);
|
|
}
|
|
else
|
|
{
|
|
format->type = GLITZ_DATA_TYPE_SHORT;
|
|
format->bytes_per_vertex += 2 * sizeof (glitz_short_t);
|
|
format->mask.offset = 2 * sizeof (glitz_short_t);
|
|
}
|
|
#endif
|
|
|
|
#ifdef XV
|
|
if (!xglXvScreenInit (pScreen))
|
|
return FALSE;
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
xglCloseScreen (int index,
|
|
ScreenPtr pScreen)
|
|
{
|
|
xglVisualPtr v;
|
|
|
|
XGL_SCREEN_PRIV (pScreen);
|
|
XGL_PIXMAP_PRIV (pScreenPriv->pScreenPixmap);
|
|
|
|
#ifdef RENDER
|
|
int i;
|
|
|
|
for (i = 0; i < 33; i++)
|
|
xglFiniGlyphCache (&pScreenPriv->glyphCache[i]);
|
|
|
|
if (pScreenPriv->pSolidAlpha)
|
|
FreePicture ((pointer) pScreenPriv->pSolidAlpha, 0);
|
|
|
|
if (pScreenPriv->trapInfo.pMask)
|
|
FreePicture ((pointer) pScreenPriv->trapInfo.pMask, 0);
|
|
#endif
|
|
|
|
xglFiniPixmap (pScreenPriv->pScreenPixmap);
|
|
if (pPixmapPriv->pDamage)
|
|
DamageDestroy (pPixmapPriv->pDamage);
|
|
|
|
if (pScreenPriv->surface)
|
|
glitz_surface_destroy (pScreenPriv->surface);
|
|
|
|
GEOMETRY_UNINIT (&pScreenPriv->scratchGeometry);
|
|
|
|
while (pScreenPriv->pVisual)
|
|
{
|
|
v = pScreenPriv->pVisual;
|
|
pScreenPriv->pVisual = v->next;
|
|
xfree (v);
|
|
}
|
|
|
|
#ifdef GLXEXT
|
|
while (pScreenPriv->pGlxVisual)
|
|
{
|
|
v = pScreenPriv->pGlxVisual;
|
|
pScreenPriv->pGlxVisual = v->next;
|
|
xfree (v);
|
|
}
|
|
#endif
|
|
|
|
XGL_SCREEN_UNWRAP (CloseScreen);
|
|
xfree (pScreenPriv);
|
|
|
|
return (*pScreen->CloseScreen) (index, pScreen);
|
|
}
|
|
|
|
#ifdef RENDER
|
|
void
|
|
xglCreateSolidAlphaPicture (ScreenPtr pScreen)
|
|
{
|
|
static xRenderColor solidWhite = { 0xffff, 0xffff, 0xffff, 0xffff };
|
|
static xRectangle one = { 0, 0, 1, 1 };
|
|
PixmapPtr pPixmap;
|
|
PictFormatPtr pFormat;
|
|
int error;
|
|
Pixel pixel;
|
|
GCPtr pGC;
|
|
XID tmpval[2];
|
|
|
|
XGL_SCREEN_PRIV (pScreen);
|
|
|
|
pFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
|
|
if (!pFormat)
|
|
return;
|
|
|
|
pGC = GetScratchGC (pFormat->depth, pScreen);
|
|
if (!pGC)
|
|
return;
|
|
|
|
pPixmap = (*pScreen->CreatePixmap) (pScreen, 1, 1, pFormat->depth);
|
|
if (!pPixmap)
|
|
return;
|
|
|
|
miRenderColorToPixel (pFormat, &solidWhite, &pixel);
|
|
|
|
tmpval[0] = GXcopy;
|
|
tmpval[1] = pixel;
|
|
|
|
ChangeGC (pGC, GCFunction | GCForeground, tmpval);
|
|
ValidateGC (&pPixmap->drawable, pGC);
|
|
(*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &one);
|
|
FreeScratchGC (pGC);
|
|
|
|
tmpval[0] = xTrue;
|
|
pScreenPriv->pSolidAlpha = CreatePicture (0, &pPixmap->drawable, pFormat,
|
|
CPRepeat, tmpval, 0, &error);
|
|
(*pScreen->DestroyPixmap) (pPixmap);
|
|
|
|
if (pScreenPriv->pSolidAlpha)
|
|
ValidatePicture (pScreenPriv->pSolidAlpha);
|
|
}
|
|
#endif
|