478 lines
12 KiB
C
478 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
|
|
|
|
XGL_SCREEN_WRAP (BackingStoreFuncs.SaveAreas, xglSaveAreas);
|
|
XGL_SCREEN_WRAP (BackingStoreFuncs.RestoreAreas, xglRestoreAreas);
|
|
|
|
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
|