301 lines
8.5 KiB
C
301 lines
8.5 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 names 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@freedesktop.org>
|
|
*/
|
|
|
|
#include "xgl.h"
|
|
#include "inputstr.h"
|
|
#include "mipointer.h"
|
|
#include "damage.h"
|
|
#include "fb.h"
|
|
|
|
int xglScreenGeneration = -1;
|
|
int xglScreenPrivateIndex;
|
|
int xglGCPrivateIndex;
|
|
int xglPixmapPrivateIndex;
|
|
int xglWinPrivateIndex;
|
|
|
|
#define xglQueryBestSize (void *) NoopDDA
|
|
#define xglSaveScreen (void *) NoopDDA
|
|
|
|
#define xglRealizeFont (void *) NoopDDA
|
|
#define xglUnrealizeFont (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
|
|
|
|
#define xglCreateColormap (void *) NoopDDA
|
|
#define xglDestroyColormap (void *) NoopDDA
|
|
#define xglInstallColormap (void *) NoopDDA
|
|
#define xglUninstallColormap (void *) NoopDDA
|
|
#define xglListInstalledColormaps (void *) NoopDDA
|
|
#define xglStoreColors (void *) NoopDDA
|
|
#define xglResolveColor (void *) NoopDDA
|
|
|
|
static PixmapPtr
|
|
xglGetWindowPixmap (WindowPtr pWin)
|
|
{
|
|
return XGL_GET_WINDOW_PIXMAP (pWin);
|
|
}
|
|
|
|
static void
|
|
xglSetWindowPixmap (WindowPtr pWin,
|
|
PixmapPtr pPixmap)
|
|
{
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
|
|
XGL_SCREEN_PRIV (pScreen);
|
|
|
|
XGL_SCREEN_UNWRAP (SetWindowPixmap);
|
|
(*pScreen->SetWindowPixmap) (pWin, pPixmap);
|
|
XGL_SCREEN_WRAP (SetWindowPixmap, xglSetWindowPixmap);
|
|
|
|
XGL_GET_WINDOW_PRIV(pWin)->pPixmap = pPixmap;
|
|
}
|
|
|
|
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;
|
|
|
|
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,
|
|
xglScreenInfoPtr pScreenInfo)
|
|
{
|
|
xglScreenPtr pScreenPriv;
|
|
|
|
#ifdef RENDER
|
|
PictureScreenPtr pPictureScreen;
|
|
#endif
|
|
|
|
if (!xglAllocatePrivates (pScreen))
|
|
return FALSE;
|
|
|
|
pScreenPriv = XGL_GET_SCREEN_PRIV (pScreen);
|
|
|
|
pScreenPriv->pScreenPixmap = NULL;
|
|
|
|
pScreenPriv->pVisual = &xglVisuals[0];
|
|
pScreenPriv->drawable = pScreenInfo->drawable;
|
|
pScreenPriv->features =
|
|
glitz_drawable_get_features (pScreenInfo->drawable);
|
|
|
|
if (!xglInitOffscreen (pScreen, pScreenInfo))
|
|
return FALSE;
|
|
|
|
xglInitPixmapFormats (pScreen);
|
|
if (!pScreenPriv->pixmapFormats[32].format)
|
|
return FALSE;
|
|
|
|
pScreenPriv->surface =
|
|
glitz_surface_create (pScreenPriv->drawable,
|
|
pScreenPriv->pixmapFormats[32].format,
|
|
pScreenInfo->width, pScreenInfo->height);
|
|
if (!pScreenPriv->surface)
|
|
return FALSE;
|
|
|
|
glitz_surface_attach (pScreenPriv->surface,
|
|
pScreenPriv->drawable,
|
|
GLITZ_DRAWABLE_BUFFER_FRONT_COLOR,
|
|
0, 0);
|
|
|
|
if (monitorResolution == 0)
|
|
monitorResolution = XGL_DEFAULT_DPI;
|
|
|
|
if (!fbSetupScreen (pScreen, NULL,
|
|
pScreenInfo->width, pScreenInfo->height,
|
|
monitorResolution, monitorResolution,
|
|
pScreenInfo->width,
|
|
pScreenPriv->pVisual->pPixel->masks.bpp))
|
|
return FALSE;
|
|
|
|
pScreen->SaveScreen = xglSaveScreen;
|
|
|
|
pScreen->CreatePixmap = xglCreatePixmap;
|
|
pScreen->DestroyPixmap = xglDestroyPixmap;
|
|
|
|
if (!fbFinishScreenInit (pScreen, NULL,
|
|
pScreenInfo->width, pScreenInfo->height,
|
|
monitorResolution, monitorResolution,
|
|
pScreenInfo->width,
|
|
pScreenPriv->pVisual->pPixel->masks.bpp))
|
|
return FALSE;
|
|
|
|
#ifdef RENDER
|
|
if (!fbPictureInit (pScreen, 0, 0))
|
|
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 (PaintWindowBackground, xglPaintWindowBackground);
|
|
XGL_SCREEN_WRAP (PaintWindowBorder, xglPaintWindowBorder);
|
|
|
|
/*
|
|
pScreen->RealizeFont = xglRealizeFont;
|
|
pScreen->UnrealizeFont = xglUnrealizeFont;
|
|
*/
|
|
|
|
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->CreateColormap = miInitializeColormap;
|
|
pScreen->DestroyColormap = xglDestroyColormap;
|
|
pScreen->InstallColormap = miInstallColormap;
|
|
pScreen->UninstallColormap = miUninstallColormap;
|
|
pScreen->ListInstalledColormaps = miListInstalledColormaps;
|
|
pScreen->StoreColors = xglStoreColors;
|
|
pScreen->ResolveColor = miResolveColor;
|
|
*/
|
|
|
|
pScreen->ModifyPixmapHeader = xglModifyPixmapHeader;
|
|
|
|
XGL_SCREEN_WRAP (BitmapToRegion, xglPixmapToRegion);
|
|
|
|
pScreen->GetWindowPixmap = xglGetWindowPixmap;
|
|
|
|
XGL_SCREEN_WRAP (SetWindowPixmap, xglSetWindowPixmap);
|
|
|
|
#ifdef RENDER
|
|
pPictureScreen = GetPictureScreenIfSet (pScreen);
|
|
if (pPictureScreen) {
|
|
XGL_PICTURE_SCREEN_WRAP (Composite, xglComposite);
|
|
XGL_PICTURE_SCREEN_WRAP (Glyphs, xglGlyphs);
|
|
XGL_PICTURE_SCREEN_WRAP (RasterizeTrapezoid, xglRasterizeTrapezoid);
|
|
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);
|
|
|
|
/* Damage is required */
|
|
DamageSetup (pScreen);
|
|
|
|
XGL_SCREEN_WRAP (CloseScreen, xglCloseScreen);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
xglFinishScreenInit (ScreenPtr pScreen)
|
|
{
|
|
XGL_SCREEN_PRIV (pScreen);
|
|
|
|
miInitializeBackingStore (pScreen);
|
|
|
|
if (!fbCreateDefColormap (pScreen))
|
|
return FALSE;
|
|
|
|
pScreenPriv->solid =
|
|
glitz_surface_create (pScreenPriv->drawable,
|
|
pScreenPriv->pixmapFormats[32].format,
|
|
1, 1);
|
|
if (!pScreenPriv->solid)
|
|
return FALSE;
|
|
|
|
glitz_surface_set_fill (pScreenPriv->solid, GLITZ_FILL_REPEAT);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
xglCloseScreen (int index,
|
|
ScreenPtr pScreen)
|
|
{
|
|
XGL_SCREEN_PRIV (pScreen);
|
|
|
|
if (pScreenPriv->solid)
|
|
glitz_surface_destroy (pScreenPriv->solid);
|
|
|
|
if (pScreenPriv->surface)
|
|
glitz_surface_destroy (pScreenPriv->surface);
|
|
|
|
xglFiniOffscreen (pScreen);
|
|
|
|
XGL_SCREEN_UNWRAP (CloseScreen);
|
|
xfree (pScreenPriv);
|
|
|
|
return (*pScreen->CloseScreen) (index, pScreen);
|
|
}
|