Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 473 insertions, 0 deletions

diff --git a/xorg-server/hw/xgl/xglscreen.c b/xorg-server/hw/xgl/xglscreen.c
new file mode 100644
index 000000000..47ed34508
--- /dev/null
+++ b/xorg-server/hw/xgl/xglscreen.c
@@ -0,0 +1,473 @@
+/*
+ * 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 (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, 0);
+    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,
+					      serverClient, &error);
+    (*pScreen->DestroyPixmap) (pPixmap);
+
+    if (pScreenPriv->pSolidAlpha)
+	ValidatePicture (pScreenPriv->pSolidAlpha);
+}
+#endif