qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
8ff87a1d9a
xenocara/xserver/hw/xwin/winscrinit.c

782 lines
22 KiB
C
Raw Blame History

/*
*Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 of the XFree86 Project
*shall not be used in advertising or otherwise to promote the sale, use
*or other dealings in this Software without prior written authorization
*from the XFree86 Project.
*
* Authors: Dakshinamurthy Karra
* Suhaib M Siddiqi
* Peter Busch
* Harold L Hunt II
* Kensuke Matsuzaki
*/
#ifdef HAVE_XWIN_CONFIG_H
#include <xwin-config.h>
#endif
#include "win.h"
#include "winmsg.h"
#include "safeAlpha.h"
#ifdef XWIN_MULTIWINDOWEXTWM
static RootlessFrameProcsRec
winMWExtWMProcs = {
winMWExtWMCreateFrame,
winMWExtWMDestroyFrame,
winMWExtWMMoveFrame,
winMWExtWMResizeFrame,
winMWExtWMRestackFrame,
winMWExtWMReshapeFrame,
winMWExtWMUnmapFrame,
winMWExtWMStartDrawing,
winMWExtWMStopDrawing,
winMWExtWMUpdateRegion,
#ifndef ROOTLESS_TRACK_DAMAGE
winMWExtWMDamageRects,
#endif
winMWExtWMRootlessSwitchWindow,
NULL,//winWMExtWMDoReorderWindow,
NULL,//winMWExtWMCopyBytes,
NULL,//winMWExtWMFillBytes,
NULL,//winMWExtWMCompositePixels,
winMWExtWMCopyWindow
};
#endif
/*
* References to external symbols
*/
extern Bool g_fSoftwareCursor;
/*
* Prototypes
*/
Bool
winRandRInit (ScreenPtr pScreen);
/*
* Local functions
*/
static Bool
winSaveScreen (ScreenPtr pScreen, int on);
/*
* Determine what type of screen we are initializing
* and call the appropriate procedure to intiailize
* that type of screen.
*/
Bool
winScreenInit (int index,
ScreenPtr pScreen,
int argc, char **argv)
{
winScreenInfoPtr pScreenInfo = &g_ScreenInfo[index];
winPrivScreenPtr pScreenPriv;
HDC hdc;
#if CYGDEBUG || YES
winDebug ("winScreenInit - dwWidth: %ld dwHeight: %ld\n",
pScreenInfo->dwWidth, pScreenInfo->dwHeight);
#endif
/* Allocate privates for this screen */
if (!winAllocatePrivates (pScreen))
{
ErrorF ("winScreenInit - Couldn't allocate screen privates\n");
return FALSE;
}
/* Get a pointer to the privates structure that was allocated */
pScreenPriv = winGetScreenPriv (pScreen);
/* Save a pointer to this screen in the screen info structure */
pScreenInfo->pScreen = pScreen;
/* Save a pointer to the screen info in the screen privates structure */
/* This allows us to get back to the screen info from a screen pointer */
pScreenPriv->pScreenInfo = pScreenInfo;
/*
* Determine which engine to use.
*
* NOTE: This is done once per screen because each screen possibly has
* a preferred engine specified on the command line.
*/
if (!winSetEngine (pScreen))
{
ErrorF ("winScreenInit - winSetEngine () failed\n");
return FALSE;
}
/* Adjust the video mode for our engine type */
if (!(*pScreenPriv->pwinAdjustVideoMode) (pScreen))
{
ErrorF ("winScreenInit - winAdjustVideoMode () failed\n");
return FALSE;
}
/* Check for supported display depth */
if (!(WIN_SUPPORTED_BPPS & (1 << (pScreenInfo->dwBPP - 1))))
{
ErrorF ("winScreenInit - Unsupported display depth: %d\n" \
"Change your Windows display depth to 15, 16, 24, or 32 bits "
"per pixel.\n",
(int) pScreenInfo->dwBPP);
ErrorF ("winScreenInit - Supported depths: %08x\n",
WIN_SUPPORTED_BPPS);
#if WIN_CHECK_DEPTH
return FALSE;
#endif
}
/*
* Check that all monitors have the same display depth if we are using
* multiple monitors
*/
if (pScreenInfo->fMultipleMonitors
&& !GetSystemMetrics (SM_SAMEDISPLAYFORMAT))
{
ErrorF ("winScreenInit - Monitors do not all have same pixel format / "
"display depth.\n"
"Using primary display only.\n");
pScreenInfo->fMultipleMonitors = FALSE;
}
/* Create display window */
if (!(*pScreenPriv->pwinCreateBoundingWindow) (pScreen))
{
ErrorF ("winScreenInit - pwinCreateBoundingWindow () "
"failed\n");
return FALSE;
}
/* Get a device context */
hdc = GetDC (pScreenPriv->hwndScreen);
/* Store the initial height, width, and depth of the display */
/* Are we using multiple monitors? */
if (pScreenInfo->fMultipleMonitors)
{
pScreenPriv->dwLastWindowsWidth = GetSystemMetrics (SM_CXVIRTUALSCREEN);
pScreenPriv->dwLastWindowsHeight = GetSystemMetrics (SM_CYVIRTUALSCREEN);
/*
* In this case, some of the defaults set in
* winInitializeDefaultScreens () are not correct ...
*/
if (!pScreenInfo->fUserGaveHeightAndWidth)
{
pScreenInfo->dwWidth = GetSystemMetrics (SM_CXVIRTUALSCREEN);
pScreenInfo->dwHeight = GetSystemMetrics (SM_CYVIRTUALSCREEN);
pScreenInfo->dwWidth_mm = (pScreenInfo->dwWidth /
WIN_DEFAULT_DPI) * 25.4;
pScreenInfo->dwHeight_mm = (pScreenInfo->dwHeight /
WIN_DEFAULT_DPI) * 25.4;
}
}
else
{
pScreenPriv->dwLastWindowsWidth = GetSystemMetrics (SM_CXSCREEN);
pScreenPriv->dwLastWindowsHeight = GetSystemMetrics (SM_CYSCREEN);
}
/* Save the original bits per pixel */
pScreenPriv->dwLastWindowsBitsPixel = GetDeviceCaps (hdc, BITSPIXEL);
/* Release the device context */
ReleaseDC (pScreenPriv->hwndScreen, hdc);
/* Clear the visuals list */
miClearVisualTypes ();
/* Set the padded screen width */
pScreenInfo->dwPaddedWidth = PixmapBytePad (pScreenInfo->dwWidth,
pScreenInfo->dwBPP);
/* Call the engine dependent screen initialization procedure */
if (!((*pScreenPriv->pwinFinishScreenInit) (index, pScreen, argc, argv)))
{
ErrorF ("winScreenInit - winFinishScreenInit () failed\n");
return FALSE;
}
if (!g_fSoftwareCursor)
winInitCursor(pScreen);
else
winErrorFVerb(2, "winScreenInit - Using software cursor\n");
#if CYGDEBUG || YES
winDebug ("winScreenInit - returning\n");
#endif
return TRUE;
}
/* See Porting Layer Definition - p. 20 */
Bool
winFinishScreenInitFB (int index,
ScreenPtr pScreen,
int argc, char **argv)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
VisualPtr pVisual = NULL;
char *pbits = NULL;
#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
int iReturn;
#endif
/* Create framebuffer */
if (!(*pScreenPriv->pwinAllocateFB) (pScreen))
{
ErrorF ("winFinishScreenInitFB - Could not allocate framebuffer\n");
return FALSE;
}
/*
* Grab the number of bits that are used to represent color in each pixel.
*/
if (pScreenInfo->dwBPP == 8)
pScreenInfo->dwDepth = 8;
else
pScreenInfo->dwDepth = winCountBits (pScreenPriv->dwRedMask)
+ winCountBits (pScreenPriv->dwGreenMask)
+ winCountBits (pScreenPriv->dwBlueMask);
winErrorFVerb (2, "winFinishScreenInitFB - Masks: %08x %08x %08x\n",
(unsigned int) pScreenPriv->dwRedMask,
(unsigned int) pScreenPriv->dwGreenMask,
(unsigned int) pScreenPriv->dwBlueMask);
/* Init visuals */
if (!(*pScreenPriv->pwinInitVisuals) (pScreen))
{
ErrorF ("winFinishScreenInitFB - winInitVisuals failed\n");
return FALSE;
}
/* Setup a local variable to point to the framebuffer */
pbits = pScreenInfo->pfb;
/* Apparently we need this for the render extension */
miSetPixmapDepths ();
/* Start fb initialization */
if (!fbSetupScreen (pScreen,
pScreenInfo->pfb,
pScreenInfo->dwWidth, pScreenInfo->dwHeight,
monitorResolution, monitorResolution,
pScreenInfo->dwStride,
pScreenInfo->dwBPP))
{
ErrorF ("winFinishScreenInitFB - fbSetupScreen failed\n");
return FALSE;
}
/* Override default colormap routines if visual class is dynamic */
if (pScreenInfo->dwDepth == 8
&& (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI
|| (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL
&& pScreenInfo->fFullScreen)
|| (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD
&& pScreenInfo->fFullScreen)))
{
winSetColormapFunctions (pScreen);
/*
* NOTE: Setting whitePixel to 255 causes Magic 7.1 to allocate its
* own colormap, as it cannot allocate 7 planes in the default
* colormap. Setting whitePixel to 1 allows Magic to get 7
* planes in the default colormap, so it doesn't create its
* own colormap. This latter situation is highly desireable,
* as it keeps the Magic window viewable when switching to
* other X clients that use the default colormap.
*/
pScreen->blackPixel = 0;
pScreen->whitePixel = 1;
}
/* Place our save screen function */
pScreen->SaveScreen = winSaveScreen;
/* Finish fb initialization */
if (!fbFinishScreenInit (pScreen,
pScreenInfo->pfb,
pScreenInfo->dwWidth, pScreenInfo->dwHeight,
monitorResolution, monitorResolution,
pScreenInfo->dwStride,
pScreenInfo->dwBPP))
{
ErrorF ("winFinishScreenInitFB - fbFinishScreenInit failed\n");
return FALSE;
}
/* Save a pointer to the root visual */
for (pVisual = pScreen->visuals;
pVisual->vid != pScreen->rootVisual;
pVisual++);
pScreenPriv->pRootVisual = pVisual;
/*
* Setup points to the block and wakeup handlers. Pass a pointer
* to the current screen as pWakeupdata.
*/
pScreen->BlockHandler = winBlockHandler;
pScreen->WakeupHandler = winWakeupHandler;
pScreen->blockData = pScreen;
pScreen->wakeupData = pScreen;
#ifdef XWIN_MULTIWINDOWEXTWM
/*
* Setup acceleration for multi-window external window manager mode.
* To be compatible with the Damage extension, this must be done
* before calling miDCInitialize, which calls DamageSetup.
*/
if (pScreenInfo->fMWExtWM)
{
if (!RootlessAccelInit (pScreen))
{
ErrorF ("winFinishScreenInitFB - RootlessAccelInit () failed\n");
return FALSE;
}
}
#endif
#ifdef RENDER
/* Render extension initialization, calls miPictureInit */
if (!fbPictureInit (pScreen, NULL, 0))
{
ErrorF ("winFinishScreenInitFB - fbPictureInit () failed\n");
return FALSE;
}
#endif
#ifdef RANDR
/* Initialize resize and rotate support */
if (!winRandRInit (pScreen))
{
ErrorF ("winFinishScreenInitFB - winRandRInit () failed\n");
return FALSE;
}
#endif
/*
* Backing store support should reduce network traffic and increase
* performance.
*/
miInitializeBackingStore (pScreen);
/* KDrive does miDCInitialize right after miInitializeBackingStore */
/* Setup the cursor routines */
#if CYGDEBUG
winDebug ("winFinishScreenInitFB - Calling miDCInitialize ()\n");
#endif
miDCInitialize (pScreen, &g_winPointerCursorFuncs);
/* KDrive does winCreateDefColormap right after miDCInitialize */
/* Create a default colormap */
#if CYGDEBUG
winDebug ("winFinishScreenInitFB - Calling winCreateDefColormap ()\n");
#endif
if (!winCreateDefColormap (pScreen))
{
ErrorF ("winFinishScreenInitFB - Could not create colormap\n");
return FALSE;
}
/* Initialize the shadow framebuffer layer */
if ((pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI
|| pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD
|| pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL)
#ifdef XWIN_MULTIWINDOWEXTWM
&& !pScreenInfo->fMWExtWM
#endif
)
{
#if CYGDEBUG
winDebug ("winFinishScreenInitFB - Calling shadowInit ()\n");
#endif
if (!shadowInit (pScreen,
pScreenPriv->pwinShadowUpdate,
NULL))
{
ErrorF ("winFinishScreenInitFB - shadowInit () failed\n");
return FALSE;
}
}
#ifdef XWIN_MULTIWINDOWEXTWM
/* Handle multi-window external window manager mode */
if (pScreenInfo->fMWExtWM)
{
winDebug ("winScreenInit - MultiWindowExtWM - Calling RootlessInit\n");
RootlessInit(pScreen, &winMWExtWMProcs);
winDebug ("winScreenInit - MultiWindowExtWM - RootlessInit returned\n");
rootless_CopyBytes_threshold = 0;
rootless_FillBytes_threshold = 0;
rootless_CompositePixels_threshold = 0;
/* FIXME: How many? Profiling needed? */
rootless_CopyWindow_threshold = 1;
winWindowsWMExtensionInit ();
}
#endif
/* Handle rootless mode */
if (pScreenInfo->fRootless)
{
/* Define the WRAP macro temporarily for local use */
#define WRAP(a) \
if (pScreen->a) { \
pScreenPriv->a = pScreen->a; \
} else { \
ErrorF("null screen fn " #a "\n"); \
pScreenPriv->a = NULL; \
}
/* Save a pointer to each lower-level window procedure */
WRAP(CreateWindow);
WRAP(DestroyWindow);
WRAP(RealizeWindow);
WRAP(UnrealizeWindow);
WRAP(PositionWindow);
WRAP(ChangeWindowAttributes);
#ifdef SHAPE
WRAP(SetShape);
#endif
/* Assign rootless window procedures to be top level procedures */
pScreen->CreateWindow = winCreateWindowRootless;
pScreen->DestroyWindow = winDestroyWindowRootless;
pScreen->PositionWindow = winPositionWindowRootless;
/*pScreen->ChangeWindowAttributes = winChangeWindowAttributesRootless;*/
pScreen->RealizeWindow = winMapWindowRootless;
pScreen->UnrealizeWindow = winUnmapWindowRootless;
#ifdef SHAPE
pScreen->SetShape = winSetShapeRootless;
#endif
/* Undefine the WRAP macro, as it is not needed elsewhere */
#undef WRAP
}
#ifdef XWIN_MULTIWINDOW
/* Handle multi window mode */
else if (pScreenInfo->fMultiWindow)
{
/* Define the WRAP macro temporarily for local use */
#define WRAP(a) \
if (pScreen->a) { \
pScreenPriv->a = pScreen->a; \
} else { \
ErrorF("null screen fn " #a "\n"); \
pScreenPriv->a = NULL; \
}
/* Save a pointer to each lower-level window procedure */
WRAP(CreateWindow);
WRAP(DestroyWindow);
WRAP(RealizeWindow);
WRAP(UnrealizeWindow);
WRAP(PositionWindow);
WRAP(ChangeWindowAttributes);
WRAP(ReparentWindow);
WRAP(RestackWindow);
WRAP(ResizeWindow);
WRAP(MoveWindow);
WRAP(CopyWindow);
#ifdef SHAPE
WRAP(SetShape);
#endif
/* Assign multi-window window procedures to be top level procedures */
pScreen->CreateWindow = winCreateWindowMultiWindow;
pScreen->DestroyWindow = winDestroyWindowMultiWindow;
pScreen->PositionWindow = winPositionWindowMultiWindow;
/*pScreen->ChangeWindowAttributes = winChangeWindowAttributesMultiWindow;*/
pScreen->RealizeWindow = winMapWindowMultiWindow;
pScreen->UnrealizeWindow = winUnmapWindowMultiWindow;
pScreen->ReparentWindow = winReparentWindowMultiWindow;
pScreen->RestackWindow = winRestackWindowMultiWindow;
pScreen->ResizeWindow = winResizeWindowMultiWindow;
pScreen->MoveWindow = winMoveWindowMultiWindow;
pScreen->CopyWindow = winCopyWindowMultiWindow;
#ifdef SHAPE
pScreen->SetShape = winSetShapeMultiWindow;
#endif
/* Undefine the WRAP macro, as it is not needed elsewhere */
#undef WRAP
}
#endif
/* Wrap either fb's or shadow's CloseScreen with our CloseScreen */
pScreenPriv->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = pScreenPriv->pwinCloseScreen;
#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
/* Create a mutex for modules in separate threads to wait for */
iReturn = pthread_mutex_init (&pScreenPriv->pmServerStarted, NULL);
if (iReturn != 0)
{
ErrorF ("winFinishScreenInitFB - pthread_mutex_init () failed: %d\n",
iReturn);
return FALSE;
}
/* Own the mutex for modules in separate threads */
iReturn = pthread_mutex_lock (&pScreenPriv->pmServerStarted);
if (iReturn != 0)
{
ErrorF ("winFinishScreenInitFB - pthread_mutex_lock () failed: %d\n",
iReturn);
return FALSE;
}
/* Set the ServerStarted flag to false */
pScreenPriv->fServerStarted = FALSE;
#endif
#ifdef XWIN_MULTIWINDOWEXTWM
pScreenPriv->fRestacking = FALSE;
#endif
#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
if (FALSE
#ifdef XWIN_MULTIWINDOW
|| pScreenInfo->fMultiWindow
#endif
#ifdef XWIN_MULTIWINDOWEXTWM
|| pScreenInfo->fInternalWM
#endif
)
{
#if CYGDEBUG || YES
winDebug ("winFinishScreenInitFB - Calling winInitWM.\n");
#endif
/* Initialize multi window mode */
if (!winInitWM (&pScreenPriv->pWMInfo,
&pScreenPriv->ptWMProc,
&pScreenPriv->ptXMsgProc,
&pScreenPriv->pmServerStarted,
pScreenInfo->dwScreen,
(HWND)&pScreenPriv->hwndScreen,
#ifdef XWIN_MULTIWINDOWEXTWM
pScreenInfo->fInternalWM ||
#endif
FALSE))
{
ErrorF ("winFinishScreenInitFB - winInitWM () failed.\n");
return FALSE;
}
}
#endif
/* Tell the server that we are enabled */
pScreenPriv->fEnabled = TRUE;
/* Tell the server that we have a valid depth */
pScreenPriv->fBadDepth = FALSE;
#if CYGDEBUG || YES
winDebug ("winFinishScreenInitFB - returning\n");
#endif
return TRUE;
}
#ifdef XWIN_NATIVEGDI
/* See Porting Layer Definition - p. 20 */
Bool
winFinishScreenInitNativeGDI (int index,
ScreenPtr pScreen,
int argc, char **argv)
{
winScreenPriv(pScreen);
winScreenInfoPtr pScreenInfo = &g_ScreenInfo[index];
VisualPtr pVisuals = NULL;
DepthPtr pDepths = NULL;
VisualID rootVisual = 0;
int nVisuals = 0, nDepths = 0, nRootDepth = 0;
/* Ignore user input (mouse, keyboard) */
pScreenInfo->fIgnoreInput = FALSE;
/* Get device contexts for the screen and shadow bitmap */
pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);
if (pScreenPriv->hdcScreen == NULL)
FatalError ("winFinishScreenInitNativeGDI - Couldn't get a DC\n");
/* Init visuals */
if (!(*pScreenPriv->pwinInitVisuals) (pScreen))
{
ErrorF ("winFinishScreenInitNativeGDI - pwinInitVisuals failed\n");
return FALSE;
}
/* Initialize the mi visuals */
if (!miInitVisuals (&pVisuals, &pDepths, &nVisuals, &nDepths, &nRootDepth,
&rootVisual,
((unsigned long)1 << (pScreenInfo->dwDepth - 1)), 8,
TrueColor))
{
ErrorF ("winFinishScreenInitNativeGDI - miInitVisuals () failed\n");
return FALSE;
}
/* Initialize the CloseScreen procedure pointer */
pScreen->CloseScreen = NULL;
/* Initialize the mi code */
if (!miScreenInit (pScreen,
NULL, /* No framebuffer */
pScreenInfo->dwWidth, pScreenInfo->dwHeight,
monitorResolution, monitorResolution,
pScreenInfo->dwStride,
nRootDepth, nDepths, pDepths, rootVisual,
nVisuals, pVisuals))
{
ErrorF ("winFinishScreenInitNativeGDI - miScreenInit failed\n");
return FALSE;
}
pScreen->defColormap = FakeClientID(0);
/*
* Register our block and wakeup handlers; these procedures
* process messages in our Windows message queue; specifically,
* they process mouse and keyboard input.
*/
pScreen->BlockHandler = winBlockHandler;
pScreen->WakeupHandler = winWakeupHandler;
pScreen->blockData = pScreen;
pScreen->wakeupData = pScreen;
/* Place our save screen function */
pScreen->SaveScreen = winSaveScreen;
/* Pixmaps */
pScreen->CreatePixmap = winCreatePixmapNativeGDI;
pScreen->DestroyPixmap = winDestroyPixmapNativeGDI;
/* Other Screen Routines */
pScreen->QueryBestSize = winQueryBestSizeNativeGDI;
pScreen->SaveScreen = winSaveScreen;
pScreen->GetImage = miGetImage;
pScreen->GetSpans = winGetSpansNativeGDI;
/* Window Procedures */
pScreen->CreateWindow = winCreateWindowNativeGDI;
pScreen->DestroyWindow = winDestroyWindowNativeGDI;
pScreen->PositionWindow = winPositionWindowNativeGDI;
/*pScreen->ChangeWindowAttributes = winChangeWindowAttributesNativeGDI;*/
pScreen->RealizeWindow = winMapWindowNativeGDI;
pScreen->UnrealizeWindow = winUnmapWindowNativeGDI;
/* Paint window */
pScreen->CopyWindow = winCopyWindowNativeGDI;
/* Fonts */
pScreen->RealizeFont = winRealizeFontNativeGDI;
pScreen->UnrealizeFont = winUnrealizeFontNativeGDI;
/* GC */
pScreen->CreateGC = winCreateGCNativeGDI;
/* Colormap Routines */
pScreen->CreateColormap = miInitializeColormap;
pScreen->DestroyColormap = (DestroyColormapProcPtr) (void (*)(void)) NoopDDA;
pScreen->InstallColormap = miInstallColormap;
pScreen->UninstallColormap = miUninstallColormap;
pScreen->ListInstalledColormaps = miListInstalledColormaps;
pScreen->StoreColors = (StoreColorsProcPtr) (void (*)(void)) NoopDDA;
pScreen->ResolveColor = miResolveColor;
/* Bitmap */
pScreen->BitmapToRegion = winPixmapToRegionNativeGDI;
ErrorF ("winFinishScreenInitNativeGDI - calling miDCInitialize\n");
/* Set the default white and black pixel positions */
pScreen->whitePixel = pScreen->blackPixel = (Pixel) 0;
/* Initialize the cursor */
if (!miDCInitialize (pScreen, &g_winPointerCursorFuncs))
{
ErrorF ("winFinishScreenInitNativeGDI - miDCInitialize failed\n");
return FALSE;
}
/* Create a default colormap */
if (!miCreateDefColormap (pScreen))
{
ErrorF ("winFinishScreenInitNativeGDI - miCreateDefColormap () "
"failed\n");
return FALSE;
}
ErrorF ("winFinishScreenInitNativeGDI - miCreateDefColormap () "
"returned\n");
/* mi doesn't use a CloseScreen procedure, so no need to wrap */
pScreen->CloseScreen = pScreenPriv->pwinCloseScreen;
/* Tell the server that we are enabled */
pScreenPriv->fEnabled = TRUE;
ErrorF ("winFinishScreenInitNativeGDI - Successful addition of "
"screen %08x\n",
(unsigned int) pScreen);
return TRUE;
}
#endif
/* See Porting Layer Definition - p. 33 */
static Bool
winSaveScreen (ScreenPtr pScreen, int on)
{
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink