int
winKeybdProc (DeviceIntPtr pDeviceInt, int iState)
{
DevicePtr pDevice = (DevicePtr) pDeviceInt;
XkbSrvInfoPtr xkbi;
XkbControlsPtr ctrl;
switch (iState)
{
case DEVICE_INIT:
winConfigKeyboard (pDeviceInt);
/* FIXME: Maybe we should use winGetKbdLeds () here? */
defaultKeyboardControl.leds = g_winInfo.keyboard.leds;
winErrorFVerb(2, "Rules = \"%s\" Model = \"%s\" Layout = \"%s\""
" Variant = \"%s\" Options = \"%s\"\n",
g_winInfo.xkb.rules ? g_winInfo.xkb.rules : "none",
g_winInfo.xkb.model ? g_winInfo.xkb.model : "none",
g_winInfo.xkb.layout ? g_winInfo.xkb.layout : "none",
g_winInfo.xkb.variant ? g_winInfo.xkb.variant : "none",
g_winInfo.xkb.options ? g_winInfo.xkb.options : "none");
InitKeyboardDeviceStruct (pDeviceInt,
&g_winInfo.xkb,
winKeybdBell,
winKeybdCtrl);
xkbi = pDeviceInt->key->xkbInfo;
if ((xkbi != NULL) && (xkbi->desc != NULL))
{
ctrl = xkbi->desc->ctrls;
ctrl->repeat_delay = g_winInfo.keyboard.delay;
ctrl->repeat_interval = 1000/g_winInfo.keyboard.rate;
}
else
{
winErrorFVerb (1, "winKeybdProc - Error initializing keyboard AutoRepeat\n");
}
break;
case DEVICE_ON:
pDevice->on = TRUE;
// immediately copy the state of this keyboard device to the VCK
// (which otherwise happens lazily after the first keypress)
CopyKeyClass(pDeviceInt, inputInfo.keyboard);
break;
case DEVICE_CLOSE:
case DEVICE_OFF:
pDevice->on = FALSE;
break;
}
return Success;
}
void
winDetectSupportedEngines(void)
{
/* Initialize the engine support flags */
g_dwEnginesSupported = WIN_SERVER_SHADOW_GDI;
/* Do we have DirectDraw? */
if (g_hmodDirectDraw != NULL) {
LPDIRECTDRAW lpdd = NULL;
LPDIRECTDRAW4 lpdd4 = NULL;
HRESULT ddrval;
/* Was the DirectDrawCreate function found? */
if (g_fpDirectDrawCreate == NULL) {
/* No DirectDraw support */
return;
}
/* DirectDrawCreate exists, try to call it */
/* Create a DirectDraw object, store the address at lpdd */
ddrval = (*g_fpDirectDrawCreate) (NULL, (void **) &lpdd, NULL);
if (FAILED(ddrval)) {
/* No DirectDraw support */
winErrorFVerb(2,
"winDetectSupportedEngines - DirectDraw not installed\n");
return;
}
/* Try to query for DirectDraw4 interface */
ddrval = IDirectDraw_QueryInterface(lpdd,
&IID_IDirectDraw4,
(LPVOID *) &lpdd4);
if (SUCCEEDED(ddrval)) {
/* We have DirectDraw4 */
winErrorFVerb(2,
"winDetectSupportedEngines - DirectDraw4 installed, allowing ShadowDDNL\n");
g_dwEnginesSupported |= WIN_SERVER_SHADOW_DDNL;
}
/* Cleanup DirectDraw interfaces */
if (lpdd4 != NULL)
IDirectDraw_Release(lpdd4);
if (lpdd != NULL)
IDirectDraw_Release(lpdd);
}
winErrorFVerb(2,
"winDetectSupportedEngines - Returning, supported engines %08x\n",
(unsigned int) g_dwEnginesSupported);
}
static void
winPointerWarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{
winScreenPriv(pScreen);
RECT rcClient;
static Bool s_fInitialWarp = TRUE;
/* Discard first warp call */
if (s_fInitialWarp)
{
/* First warp moves mouse to center of window, just ignore it */
/* Don't ignore subsequent warps */
s_fInitialWarp = FALSE;
winErrorFVerb (2, "winPointerWarpCursor - Discarding first warp: %d %d\n",
x, y);
return;
}
/*
Only update the Windows cursor position if root window is active,
or we are in a rootless mode
*/
if ((pScreenPriv->hwndScreen == GetForegroundWindow ())
|| pScreenPriv->pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOW
|| pScreenPriv->pScreenInfo->fMultiWindow
#endif
)
{
/* Get the client area coordinates */
GetClientRect (pScreenPriv->hwndScreen, &rcClient);
/* Translate the client area coords to screen coords */
MapWindowPoints (pScreenPriv->hwndScreen,
HWND_DESKTOP,
(LPPOINT)&rcClient,
2);
/*
* Update the Windows cursor position so that we don't
* immediately warp back to the current position.
*/
SetCursorPos (rcClient.left + x, rcClient.top + y);
}
/* Call the mi warp procedure to do the actual warping in X. */
miPointerWarpCursor (pDev, pScreen, x, y);
}
void
winW32ErrorEx(int verb, const char *msg, DWORD errorcode)
{
LPVOID buffer;
if (!FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
errorcode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &buffer,
0,
NULL ))
{
winErrorFVerb(verb, "Unknown error in FormatMessage!\n");
}
else
{
winErrorFVerb(verb, "%s %s", msg, (char *)buffer);
LocalFree(buffer);
}
}
static void
winInitializeScreen(int i)
{
winErrorFVerb (2, "winInitializeScreen - %d\n",i);
/* Initialize default screen values, if needed */
winInitializeScreenDefaults();
/* Copy the default screen info */
g_ScreenInfo[i] = defaultScreenInfo;
/* Set the screen number */
g_ScreenInfo[i].dwScreen = i;
}
void
winInitializeScreens(int maxscreens)
{
int i;
winErrorFVerb (2, "winInitializeScreens - %i\n", maxscreens);
if (maxscreens > g_iNumScreens)
{
/* Reallocate the memory for DDX-specific screen info */
g_ScreenInfo = realloc(g_ScreenInfo, maxscreens * sizeof (winScreenInfo));
/* Set default values for any new screens */
for (i = g_iNumScreens; i < maxscreens ; i++)
winInitializeScreen(i);
/* Keep a count of the number of screens */
g_iNumScreens = maxscreens;
}
}
void
InitOutput(ScreenInfo * screenInfo, int argc, char *argv[])
{
int i;
/* Log the command line */
winLogCommandLine(argc, argv);
#if CYGDEBUG
winDebug("InitOutput\n");
#endif
/* Validate command-line arguments */
if (serverGeneration == 1 && !winValidateArgs()) {
FatalError("InitOutput - Invalid command-line arguments found. "
"Exiting.\n");
}
/* Check for duplicate invocation on same display number. */
if (serverGeneration == 1 && !winCheckDisplayNumber()) {
if (g_fSilentDupError)
g_fSilentFatalError = TRUE;
FatalError("InitOutput - Duplicate invocation on display "
"number: %s. Exiting.\n", display);
}
#ifdef XWIN_XF86CONFIG
/* Try to read the xorg.conf-style configuration file */
if (!winReadConfigfile())
winErrorFVerb(1, "InitOutput - Error reading config file\n");
#else
winMsg(X_INFO, "xorg.conf is not supported\n");
winMsg(X_INFO, "See http://x.cygwin.com/docs/faq/cygwin-x-faq.html "
"for more information\n");
winConfigFiles();
#endif
/* Load preferences from XWinrc file */
LoadPreferences();
/* Setup global screen info parameters */
screenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
screenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
screenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
screenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
screenInfo->numPixmapFormats = NUMFORMATS;
/* Describe how we want common pixmap formats padded */
for (i = 0; i < NUMFORMATS; i++) {
screenInfo->formats[i] = g_PixmapFormats[i];
}
/* Load pointers to DirectDraw functions */
winGetDDProcAddresses();
/* Detect supported engines */
winDetectSupportedEngines();
/* Store the instance handle */
g_hInstance = GetModuleHandle(NULL);
/* Initialize each screen */
for (i = 0; i < g_iNumScreens; ++i) {
/* Initialize the screen */
if (-1 == AddScreen(winScreenInit, argc, argv)) {
FatalError("InitOutput - Couldn't add screen %d", i);
}
}
#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
/* Generate a cookie used by internal clients for authorization */
if (g_fXdmcpEnabled || g_fAuthEnabled)
winGenerateAuthorization();
/* Perform some one time initialization */
if (1 == serverGeneration) {
/*
* setlocale applies to all threads in the current process.
* Apply locale specified in LANG environment variable.
*/
setlocale(LC_ALL, "");
}
#endif
#if CYGDEBUG || YES
winDebug("InitOutput - Returning.\n");
#endif
}
static void
winInitializeScreenDefaults(void)
{
DWORD dwWidth, dwHeight;
static Bool fInitializedScreenDefaults = FALSE;
/* Bail out early if default screen has already been initialized */
if (fInitializedScreenDefaults)
return;
/* Zero the memory used for storing the screen info */
memset(&defaultScreenInfo, 0, sizeof(winScreenInfo));
/* Get default width and height */
/*
* NOTE: These defaults will cause the window to cover only
* the primary monitor in the case that we have multiple monitors.
*/
dwWidth = GetSystemMetrics (SM_CXSCREEN);
dwHeight = GetSystemMetrics (SM_CYSCREEN);
winErrorFVerb (2, "winInitializeScreenDefaults - w %d h %d\n",
(int) dwWidth, (int) dwHeight);
/* Set a default DPI, if no parameter was passed */
if (monitorResolution == 0)
monitorResolution = WIN_DEFAULT_DPI;
defaultScreenInfo.dwWidth = dwWidth;
defaultScreenInfo.dwHeight = dwHeight;
defaultScreenInfo.dwUserWidth = dwWidth;
defaultScreenInfo.dwUserHeight = dwHeight;
defaultScreenInfo.fUserGaveHeightAndWidth = WIN_DEFAULT_USER_GAVE_HEIGHT_AND_WIDTH;
defaultScreenInfo.fUserGavePosition = FALSE;
defaultScreenInfo.dwBPP = WIN_DEFAULT_BPP;
defaultScreenInfo.dwClipUpdatesNBoxes = WIN_DEFAULT_CLIP_UPDATES_NBOXES;
#ifdef XWIN_EMULATEPSEUDO
defaultScreenInfo.fEmulatePseudo = WIN_DEFAULT_EMULATE_PSEUDO;
#endif
defaultScreenInfo.dwRefreshRate = WIN_DEFAULT_REFRESH;
defaultScreenInfo.pfb = NULL;
defaultScreenInfo.fFullScreen = FALSE;
defaultScreenInfo.fDecoration = TRUE;
#ifdef XWIN_MULTIWINDOWEXTWM
defaultScreenInfo.fMWExtWM = FALSE;
defaultScreenInfo.fInternalWM = FALSE;
#endif
defaultScreenInfo.fRootless = FALSE;
#ifdef XWIN_MULTIWINDOW
defaultScreenInfo.fMultiWindow = FALSE;
#endif
#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
defaultScreenInfo.fMultiMonitorOverride = FALSE;
#endif
defaultScreenInfo.fMultipleMonitors = FALSE;
defaultScreenInfo.fLessPointer = FALSE;
defaultScreenInfo.fScrollbars = FALSE;
defaultScreenInfo.fNoTrayIcon = FALSE;
defaultScreenInfo.iE3BTimeout = WIN_E3B_OFF;
defaultScreenInfo.dwWidth_mm = (dwWidth / WIN_DEFAULT_DPI) * 25.4;
defaultScreenInfo.dwHeight_mm = (dwHeight / WIN_DEFAULT_DPI) * 25.4;
defaultScreenInfo.fUseWinKillKey = WIN_DEFAULT_WIN_KILL;
defaultScreenInfo.fUseUnixKillKey = WIN_DEFAULT_UNIX_KILL;
defaultScreenInfo.fIgnoreInput = FALSE;
defaultScreenInfo.fExplicitScreen = FALSE;
/* Note that the default screen has been initialized */
fInitializedScreenDefaults = TRUE;
}
static Bool
winBltExposedRegionsShadowDDNL (ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
RECT rcSrc, rcDest;
POINT ptOrigin;
HDC hdcUpdate;
PAINTSTRUCT ps;
HRESULT ddrval = DD_OK;
Bool fReturn = TRUE;
int i;
/* Quite common case. The primary surface was lost (maybe because of depth
* change). Try to create a new primary surface. Bail out if this fails */
if (pScreenPriv->pddsPrimary4 == NULL && pScreenPriv->fRetryCreateSurface &&
!winCreatePrimarySurfaceShadowDDNL(pScreen))
{
Sleep(100);
return FALSE;
}
if (pScreenPriv->pddsPrimary4 == NULL)
return FALSE;
/* BeginPaint gives us an hdc that clips to the invalidated region */
hdcUpdate = BeginPaint (pScreenPriv->hwndScreen, &ps);
if (hdcUpdate == NULL)
{
fReturn = FALSE;
ErrorF ("winBltExposedRegionsShadowDDNL - BeginPaint () returned "
"a NULL device context handle. Aborting blit attempt.\n");
goto winBltExposedRegionsShadowDDNL_Exit;
}
/* Get the origin of the window in the screen coords */
ptOrigin.x = pScreenInfo->dwXOffset;
ptOrigin.y = pScreenInfo->dwYOffset;
MapWindowPoints (pScreenPriv->hwndScreen,
HWND_DESKTOP,
(LPPOINT)&ptOrigin, 1);
rcDest.left = ptOrigin.x;
rcDest.right = ptOrigin.x + pScreenInfo->dwWidth;
rcDest.top = ptOrigin.y;
rcDest.bottom = ptOrigin.y + pScreenInfo->dwHeight;
/* Source can be entire shadow surface, as Blt should clip for us */
rcSrc.left = 0;
rcSrc.top = 0;
rcSrc.right = pScreenInfo->dwWidth;
rcSrc.bottom = pScreenInfo->dwHeight;
/* Try to regain the primary surface and blit again if we've lost it */
for (i = 0; i <= WIN_REGAIN_SURFACE_RETRIES; ++i)
{
/* Our Blt should be clipped to the invalidated region */
ddrval = IDirectDrawSurface4_Blt (pScreenPriv->pddsPrimary4,
&rcDest,
pScreenPriv->pddsShadow4,
&rcSrc,
DDBLT_WAIT,
NULL);
if (ddrval == DDERR_SURFACELOST)
{
/* Surface was lost */
winErrorFVerb (1, "winBltExposedRegionsShadowDDNL - "
"IDirectDrawSurface4_Blt reported that the primary "
"surface was lost, trying to restore, retry: %d\n", i + 1);
/* Try to restore the surface, once */
ddrval = IDirectDrawSurface4_Restore (pScreenPriv->pddsPrimary4);
winDebug ("winBltExposedRegionsShadowDDNL - "
"IDirectDrawSurface4_Restore returned: ");
if (ddrval == DD_OK)
winDebug ("DD_OK\n");
else if (ddrval == DDERR_WRONGMODE)
winDebug ("DDERR_WRONGMODE\n");
else if (ddrval == DDERR_INCOMPATIBLEPRIMARY)
winDebug ("DDERR_INCOMPATIBLEPRIMARY\n");
else if (ddrval == DDERR_UNSUPPORTED)
winDebug ("DDERR_UNSUPPORTED\n");
else if (ddrval == DDERR_INVALIDPARAMS)
winDebug ("DDERR_INVALIDPARAMS\n");
else if (ddrval == DDERR_INVALIDOBJECT)
winDebug ("DDERR_INVALIDOBJECT\n");
else
winDebug ("unknown error: %08x\n", (unsigned int) ddrval);
/* Loop around to try the blit one more time */
continue;
}
else if (FAILED (ddrval))
{
fReturn = FALSE;
winErrorFVerb (1, "winBltExposedRegionsShadowDDNL - "
"IDirectDrawSurface4_Blt failed, but surface not "
"lost: %08x %d\n",
(unsigned int) ddrval, (int) ddrval);
goto winBltExposedRegionsShadowDDNL_Exit;
}
else
{
/* Success, stop looping */
break;
}
}
winBltExposedRegionsShadowDDNL_Exit:
/* EndPaint frees the DC */
if (hdcUpdate != NULL)
EndPaint (pScreenPriv->hwndScreen, &ps);
return fReturn;
}
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
* winInitializeScreenDefaults() 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");
/*
Note the screen origin in a normalized coordinate space where (0,0) is at the top left
of the native virtual desktop area
*/
pScreen->x = pScreenInfo->dwInitialX - GetSystemMetrics(SM_XVIRTUALSCREEN);
pScreen->y = pScreenInfo->dwInitialY - GetSystemMetrics(SM_YVIRTUALSCREEN);
ErrorF("Screen %d added at virtual desktop coordinate (%d,%d).\n",
index, pScreen->x, pScreen->y);
#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;
/* Render extension initialization, calls miPictureInit */
if (!fbPictureInit (pScreen, NULL, 0))
{
ErrorF ("winFinishScreenInitFB - fbPictureInit () failed\n");
return FALSE;
}
#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 shadowSetup ()\n");
#endif
if (!shadowSetup(pScreen))
{
ErrorF ("winFinishScreenInitFB - shadowSetup () failed\n");
return FALSE;
}
/* Wrap CreateScreenResources so we can add the screen pixmap
to the Shadow framebuffer after it's been created */
pScreenPriv->pwinCreateScreenResources = pScreen->CreateScreenResources;
pScreen->CreateScreenResources = winCreateScreenResources;
}
#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;
/* 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);
WRAP(SetShape);
/* 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;
pScreen->SetShape = winSetShapeRootless;
/* 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);
WRAP(SetShape);
/* 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;
pScreen->SetShape = winSetShapeMultiWindow;
/* 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;
}
LRESULT CALLBACK
winClipboardWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HWND s_hwndNextViewer;
static Bool s_fCBCInitialized;
/* Branch on message type */
switch (message) {
case WM_DESTROY:
{
winDebug("winClipboardWindowProc - WM_DESTROY\n");
/* Remove ourselves from the clipboard chain */
ChangeClipboardChain(hwnd, s_hwndNextViewer);
s_hwndNextViewer = NULL;
PostQuitMessage(0);
}
return 0;
case WM_CREATE:
{
HWND first, next;
DWORD error_code = 0;
winDebug("winClipboardWindowProc - WM_CREATE\n");
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
if (first == hwnd)
return 0; /* Make sure it's not us! */
/* Add ourselves to the clipboard viewer chain */
next = SetClipboardViewer(hwnd);
error_code = GetLastError();
if (SUCCEEDED(error_code) && (next == first)) /* SetClipboardViewer must have succeeded, and the handle */
s_hwndNextViewer = next; /* it returned must have been the first window in the chain */
else
s_fCBCInitialized = FALSE;
}
return 0;
case WM_CHANGECBCHAIN:
{
winDebug("winClipboardWindowProc - WM_CHANGECBCHAIN: wParam(%x) "
"lParam(%x) s_hwndNextViewer(%x)\n",
wParam, lParam, s_hwndNextViewer);
if ((HWND) wParam == s_hwndNextViewer) {
s_hwndNextViewer = (HWND) lParam;
if (s_hwndNextViewer == hwnd) {
s_hwndNextViewer = NULL;
winErrorFVerb(1, "winClipboardWindowProc - WM_CHANGECBCHAIN: "
"attempted to set next window to ourselves.");
}
}
else if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
}
winDebug("winClipboardWindowProc - WM_CHANGECBCHAIN: Exit\n");
return 0;
case WM_WM_REINIT:
{
/* Ensure that we're in the clipboard chain. Some apps,
* WinXP's remote desktop for one, don't play nice with the
* chain. This message is called whenever we receive a
* WM_ACTIVATEAPP message to ensure that we continue to
* receive clipboard messages.
*
* It might be possible to detect if we're still in the chain
* by calling SendMessage (GetClipboardViewer(),
* WM_DRAWCLIPBOARD, 0, 0); and then seeing if we get the
* WM_DRAWCLIPBOARD message. That, however, might be more
* expensive than just putting ourselves back into the chain.
*/
HWND first, next;
DWORD error_code = 0;
winDebug("winClipboardWindowProc - WM_WM_REINIT: Enter\n");
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
if (first == hwnd)
return 0; /* Make sure it's not us! */
winDebug(" WM_WM_REINIT: Replacing us(%x) with %x at head "
"of chain\n", hwnd, s_hwndNextViewer);
s_fCBCInitialized = FALSE;
ChangeClipboardChain(hwnd, s_hwndNextViewer);
s_hwndNextViewer = NULL;
s_fCBCInitialized = FALSE;
winDebug(" WM_WM_REINIT: Putting us back at head of chain.\n");
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
if (first == hwnd)
return 0; /* Make sure it's not us! */
next = SetClipboardViewer(hwnd);
error_code = GetLastError();
if (SUCCEEDED(error_code) && (next == first)) /* SetClipboardViewer must have succeeded, and the handle */
s_hwndNextViewer = next; /* it returned must have been the first window in the chain */
else
s_fCBCInitialized = FALSE;
}
winDebug("winClipboardWindowProc - WM_WM_REINIT: Exit\n");
return 0;
case WM_DRAWCLIPBOARD:
{
static Atom atomClipboard;
static int generation;
static Bool s_fProcessingDrawClipboard = FALSE;
Display *pDisplay = g_pClipboardDisplay;
Window iWindow = g_iClipboardWindow;
int iReturn;
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Enter\n");
if (generation != serverGeneration) {
generation = serverGeneration;
atomClipboard = XInternAtom(pDisplay, "CLIPBOARD", False);
}
/*
* We've occasionally seen a loop in the clipboard chain.
* Try and fix it on the first hint of recursion.
*/
if (!s_fProcessingDrawClipboard) {
s_fProcessingDrawClipboard = TRUE;
}
else {
/* Attempt to break the nesting by getting out of the chain, twice?, and then fix and bail */
s_fCBCInitialized = FALSE;
ChangeClipboardChain(hwnd, s_hwndNextViewer);
winFixClipboardChain();
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Nested calls detected. Re-initing.\n");
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
s_fProcessingDrawClipboard = FALSE;
return 0;
}
/* Bail on first message */
if (!s_fCBCInitialized) {
s_fCBCInitialized = TRUE;
s_fProcessingDrawClipboard = FALSE;
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
return 0;
}
/*
* NOTE: We cannot bail out when NULL == GetClipboardOwner ()
* because some applications deal with the clipboard in a manner
* that causes the clipboard owner to be NULL when they are in
* fact taking ownership. One example of this is the Win32
* native compile of emacs.
*/
/* Bail when we still own the clipboard */
if (hwnd == GetClipboardOwner()) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"We own the clipboard, returning.\n");
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
s_fProcessingDrawClipboard = FALSE;
if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
return 0;
}
/*
* Do not take ownership of the X11 selections when something
* other than CF_TEXT or CF_UNICODETEXT has been copied
* into the Win32 clipboard.
*/
if (!IsClipboardFormatAvailable(CF_TEXT)
&& !IsClipboardFormatAvailable(CF_UNICODETEXT)) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Clipboard does not contain CF_TEXT nor "
"CF_UNICODETEXT.\n");
/*
* We need to make sure that the X Server has processed
* previous XSetSelectionOwner messages.
*/
XSync(pDisplay, FALSE);
winDebug("winClipboardWindowProc - XSync done.\n");
/* Release PRIMARY selection if owned */
iReturn = XGetSelectionOwner(pDisplay, XA_PRIMARY);
if (iReturn == g_iClipboardWindow) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"PRIMARY selection is owned by us.\n");
XSetSelectionOwner(pDisplay, XA_PRIMARY, None, CurrentTime);
}
else if (BadWindow == iReturn || BadAtom == iReturn)
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"XGetSelection failed for PRIMARY: %d\n",
iReturn);
/* Release CLIPBOARD selection if owned */
iReturn = XGetSelectionOwner(pDisplay, atomClipboard);
if (iReturn == g_iClipboardWindow) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"CLIPBOARD selection is owned by us.\n");
XSetSelectionOwner(pDisplay, atomClipboard, None, CurrentTime);
}
else if (BadWindow == iReturn || BadAtom == iReturn)
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"XGetSelection failed for CLIPBOARD: %d\n",
iReturn);
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
s_fProcessingDrawClipboard = FALSE;
if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
return 0;
}
/* Reassert ownership of PRIMARY */
iReturn = XSetSelectionOwner(pDisplay,
XA_PRIMARY, iWindow, CurrentTime);
if (iReturn == BadAtom || iReturn == BadWindow ||
XGetSelectionOwner(pDisplay, XA_PRIMARY) != iWindow) {
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Could not reassert ownership of PRIMARY\n");
}
else {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Reasserted ownership of PRIMARY\n");
}
/* Reassert ownership of the CLIPBOARD */
iReturn = XSetSelectionOwner(pDisplay,
atomClipboard, iWindow, CurrentTime);
if (iReturn == BadAtom || iReturn == BadWindow ||
XGetSelectionOwner(pDisplay, atomClipboard) != iWindow) {
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Could not reassert ownership of CLIPBOARD\n");
}
else {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Reasserted ownership of CLIPBOARD\n");
}
/* Flush the pending SetSelectionOwner event now */
XFlush(pDisplay);
s_fProcessingDrawClipboard = FALSE;
}
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
/* Pass the message on the next window in the clipboard viewer chain */
if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
return 0;
case WM_DESTROYCLIPBOARD:
/*
* NOTE: Intentionally do nothing.
* Changes in the Win32 clipboard are handled by WM_DRAWCLIPBOARD
* above. We only process this message to conform to the specs
* for delayed clipboard rendering in Win32. You might think
* that we need to release ownership of the X11 selections, but
* we do not, because a WM_DRAWCLIPBOARD message will closely
* follow this message and reassert ownership of the X11
* selections, handling the issue for us.
*/
winDebug("winClipboardWindowProc - WM_DESTROYCLIPBOARD - Ignored.\n");
return 0;
case WM_RENDERFORMAT:
case WM_RENDERALLFORMATS:
{
int iReturn;
Display *pDisplay = g_pClipboardDisplay;
Window iWindow = g_iClipboardWindow;
Bool fConvertToUnicode;
winDebug("winClipboardWindowProc - WM_RENDER*FORMAT - Hello.\n");
/* Flag whether to convert to Unicode or not */
if (message == WM_RENDERALLFORMATS)
fConvertToUnicode = FALSE;
else
fConvertToUnicode = g_fUnicodeSupport && (CF_UNICODETEXT == wParam);
/* Request the selection contents */
iReturn = XConvertSelection(pDisplay,
g_atomLastOwnedSelection,
XInternAtom(pDisplay,
"COMPOUND_TEXT", False),
XInternAtom(pDisplay,
"CYGX_CUT_BUFFER", False),
iWindow, CurrentTime);
if (iReturn == BadAtom || iReturn == BadWindow) {
winErrorFVerb(1, "winClipboardWindowProc - WM_RENDER*FORMAT - "
"XConvertSelection () failed\n");
break;
}
/* Special handling for WM_RENDERALLFORMATS */
if (message == WM_RENDERALLFORMATS) {
/* We must open and empty the clipboard */
/* Close clipboard if we have it open already */
if (GetOpenClipboardWindow() == hwnd) {
CloseClipboard();
}
if (!OpenClipboard(hwnd)) {
winErrorFVerb(1, "winClipboardWindowProc - WM_RENDER*FORMATS - "
"OpenClipboard () failed: %08x\n",
GetLastError());
break;
}
if (!EmptyClipboard()) {
winErrorFVerb(1, "winClipboardWindowProc - WM_RENDER*FORMATS - "
"EmptyClipboard () failed: %08x\n",
GetLastError());
break;
}
}
/* Process the SelectionNotify event */
iReturn = winProcessXEventsTimeout(hwnd,
iWindow,
pDisplay,
fConvertToUnicode, WIN_POLL_TIMEOUT);
/*
* The last call to winProcessXEventsTimeout
* from above had better have seen a notify event, or else we
* are dealing with a buggy or old X11 app. In these cases we
* have to paste some fake data to the Win32 clipboard to
* satisfy the requirement that we write something to it.
*/
if (WIN_XEVENTS_NOTIFY != iReturn) {
/* Paste no data, to satisfy required call to SetClipboardData */
if (g_fUnicodeSupport)
SetClipboardData(CF_UNICODETEXT, NULL);
SetClipboardData(CF_TEXT, NULL);
ErrorF
("winClipboardWindowProc - timed out waiting for WIN_XEVENTS_NOTIFY\n");
}
/* Special handling for WM_RENDERALLFORMATS */
if (message == WM_RENDERALLFORMATS) {
/* We must close the clipboard */
if (!CloseClipboard()) {
winErrorFVerb(1,
"winClipboardWindowProc - WM_RENDERALLFORMATS - "
"CloseClipboard () failed: %08x\n",
GetLastError());
break;
}
}
winDebug("winClipboardWindowProc - WM_RENDER*FORMAT - Returning.\n");
return 0;
}
}
/* Let Windows perform default processing for unhandled messages */
return DefWindowProc(hwnd, message, wParam, lParam);
}
Bool
winScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
{
winScreenInfoPtr pScreenInfo = &g_ScreenInfo[index];
winPrivScreenPtr pScreenPriv;
HDC hdc;
DWORD dwInitialBPP;
#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;
}
/* Horribly misnamed function: Allow engine to adjust BPP for screen */
dwInitialBPP = pScreenInfo->dwBPP;
if (!(*pScreenPriv->pwinAdjustVideoMode) (pScreen)) {
ErrorF("winScreenInit - winAdjustVideoMode () failed\n");
return FALSE;
}
if (dwInitialBPP == WIN_DEFAULT_BPP) {
/* No -depth parameter was passed, let the user know the depth being used */
ErrorF
("winScreenInit - Using Windows display depth of %d bits per pixel\n",
(int) pScreenInfo->dwBPP);
}
else if (dwInitialBPP != pScreenInfo->dwBPP) {
/* Warn user if engine forced a depth different to -depth parameter */
ErrorF
("winScreenInit - Command line depth of %d bpp overidden by engine, using %d bpp\n",
(int) dwInitialBPP, (int) pScreenInfo->dwBPP);
}
else {
ErrorF("winScreenInit - Using command line depth of %d bpp\n",
(int) pScreenInfo->dwBPP);
}
/* 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");
if (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI) {
ErrorF
("winScreenInit - Performance may suffer off primary display.\n");
}
else {
ErrorF("winScreenInit - 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);
/* Are we using multiple monitors? */
if (pScreenInfo->fMultipleMonitors) {
/*
* In this case, some of the defaults set in
* winInitializeScreenDefaults() are not correct ...
*/
if (!pScreenInfo->fUserGaveHeightAndWidth) {
pScreenInfo->dwWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
pScreenInfo->dwHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
}
}
/* Release the device context */
ReleaseDC(pScreenPriv->hwndScreen, hdc);
/* Clear the visuals list */
miClearVisualTypes();
/* Call the engine dependent screen initialization procedure */
if (!((*pScreenPriv->pwinFinishScreenInit) (index, pScreen, argc, argv))) {
ErrorF("winScreenInit - winFinishScreenInit () failed\n");
/* call the engine dependent screen close procedure to clean up from a failure */
pScreenPriv->pwinCloseScreen(index, pScreen);
return FALSE;
}
if (!g_fSoftwareCursor)
winInitCursor(pScreen);
else
winErrorFVerb(2, "winScreenInit - Using software cursor\n");
/*
Note the screen origin in a normalized coordinate space where (0,0) is at the top left
of the native virtual desktop area
*/
pScreen->x = pScreenInfo->dwInitialX - GetSystemMetrics(SM_XVIRTUALSCREEN);
pScreen->y = pScreenInfo->dwInitialY - GetSystemMetrics(SM_YVIRTUALSCREEN);
ErrorF("Screen %d added at virtual desktop coordinate (%d,%d).\n",
index, pScreen->x, pScreen->y);
#if CYGDEBUG || YES
winDebug("winScreenInit - returning\n");
#endif
return TRUE;
}
Bool
winValidateArgs (void)
{
int i;
int iMaxConsecutiveScreen = 0;
BOOL fHasNormalScreen0 = FALSE;
/*
* Check for a malformed set of -screen parameters.
* Examples of malformed parameters:
* XWin -screen 1
* XWin -screen 0 -screen 2
* XWin -screen 1 -screen 2
*/
for (i = 0; i < MAXSCREENS; i++)
{
if (g_ScreenInfo[i].fExplicitScreen)
iMaxConsecutiveScreen = i + 1;
}
winErrorFVerb (2, "winValidateArgs - g_iNumScreens: %d "
"iMaxConsecutiveScreen: %d\n",
g_iNumScreens, iMaxConsecutiveScreen);
if (g_iNumScreens < iMaxConsecutiveScreen)
{
ErrorF ("winValidateArgs - Malformed set of screen parameter(s). "
"Screens must be specified consecutively starting with "
"screen 0. That is, you cannot have only a screen 1, nor "
"could you have screen 0 and screen 2. You instead must "
"have screen 0, or screen 0 and screen 1, respectively. Of "
"you can specify as many screens as you want from 0 up to "
"%d.\n", MAXSCREENS - 1);
return FALSE;
}
/* Loop through all screens */
for (i = 0; i < g_iNumScreens; ++i)
{
/*
* Check for any combination of
* -multiwindow, -mwextwm, and -rootless.
*/
{
int iCount = 0;
/* Count conflicting options */
#ifdef XWIN_MULTIWINDOW
if (g_ScreenInfo[i].fMultiWindow)
++iCount;
#endif
#ifdef XWIN_MULTIWINDOWEXTWM
if (g_ScreenInfo[i].fMWExtWM)
++iCount;
#endif
if (g_ScreenInfo[i].fRootless)
++iCount;
/* Check if the first screen is without rootless and multiwindow */
if (iCount == 0 && i == 0)
fHasNormalScreen0 = TRUE;
/* Fail if two or more conflicting options */
if (iCount > 1)
{
ErrorF ("winValidateArgs - Only one of -multiwindow, -mwextwm, "
"and -rootless can be specific at a time.\n");
return FALSE;
}
}
/* Check for -multiwindow or -mwextwm and Xdmcp */
/* allow xdmcp if screen 0 is normal. */
if (g_fXdmcpEnabled && !fHasNormalScreen0
&& (FALSE
#ifdef XWIN_MULTIWINDOW
|| g_ScreenInfo[i].fMultiWindow
#endif
#ifdef XWIN_MULTIWINDOWEXTWM
|| g_ScreenInfo[i].fMWExtWM
#endif
)
)
{
ErrorF ("winValidateArgs - Xdmcp (-query, -broadcast, or -indirect) "
"is invalid with -multiwindow or -mwextwm.\n");
return FALSE;
}
/* Check for -multiwindow, -mwextwm, or -rootless and fullscreen */
if (g_ScreenInfo[i].fFullScreen
&& (FALSE
#ifdef XWIN_MULTIWINDOW
|| g_ScreenInfo[i].fMultiWindow
#endif
#ifdef XWIN_MULTIWINDOWEXTWM
|| g_ScreenInfo[i].fMWExtWM
#endif
|| g_ScreenInfo[i].fRootless)
)
{
ErrorF ("winValidateArgs - -fullscreen is invalid with "
"-multiwindow, -mwextwm, or -rootless.\n");
return FALSE;
}
/* Check for !fullscreen and any fullscreen-only parameters */
if (!g_ScreenInfo[i].fFullScreen
&& (g_ScreenInfo[i].dwRefreshRate != WIN_DEFAULT_BPP
|| g_ScreenInfo[i].dwBPP != WIN_DEFAULT_REFRESH))
{
ErrorF ("winValidateArgs - -refresh and -depth are only valid "
"with -fullscreen.\n");
return FALSE;
}
/* Check for fullscreen and any non-fullscreen parameters */
if (g_ScreenInfo[i].fFullScreen
&& (g_ScreenInfo[i].fScrollbars
|| !g_ScreenInfo[i].fDecoration
|| g_ScreenInfo[i].fLessPointer))
{
ErrorF ("winValidateArgs - -fullscreen is invalid with "
"-scrollbars, -nodecoration, or -lesspointer.\n");
return FALSE;
}
}
winDebug ("winValidateArgs - Returning.\n");
return TRUE;
}
static Bool
winAdjustVideoModeShadowDDNL (ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
HDC hdc = NULL;
DWORD dwBPP;
/* We're in serious trouble if we can't get a DC */
hdc = GetDC (NULL);
if (hdc == NULL)
{
ErrorF ("winAdjustVideoModeShadowDDNL - GetDC () failed\n");
return FALSE;
}
/* Query GDI for current display depth */
dwBPP = GetDeviceCaps (hdc, BITSPIXEL);
/* DirectDraw can only change the depth in fullscreen mode */
if (pScreenInfo->dwBPP == WIN_DEFAULT_BPP)
{
/* No -depth parameter passed, let the user know the depth being used */
winErrorFVerb (2, "winAdjustVideoModeShadowDDNL - Using Windows display "
"depth of %d bits per pixel\n", (int) dwBPP);
/* Use GDI's depth */
pScreenInfo->dwBPP = dwBPP;
}
else if (pScreenInfo->fFullScreen
&& pScreenInfo->dwBPP != dwBPP)
{
/* FullScreen, and GDI depth differs from -depth parameter */
winErrorFVerb (2, "winAdjustVideoModeShadowDDNL - FullScreen, using command "
"line bpp: %d\n", (int) pScreenInfo->dwBPP);
}
else if (dwBPP != pScreenInfo->dwBPP)
{
/* Windowed, and GDI depth differs from -depth parameter */
winErrorFVerb (2, "winAdjustVideoModeShadowDDNL - Windowed, command line "
"bpp: %d, using bpp: %d\n",
(int) pScreenInfo->dwBPP, (int) dwBPP);
/* We'll use GDI's depth */
pScreenInfo->dwBPP = dwBPP;
}
/* See if the shadow bitmap will be larger than the DIB size limit */
if (pScreenInfo->dwWidth * pScreenInfo->dwHeight * pScreenInfo->dwBPP
>= WIN_DIB_MAXIMUM_SIZE)
{
winErrorFVerb (1, "winAdjustVideoModeShadowDDNL - Requested DirectDraw surface "
"will be larger than %d MB. The surface may fail to be "
"allocated on Windows 95, 98, or Me, due to a %d MB limit in "
"DIB size. This limit does not apply to Windows NT/2000, and "
"this message may be ignored on those platforms.\n",
WIN_DIB_MAXIMUM_SIZE_MB, WIN_DIB_MAXIMUM_SIZE_MB);
}
/* Release our DC */
ReleaseDC (NULL, hdc);
return TRUE;
}
static void
winInitializeScreenDefaults(void)
{
DWORD dwWidth, dwHeight;
static Bool fInitializedScreenDefaults = FALSE;
/* Bail out early if default screen has already been initialized */
if (fInitializedScreenDefaults)
return;
/* Zero the memory used for storing the screen info */
memset(&defaultScreenInfo, 0, sizeof(winScreenInfo));
/* Get default width and height */
/*
* NOTE: These defaults will cause the window to cover only
* the primary monitor in the case that we have multiple monitors.
*/
dwWidth = GetSystemMetrics(SM_CXSCREEN);
dwHeight = GetSystemMetrics(SM_CYSCREEN);
winErrorFVerb(2,
"winInitializeScreenDefaults - primary monitor w %d h %d\n",
(int) dwWidth, (int) dwHeight);
/* Set a default DPI, if no '-dpi' option was used */
if (monitorResolution == 0) {
HDC hdc = GetDC(NULL);
if (hdc) {
int dpiX = GetDeviceCaps(hdc, LOGPIXELSX);
int dpiY = GetDeviceCaps(hdc, LOGPIXELSY);
winErrorFVerb(2,
"winInitializeScreenDefaults - native DPI x %d y %d\n",
dpiX, dpiY);
monitorResolution = dpiY;
ReleaseDC(NULL, hdc);
}
else {
winErrorFVerb(1,
"winInitializeScreenDefaults - Failed to retrieve native DPI, falling back to default of %d DPI\n",
WIN_DEFAULT_DPI);
monitorResolution = WIN_DEFAULT_DPI;
}
}
defaultScreenInfo.iMonitor = 1;
defaultScreenInfo.hMonitor = MonitorFromWindow(NULL, MONITOR_DEFAULTTOPRIMARY);
defaultScreenInfo.dwWidth = dwWidth;
defaultScreenInfo.dwHeight = dwHeight;
defaultScreenInfo.dwUserWidth = dwWidth;
defaultScreenInfo.dwUserHeight = dwHeight;
defaultScreenInfo.fUserGaveHeightAndWidth =
WIN_DEFAULT_USER_GAVE_HEIGHT_AND_WIDTH;
defaultScreenInfo.fUserGavePosition = FALSE;
defaultScreenInfo.dwBPP = WIN_DEFAULT_BPP;
defaultScreenInfo.dwClipUpdatesNBoxes = WIN_DEFAULT_CLIP_UPDATES_NBOXES;
#ifdef XWIN_EMULATEPSEUDO
defaultScreenInfo.fEmulatePseudo = WIN_DEFAULT_EMULATE_PSEUDO;
#endif
defaultScreenInfo.dwRefreshRate = WIN_DEFAULT_REFRESH;
defaultScreenInfo.pfb = NULL;
defaultScreenInfo.fFullScreen = FALSE;
defaultScreenInfo.fDecoration = TRUE;
#ifdef XWIN_MULTIWINDOWEXTWM
defaultScreenInfo.fMWExtWM = FALSE;
defaultScreenInfo.fInternalWM = FALSE;
#endif
defaultScreenInfo.fRootless = FALSE;
#ifdef XWIN_MULTIWINDOW
defaultScreenInfo.fMultiWindow = FALSE;
#endif
#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
defaultScreenInfo.fMultiMonitorOverride = FALSE;
#endif
defaultScreenInfo.fMultipleMonitors = FALSE;
defaultScreenInfo.fLessPointer = FALSE;
defaultScreenInfo.iResizeMode = resizeWithRandr;
defaultScreenInfo.fNoTrayIcon = FALSE;
defaultScreenInfo.iE3BTimeout = WIN_E3B_DEFAULT;
defaultScreenInfo.fUseWinKillKey = WIN_DEFAULT_WIN_KILL;
defaultScreenInfo.fUseUnixKillKey = WIN_DEFAULT_UNIX_KILL;
defaultScreenInfo.fIgnoreInput = FALSE;
defaultScreenInfo.fExplicitScreen = FALSE;
/* Note that the default screen has been initialized */
fInitializedScreenDefaults = TRUE;
}
void
InitOutput(ScreenInfo * pScreenInfo, int argc, char *argv[])
{
int i;
if (serverGeneration == 1)
XwinExtensionInit();
/* Log the command line */
winLogCommandLine(argc, argv);
#if CYGDEBUG
winDebug("InitOutput\n");
#endif
/* Validate command-line arguments */
if (serverGeneration == 1 && !winValidateArgs()) {
FatalError("InitOutput - Invalid command-line arguments found. "
"Exiting.\n");
}
/* Check for duplicate invocation on same display number. */
if (serverGeneration == 1 && !winCheckDisplayNumber()) {
if (g_fSilentDupError)
g_fSilentFatalError = TRUE;
FatalError("InitOutput - Duplicate invocation on display "
"number: %s. Exiting.\n", display);
}
#ifdef XWIN_XF86CONFIG
/* Try to read the xorg.conf-style configuration file */
if (!winReadConfigfile())
winErrorFVerb(1, "InitOutput - Error reading config file\n");
#else
winMsg(X_INFO, "xorg.conf is not supported\n");
winMsg(X_INFO, "See http://x.cygwin.com/docs/faq/cygwin-x-faq.html "
"for more information\n");
winConfigFiles();
#endif
/* Load preferences from XWinrc file */
LoadPreferences();
/* Setup global screen info parameters */
pScreenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
pScreenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
pScreenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
pScreenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
pScreenInfo->numPixmapFormats = NUMFORMATS;
/* Describe how we want common pixmap formats padded */
for (i = 0; i < NUMFORMATS; i++) {
pScreenInfo->formats[i] = g_PixmapFormats[i];
}
/* Load pointers to DirectDraw functions */
winGetDDProcAddresses();
/* Detect supported engines */
winDetectSupportedEngines();
#ifdef XWIN_MULTIWINDOW
/* Load libraries for taskbar grouping */
winPropertyStoreInit();
#endif
/* Store the instance handle */
g_hInstance = GetModuleHandle(NULL);
/* Create the messaging window */
if (serverGeneration == 1)
winCreateMsgWindowThread();
/* Initialize each screen */
for (i = 0; i < g_iNumScreens; ++i) {
/* Initialize the screen */
if (-1 == AddScreen(winScreenInit, argc, argv)) {
FatalError("InitOutput - Couldn't add screen %d", i);
}
}
/*
Unless full xinerama has been explicitly enabled, register all native screens with pseudoramiX
*/
if (!noPanoramiXExtension)
noPseudoramiXExtension = TRUE;
if ((g_ScreenInfo[0].fMultipleMonitors) && !noPseudoramiXExtension)
{
int pass;
PseudoramiXExtensionInit();
/* Add primary monitor on pass 0, other monitors on pass 1, to ensure
the primary monitor is first in XINERAMA list */
for (pass = 0; pass < 2; pass++)
{
int iMonitor;
for (iMonitor = 1; ; iMonitor++)
{
struct GetMonitorInfoData data;
QueryMonitor(iMonitor, &data);
if (data.bMonitorSpecifiedExists)
{
MONITORINFO mi;
mi.cbSize = sizeof(MONITORINFO);
if (GetMonitorInfo(data.monitorHandle, &mi))
{
/* pass == 1 XOR primary monitor flags is set */
if ((!(pass == 1)) != (!(mi.dwFlags & MONITORINFOF_PRIMARY)))
{
/*
Note the screen origin in a normalized coordinate space where (0,0) is at the top left
of the native virtual desktop area
*/
data.monitorOffsetX = data.monitorOffsetX - GetSystemMetrics(SM_XVIRTUALSCREEN);
data.monitorOffsetY = data.monitorOffsetY - GetSystemMetrics(SM_YVIRTUALSCREEN);
winDebug ("InitOutput - screen %d added at virtual desktop coordinate (%d,%d) (pseudoramiX) \n",
iMonitor-1, data.monitorOffsetX, data.monitorOffsetY);
PseudoramiXAddScreen(data.monitorOffsetX, data.monitorOffsetY,
data.monitorWidth, data.monitorHeight);
}
}
}
else
break;
}
}
}
#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
/* Generate a cookie used by internal clients for authorization */
if (g_fXdmcpEnabled || g_fAuthEnabled)
winGenerateAuthorization();
/* Perform some one time initialization */
if (1 == serverGeneration) {
/*
* setlocale applies to all threads in the current process.
* Apply locale specified in LANG environment variable.
*/
setlocale(LC_ALL, "");
}
#endif
#if CYGDEBUG || YES
winDebug("InitOutput - Returning.\n");
#endif
}
Bool
winSetEngine(ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
HDC hdc;
DWORD dwBPP;
/* Get a DC */
hdc = GetDC(NULL);
if (hdc == NULL) {
ErrorF("winSetEngine - Couldn't get an HDC\n");
return FALSE;
}
/*
* pScreenInfo->dwBPP may be 0 to indicate that the current screen
* depth is to be used. Thus, we must query for the current display
* depth here.
*/
dwBPP = GetDeviceCaps(hdc, BITSPIXEL);
/* Release the DC */
ReleaseDC(NULL, hdc);
hdc = NULL;
/* ShadowGDI is the only engine that supports windowed PseudoColor */
if (dwBPP == 8 && !pScreenInfo->fFullScreen) {
winErrorFVerb(2,
"winSetEngine - Windowed && PseudoColor => ShadowGDI\n");
pScreenInfo->dwEngine = WIN_SERVER_SHADOW_GDI;
/* Set engine function pointers */
winSetEngineFunctionsShadowGDI(pScreen);
return TRUE;
}
/* ShadowGDI is the only engine that supports Multi Window Mode */
if (FALSE
#ifdef XWIN_MULTIWINDOWEXTWM
|| pScreenInfo->fMWExtWM
#endif
#ifdef XWIN_MULTIWINDOW
|| pScreenInfo->fMultiWindow
#endif
) {
winErrorFVerb(2,
"winSetEngine - Multi Window or Rootless => ShadowGDI\n");
pScreenInfo->dwEngine = WIN_SERVER_SHADOW_GDI;
/* Set engine function pointers */
winSetEngineFunctionsShadowGDI(pScreen);
return TRUE;
}
/* If the user's choice is supported, we'll use that */
if (g_dwEnginesSupported & pScreenInfo->dwEnginePreferred) {
winErrorFVerb(2, "winSetEngine - Using user's preference: %d\n",
(int) pScreenInfo->dwEnginePreferred);
pScreenInfo->dwEngine = pScreenInfo->dwEnginePreferred;
/* Setup engine function pointers */
switch (pScreenInfo->dwEngine) {
case WIN_SERVER_SHADOW_GDI:
winSetEngineFunctionsShadowGDI(pScreen);
break;
case WIN_SERVER_SHADOW_DDNL:
winSetEngineFunctionsShadowDDNL(pScreen);
break;
default:
FatalError("winSetEngine - Invalid engine type\n");
}
return TRUE;
}
/* ShadowDDNL has good performance, so why not */
if (g_dwEnginesSupported & WIN_SERVER_SHADOW_DDNL) {
winErrorFVerb(2, "winSetEngine - Using Shadow DirectDraw NonLocking\n");
pScreenInfo->dwEngine = WIN_SERVER_SHADOW_DDNL;
/* Set engine function pointers */
winSetEngineFunctionsShadowDDNL(pScreen);
return TRUE;
}
/* ShadowGDI is next in line */
if (g_dwEnginesSupported & WIN_SERVER_SHADOW_GDI) {
winErrorFVerb(2, "winSetEngine - Using Shadow GDI DIB\n");
pScreenInfo->dwEngine = WIN_SERVER_SHADOW_GDI;
/* Set engine function pointers */
winSetEngineFunctionsShadowGDI(pScreen);
return TRUE;
}
return FALSE;
}
void
winDetectSupportedEngines(void)
{
OSVERSIONINFO osvi;
/* Initialize the engine support flags */
g_dwEnginesSupported = WIN_SERVER_SHADOW_GDI;
#ifdef XWIN_NATIVEGDI
g_dwEnginesSupported |= WIN_SERVER_NATIVE_GDI;
#endif
/* Get operating system version information */
ZeroMemory(&osvi, sizeof(osvi));
osvi.dwOSVersionInfoSize = sizeof(osvi);
GetVersionEx(&osvi);
/* Do we have DirectDraw? */
if (g_hmodDirectDraw != NULL) {
LPDIRECTDRAW lpdd = NULL;
LPDIRECTDRAW4 lpdd4 = NULL;
HRESULT ddrval;
/* Was the DirectDrawCreate function found? */
if (g_fpDirectDrawCreate == NULL) {
/* No DirectDraw support */
return;
}
/* DirectDrawCreate exists, try to call it */
/* Create a DirectDraw object, store the address at lpdd */
ddrval = (*g_fpDirectDrawCreate) (NULL, (void **) &lpdd, NULL);
if (FAILED(ddrval)) {
/* No DirectDraw support */
winErrorFVerb(2,
"winDetectSupportedEngines - DirectDraw not installed\n");
return;
}
else {
/* We have DirectDraw */
winErrorFVerb(2,
"winDetectSupportedEngines - DirectDraw installed\n");
g_dwEnginesSupported |= WIN_SERVER_SHADOW_DD;
#ifdef XWIN_PRIMARYFB
/* Allow PrimaryDD engine if NT */
if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
g_dwEnginesSupported |= WIN_SERVER_PRIMARY_DD;
winErrorFVerb(2,
"winDetectSupportedEngines - Allowing PrimaryDD\n");
}
#endif
}
/* Try to query for DirectDraw4 interface */
ddrval = IDirectDraw_QueryInterface(lpdd,
&IID_IDirectDraw4,
(LPVOID *) & lpdd4);
if (SUCCEEDED(ddrval)) {
/* We have DirectDraw4 */
winErrorFVerb(2,
"winDetectSupportedEngines - DirectDraw4 installed\n");
g_dwEnginesSupported |= WIN_SERVER_SHADOW_DDNL;
}
/* Cleanup DirectDraw interfaces */
if (lpdd4 != NULL)
IDirectDraw_Release(lpdd4);
if (lpdd != NULL)
IDirectDraw_Release(lpdd);
}
winErrorFVerb(2,
"winDetectSupportedEngines - Returning, supported engines %08x\n",
(unsigned int) g_dwEnginesSupported);
}
/*
* Convert X cursor to Windows cursor
* FIXME: Perhaps there are more smart code
*/
static HCURSOR
winLoadCursor (ScreenPtr pScreen, CursorPtr pCursor, int screen)
{
winScreenPriv(pScreen);
HCURSOR hCursor = NULL;
unsigned char *pAnd;
unsigned char *pXor;
int nCX, nCY;
int nBytes;
double dForeY, dBackY;
BOOL fReverse;
HBITMAP hAnd, hXor;
ICONINFO ii;
unsigned char *pCur;
int x, y;
unsigned char bit;
HDC hDC;
BITMAPV4HEADER bi;
BITMAPINFO *pbmi;
unsigned long *lpBits;
WIN_DEBUG_MSG("winLoadCursor: Win32: %dx%d X11: %dx%d hotspot: %d,%d\n",
pScreenPriv->cursor.sm_cx, pScreenPriv->cursor.sm_cy,
pCursor->bits->width, pCursor->bits->height,
pCursor->bits->xhot, pCursor->bits->yhot
);
/* We can use only White and Black, so calc brightness of color
* Also check if the cursor is inverted */
dForeY = BRIGHTNESS(pCursor->fore);
dBackY = BRIGHTNESS(pCursor->back);
fReverse = dForeY < dBackY;
/* Check wether the X11 cursor is bigger than the win32 cursor */
if (pScreenPriv->cursor.sm_cx < pCursor->bits->width ||
pScreenPriv->cursor.sm_cy < pCursor->bits->height)
{
winErrorFVerb (3, "winLoadCursor - Windows requires %dx%d cursor but X requires %dx%d\n",
pScreenPriv->cursor.sm_cx, pScreenPriv->cursor.sm_cy,
pCursor->bits->width, pCursor->bits->height);
}
/* Get the number of bytes required to store the whole cursor image
* This is roughly (sm_cx * sm_cy) / 8
* round up to 8 pixel boundary so we can convert whole bytes */
nBytes = bits_to_bytes(pScreenPriv->cursor.sm_cx) * pScreenPriv->cursor.sm_cy;
/* Get the effective width and height */
nCX = min(pScreenPriv->cursor.sm_cx, pCursor->bits->width);
nCY = min(pScreenPriv->cursor.sm_cy, pCursor->bits->height);
/* Allocate memory for the bitmaps */
pAnd = malloc (nBytes);
memset (pAnd, 0xFF, nBytes);
pXor = calloc (1, nBytes);
/* Convert the X11 bitmap to a win32 bitmap
* The first is for an empty mask */
if (pCursor->bits->emptyMask)
{
int x, y, xmax = bits_to_bytes(nCX);
for (y = 0; y < nCY; ++y)
for (x = 0; x < xmax; ++x)
{
int nWinPix = bits_to_bytes(pScreenPriv->cursor.sm_cx) * y + x;
int nXPix = BitmapBytePad(pCursor->bits->width) * y + x;
pAnd[nWinPix] = 0;
if (fReverse)
pXor[nWinPix] = reverse (~pCursor->bits->source[nXPix]);
else
pXor[nWinPix] = reverse (pCursor->bits->source[nXPix]);
}
}
else
{
int x, y, xmax = bits_to_bytes(nCX);
for (y = 0; y < nCY; ++y)
for (x = 0; x < xmax; ++x)
{
int nWinPix = bits_to_bytes(pScreenPriv->cursor.sm_cx) * y + x;
int nXPix = BitmapBytePad(pCursor->bits->width) * y + x;
unsigned char mask = pCursor->bits->mask[nXPix];
pAnd[nWinPix] = reverse (~mask);
if (fReverse)
pXor[nWinPix] = reverse (~pCursor->bits->source[nXPix] & mask);
else
pXor[nWinPix] = reverse (pCursor->bits->source[nXPix] & mask);
}
}
/* prepare the pointers */
hCursor = NULL;
lpBits = NULL;
/* We have a truecolor alpha-blended cursor and can use it! */
if (pCursor->bits->argb)
{
WIN_DEBUG_MSG("winLoadCursor: Trying truecolor alphablended cursor\n");
memset (&bi, 0, sizeof (BITMAPV4HEADER));
bi.bV4Size = sizeof(BITMAPV4HEADER);
bi.bV4Width = pScreenPriv->cursor.sm_cx;
bi.bV4Height = -(pScreenPriv->cursor.sm_cy); /* right-side up */
bi.bV4Planes = 1;
bi.bV4BitCount = 32;
bi.bV4V4Compression = BI_BITFIELDS;
bi.bV4RedMask = 0x00FF0000;
bi.bV4GreenMask = 0x0000FF00;
bi.bV4BlueMask = 0x000000FF;
bi.bV4AlphaMask = 0xFF000000;
lpBits = (unsigned long *) calloc (pScreenPriv->cursor.sm_cx*pScreenPriv->cursor.sm_cy,
sizeof (unsigned long));
if (lpBits)
{
for (y=0; y<nCY; y++)
{
unsigned long *src, *dst;
src = &(pCursor->bits->argb[y * pCursor->bits->width]);
dst = &(lpBits[y * pScreenPriv->cursor.sm_cx]);
memcpy (dst, src, 4*nCX);
}
}
} /* End if-truecolor-icon */
if (!lpBits)
{
/* Bicolor, use a palettized DIB */
WIN_DEBUG_MSG("winLoadCursor: Trying two color cursor\n");
pbmi = (BITMAPINFO*)&bi;
memset (pbmi, 0, sizeof (BITMAPINFOHEADER));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = pScreenPriv->cursor.sm_cx;
pbmi->bmiHeader.biHeight = -abs(pScreenPriv->cursor.sm_cy); /* right-side up */
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 8;
pbmi->bmiHeader.biCompression = BI_RGB;
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biClrUsed = 3;
pbmi->bmiHeader.biClrImportant = 3;
pbmi->bmiColors[0].rgbRed = 0; /* Empty */
pbmi->bmiColors[0].rgbGreen = 0;
pbmi->bmiColors[0].rgbBlue = 0;
pbmi->bmiColors[0].rgbReserved = 0;
pbmi->bmiColors[1].rgbRed = pCursor->backRed>>8; /* Background */
pbmi->bmiColors[1].rgbGreen = pCursor->backGreen>>8;
pbmi->bmiColors[1].rgbBlue = pCursor->backBlue>>8;
pbmi->bmiColors[1].rgbReserved = 0;
pbmi->bmiColors[2].rgbRed = pCursor->foreRed>>8; /* Foreground */
pbmi->bmiColors[2].rgbGreen = pCursor->foreGreen>>8;
pbmi->bmiColors[2].rgbBlue = pCursor->foreBlue>>8;
pbmi->bmiColors[2].rgbReserved = 0;
lpBits = (unsigned long *) calloc (pScreenPriv->cursor.sm_cx*pScreenPriv->cursor.sm_cy,
sizeof (char));
pCur = (unsigned char *)lpBits;
if (lpBits)
{
for (y=0; y<pScreenPriv->cursor.sm_cy; y++)
{
for (x=0; x<pScreenPriv->cursor.sm_cx; x++)
{
if (x>=nCX || y>=nCY) /* Outside of X11 icon bounds */
(*pCur++) = 0;
else /* Within X11 icon bounds */
{
int nWinPix = bits_to_bytes(pScreenPriv->cursor.sm_cx) * y + (x/8);
bit = pAnd[nWinPix];
bit = bit & (1<<(7-(x&7)));
if (!bit) /* Within the cursor mask? */
{
int nXPix = BitmapBytePad(pCursor->bits->width) * y + (x/8);
bit = ~reverse(~pCursor->bits->source[nXPix] & pCursor->bits->mask[nXPix]);
bit = bit & (1<<(7-(x&7)));
if (bit) /* Draw foreground */
(*pCur++) = 2;
else /* Draw background */
(*pCur++) = 1;
}
else /* Outside the cursor mask */
(*pCur++) = 0;
}
} /* end for (x) */
} /* end for (y) */
} /* end if (lpbits) */
}
int
ddxProcessArgument (int argc, char *argv[], int i)
{
static Bool s_fBeenHere = FALSE;
winScreenInfo *screenInfoPtr = NULL;
/* Initialize once */
if (!s_fBeenHere)
{
#ifdef DDXOSVERRORF
/*
* This initialises our hook into VErrorF () for catching log messages
* that are generated before OsInit () is called.
*/
OsVendorVErrorFProc = OsVendorVErrorF;
#endif
s_fBeenHere = TRUE;
/* Initialize only if option is not -help */
if (!IS_OPTION("-help") && !IS_OPTION("-h") && !IS_OPTION("--help") &&
!IS_OPTION("-version") && !IS_OPTION("--version"))
{
/* Log the version information */
winLogVersionInfo ();
/* Log the command line */
winLogCommandLine (argc, argv);
/*
* Initialize default screen settings. We have to do this before
* OsVendorInit () gets called, otherwise we will overwrite
* settings changed by parameters such as -fullscreen, etc.
*/
winErrorFVerb (2, "ddxProcessArgument - Initializing default "
"screens\n");
winInitializeScreenDefaults();
}
}
#if CYGDEBUG
winDebug ("ddxProcessArgument - arg: %s\n", argv[i]);
#endif
/*
* Look for the '-help' and similar options
*/
if (IS_OPTION ("-help") || IS_OPTION("-h") || IS_OPTION("--help"))
{
/* Reset logfile. We don't need that helpmessage in the logfile */
g_pszLogFile = NULL;
g_fNoHelpMessageBox = TRUE;
UseMsg();
exit (0);
return 1;
}
if (IS_OPTION ("-version") || IS_OPTION("--version"))
{
/* Reset logfile. We don't need that versioninfo in the logfile */
g_pszLogFile = NULL;
winLogVersionInfo ();
exit (0);
return 1;
}
/*
* Look for the '-screen scr_num [width height]' argument
*/
if (IS_OPTION ("-screen"))
{
int iArgsProcessed = 1;
int nScreenNum;
int iWidth, iHeight, iX, iY;
int iMonitor;
#if CYGDEBUG
winDebug ("ddxProcessArgument - screen - argc: %d i: %d\n",
argc, i);
#endif
/* Display the usage message if the argument is malformed */
if (i + 1 >= argc)
{
return 0;
}
/* Grab screen number */
nScreenNum = atoi (argv[i + 1]);
/* Validate the specified screen number */
if (nScreenNum < 0)
{
ErrorF ("ddxProcessArgument - screen - Invalid screen number %d\n",
nScreenNum);
UseMsg ();
return 0;
}
/*
Initialize default values for any new screens
Note that default values can't change after a -screen option is
seen, so it's safe to do this for each screen as it is introduced
*/
winInitializeScreens(nScreenNum+1);
/* look for @m where m is monitor number */
if (i + 2 < argc
&& 1 == sscanf(argv[i + 2], "@%d", (int *) &iMonitor))
{
struct GetMonitorInfoData data;
if (!QueryMonitor(iMonitor, &data))
{
ErrorF ("ddxProcessArgument - screen - "
"Querying monitors is not supported on NT4 and Win95\n");
} else if (data.bMonitorSpecifiedExists == TRUE)
{
winErrorFVerb(2, "ddxProcessArgument - screen - Found Valid ``@Monitor'' = %d arg\n", iMonitor);
iArgsProcessed = 3;
g_ScreenInfo[nScreenNum].fUserGaveHeightAndWidth = FALSE;
g_ScreenInfo[nScreenNum].fUserGavePosition = TRUE;
g_ScreenInfo[nScreenNum].dwWidth = data.monitorWidth;
g_ScreenInfo[nScreenNum].dwHeight = data.monitorHeight;
g_ScreenInfo[nScreenNum].dwUserWidth = data.monitorWidth;
g_ScreenInfo[nScreenNum].dwUserHeight = data.monitorHeight;
g_ScreenInfo[nScreenNum].dwInitialX = data.monitorOffsetX;
g_ScreenInfo[nScreenNum].dwInitialY = data.monitorOffsetY;
}
else
{
/* monitor does not exist, error out */
ErrorF ("ddxProcessArgument - screen - Invalid monitor number %d\n",
iMonitor);
UseMsg ();
exit (0);
return 0;
}
}
/* Look for 'WxD' or 'W D' */
else if (i + 2 < argc
&& 2 == sscanf (argv[i + 2], "%dx%d",
(int *) &iWidth,
(int *) &iHeight))
{
winErrorFVerb (2, "ddxProcessArgument - screen - Found ``WxD'' arg\n");
iArgsProcessed = 3;
g_ScreenInfo[nScreenNum].fUserGaveHeightAndWidth = TRUE;
g_ScreenInfo[nScreenNum].dwWidth = iWidth;
g_ScreenInfo[nScreenNum].dwHeight = iHeight;
g_ScreenInfo[nScreenNum].dwUserWidth = iWidth;
g_ScreenInfo[nScreenNum].dwUserHeight = iHeight;
/* Look for WxD+X+Y */
if (2 == sscanf (argv[i + 2], "%*dx%*d+%d+%d",
(int *) &iX,
(int *) &iY))
{
winErrorFVerb (2, "ddxProcessArgument - screen - Found ``X+Y'' arg\n");
g_ScreenInfo[nScreenNum].fUserGavePosition = TRUE;
g_ScreenInfo[nScreenNum].dwInitialX = iX;
g_ScreenInfo[nScreenNum].dwInitialY = iY;
/* look for WxD+X+Y@m where m is monitor number. take X,Y to be offsets from monitor's root position */
if (1 == sscanf (argv[i + 2], "%*dx%*d+%*d+%*d@%d",
(int *) &iMonitor))
{
struct GetMonitorInfoData data;
if (!QueryMonitor(iMonitor, &data))
{
ErrorF ("ddxProcessArgument - screen - "
"Querying monitors is not supported on NT4 and Win95\n");
} else if (data.bMonitorSpecifiedExists == TRUE)
{
g_ScreenInfo[nScreenNum].dwInitialX += data.monitorOffsetX;
g_ScreenInfo[nScreenNum].dwInitialY += data.monitorOffsetY;
}
else
{
/* monitor does not exist, error out */
ErrorF ("ddxProcessArgument - screen - Invalid monitor number %d\n",
iMonitor);
UseMsg ();
exit (0);
return 0;
}
}
}
/* look for WxD@m where m is monitor number */
else if (1 == sscanf(argv[i + 2], "%*dx%*d@%d",
(int *) &iMonitor))
{
struct GetMonitorInfoData data;
if (!QueryMonitor(iMonitor, &data))
{
ErrorF ("ddxProcessArgument - screen - "
"Querying monitors is not supported on NT4 and Win95\n");
} else if (data.bMonitorSpecifiedExists == TRUE)
{
winErrorFVerb (2, "ddxProcessArgument - screen - Found Valid ``@Monitor'' = %d arg\n", iMonitor);
g_ScreenInfo[nScreenNum].fUserGavePosition = TRUE;
g_ScreenInfo[nScreenNum].dwInitialX = data.monitorOffsetX;
g_ScreenInfo[nScreenNum].dwInitialY = data.monitorOffsetY;
}
else
{
/* monitor does not exist, error out */
ErrorF ("ddxProcessArgument - screen - Invalid monitor number %d\n",
iMonitor);
UseMsg ();
exit (0);
return 0;
}
}
}
else if (i + 3 < argc
&& 1 == sscanf (argv[i + 2], "%d",
(int *) &iWidth)
&& 1 == sscanf (argv[i + 3], "%d",
(int *) &iHeight))
{
winErrorFVerb (2, "ddxProcessArgument - screen - Found ``W D'' arg\n");
iArgsProcessed = 4;
g_ScreenInfo[nScreenNum].fUserGaveHeightAndWidth = TRUE;
g_ScreenInfo[nScreenNum].dwWidth = iWidth;
g_ScreenInfo[nScreenNum].dwHeight = iHeight;
g_ScreenInfo[nScreenNum].dwUserWidth = iWidth;
g_ScreenInfo[nScreenNum].dwUserHeight = iHeight;
if (i + 5 < argc
&& 1 == sscanf (argv[i + 4], "%d",
(int *) &iX)
&& 1 == sscanf (argv[i + 5], "%d",
(int *) &iY))
{
winErrorFVerb (2, "ddxProcessArgument - screen - Found ``X Y'' arg\n");
iArgsProcessed = 6;
g_ScreenInfo[nScreenNum].fUserGavePosition = TRUE;
g_ScreenInfo[nScreenNum].dwInitialX = iX;
g_ScreenInfo[nScreenNum].dwInitialY = iY;
}
}
else
{
winErrorFVerb (2, "ddxProcessArgument - screen - Did not find size arg. "
"dwWidth: %d dwHeight: %d\n",
(int) g_ScreenInfo[nScreenNum].dwWidth,
(int) g_ScreenInfo[nScreenNum].dwHeight);
iArgsProcessed = 2;
g_ScreenInfo[nScreenNum].fUserGaveHeightAndWidth = FALSE;
}
/* Calculate the screen width and height in millimeters */
if (g_ScreenInfo[nScreenNum].fUserGaveHeightAndWidth)
{
g_ScreenInfo[nScreenNum].dwWidth_mm
= (g_ScreenInfo[nScreenNum].dwWidth
/ monitorResolution) * 25.4;
g_ScreenInfo[nScreenNum].dwHeight_mm
= (g_ScreenInfo[nScreenNum].dwHeight
/ monitorResolution) * 25.4;
}
/* Flag that this screen was explicity specified by the user */
g_ScreenInfo[nScreenNum].fExplicitScreen = TRUE;
/*
* Keep track of the last screen number seen, as parameters seen
* before a screen number apply to all screens, whereas parameters
* seen after a screen number apply to that screen number only.
*/
iLastScreen = nScreenNum;
return iArgsProcessed;
}
/*
* Is this parameter attached to a screen or global?
*
* If the parameter is for all screens (appears before
* any -screen option), store it in the default screen
* info
*
* If the parameter is for a single screen (appears
* after a -screen option), store it in the screen info
* for that screen
*
*/
if (iLastScreen == -1)
{
screenInfoPtr = &defaultScreenInfo;
}
else
{
screenInfoPtr = &(g_ScreenInfo[iLastScreen]);
}
/*
* Look for the '-engine n' argument
*/
if (IS_OPTION ("-engine"))
{
DWORD dwEngine = 0;
CARD8 c8OnBits = 0;
/* Display the usage message if the argument is malformed */
if (++i >= argc)
{
UseMsg ();
return 0;
}
/* Grab the argument */
dwEngine = atoi (argv[i]);
/* Count the one bits in the engine argument */
c8OnBits = winCountBits (dwEngine);
/* Argument should only have a single bit on */
if (c8OnBits != 1)
{
UseMsg ();
return 0;
}
screenInfoPtr->dwEnginePreferred = dwEngine;
/* Indicate that we have processed the argument */
return 2;
}
/*
* Look for the '-fullscreen' argument
*/
if (IS_OPTION ("-fullscreen"))
{
#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
if (!screenInfoPtr->fMultiMonitorOverride)
screenInfoPtr->fMultipleMonitors = FALSE;
#endif
screenInfoPtr->fFullScreen = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-lesspointer' argument
*/
if (IS_OPTION ("-lesspointer"))
{
screenInfoPtr->fLessPointer = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-nodecoration' argument
*/
if (IS_OPTION ("-nodecoration"))
{
#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
if (!screenInfoPtr->fMultiMonitorOverride)
screenInfoPtr->fMultipleMonitors = FALSE;
#endif
screenInfoPtr->fDecoration = FALSE;
/* Indicate that we have processed this argument */
return 1;
}
#ifdef XWIN_MULTIWINDOWEXTWM
/*
* Look for the '-mwextwm' argument
*/
if (IS_OPTION ("-mwextwm"))
{
if (!screenInfoPtr->fMultiMonitorOverride)
screenInfoPtr->fMultipleMonitors = TRUE;
screenInfoPtr->fMWExtWM = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-internalwm' argument
*/
if (IS_OPTION ("-internalwm"))
{
if (!screenInfoPtr->fMultiMonitorOverride)
screenInfoPtr->fMultipleMonitors = TRUE;
screenInfoPtr->fMWExtWM = TRUE;
screenInfoPtr->fInternalWM = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
#endif
/*
* Look for the '-rootless' argument
*/
if (IS_OPTION ("-rootless"))
{
#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
if (!screenInfoPtr->fMultiMonitorOverride)
screenInfoPtr->fMultipleMonitors = FALSE;
#endif
screenInfoPtr->fRootless = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
#ifdef XWIN_MULTIWINDOW
/*
* Look for the '-multiwindow' argument
*/
if (IS_OPTION ("-multiwindow"))
{
#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
if (!screenInfoPtr->fMultiMonitorOverride)
screenInfoPtr->fMultipleMonitors = TRUE;
#endif
screenInfoPtr->fMultiWindow = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
#endif
/*
* Look for the '-multiplemonitors' argument
*/
if (IS_OPTION ("-multiplemonitors")
|| IS_OPTION ("-multimonitors"))
{
#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
screenInfoPtr->fMultiMonitorOverride = TRUE;
#endif
screenInfoPtr->fMultipleMonitors = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-nomultiplemonitors' argument
*/
if (IS_OPTION ("-nomultiplemonitors")
|| IS_OPTION ("-nomultimonitors"))
{
#if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM)
screenInfoPtr->fMultiMonitorOverride = TRUE;
#endif
screenInfoPtr->fMultipleMonitors = FALSE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-scrollbars' argument
*/
if (IS_OPTION ("-scrollbars"))
{
screenInfoPtr->fScrollbars = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
#ifdef XWIN_CLIPBOARD
/*
* Look for the '-clipboard' argument
*/
if (IS_OPTION ("-clipboard"))
{
/* Now the default, we still accept the arg for backwards compatibility */
g_fClipboard = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-noclipboard' argument
*/
if (IS_OPTION ("-noclipboard"))
{
g_fClipboard = FALSE;
/* Indicate that we have processed this argument */
return 1;
}
#endif
/*
* Look for the '-ignoreinput' argument
*/
if (IS_OPTION ("-ignoreinput"))
{
screenInfoPtr->fIgnoreInput = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-emulate3buttons' argument
*/
if (IS_OPTION ("-emulate3buttons"))
{
int iArgsProcessed = 1;
int iE3BTimeout = WIN_DEFAULT_E3B_TIME;
/* Grab the optional timeout value */
if (i + 1 < argc
&& 1 == sscanf (argv[i + 1], "%d",
&iE3BTimeout))
{
/* Indicate that we have processed the next argument */
iArgsProcessed++;
}
else
{
/*
* sscanf () won't modify iE3BTimeout if it doesn't find
* the specified format; however, I want to be explicit
* about setting the default timeout in such cases to
* prevent some programs (me) from getting confused.
*/
iE3BTimeout = WIN_DEFAULT_E3B_TIME;
}
screenInfoPtr->iE3BTimeout = iE3BTimeout;
/* Indicate that we have processed this argument */
return iArgsProcessed;
}
/*
* Look for the '-depth n' argument
*/
if (IS_OPTION ("-depth"))
{
DWORD dwBPP = 0;
/* Display the usage message if the argument is malformed */
if (++i >= argc)
{
UseMsg ();
return 0;
}
/* Grab the argument */
dwBPP = atoi (argv[i]);
screenInfoPtr->dwBPP = dwBPP;
/* Indicate that we have processed the argument */
return 2;
}
/*
* Look for the '-refresh n' argument
*/
if (IS_OPTION ("-refresh"))
{
DWORD dwRefreshRate = 0;
/* Display the usage message if the argument is malformed */
if (++i >= argc)
{
UseMsg ();
return 0;
}
/* Grab the argument */
dwRefreshRate = atoi (argv[i]);
screenInfoPtr->dwRefreshRate = dwRefreshRate;
/* Indicate that we have processed the argument */
return 2;
}
/*
* Look for the '-clipupdates num_boxes' argument
*/
if (IS_OPTION ("-clipupdates"))
{
DWORD dwNumBoxes = 0;
/* Display the usage message if the argument is malformed */
if (++i >= argc)
{
UseMsg ();
return 0;
}
/* Grab the argument */
dwNumBoxes = atoi (argv[i]);
screenInfoPtr->dwClipUpdatesNBoxes = dwNumBoxes;
/* Indicate that we have processed the argument */
return 2;
}
#ifdef XWIN_EMULATEPSEUDO
/*
* Look for the '-emulatepseudo' argument
*/
if (IS_OPTION ("-emulatepseudo"))
{
screenInfoPtr->fEmulatePseudo = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
#endif
/*
* Look for the '-nowinkill' argument
*/
if (IS_OPTION ("-nowinkill"))
{
screenInfoPtr->fUseWinKillKey = FALSE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-winkill' argument
*/
if (IS_OPTION ("-winkill"))
{
screenInfoPtr->fUseWinKillKey = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-nounixkill' argument
*/
if (IS_OPTION ("-nounixkill"))
{
screenInfoPtr->fUseUnixKillKey = FALSE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-unixkill' argument
*/
if (IS_OPTION ("-unixkill"))
{
screenInfoPtr->fUseUnixKillKey = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-notrayicon' argument
*/
if (IS_OPTION ("-notrayicon"))
{
screenInfoPtr->fNoTrayIcon = TRUE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-trayicon' argument
*/
if (IS_OPTION ("-trayicon"))
{
screenInfoPtr->fNoTrayIcon = FALSE;
/* Indicate that we have processed this argument */
return 1;
}
/*
* Look for the '-fp' argument
*/
if (IS_OPTION ("-fp"))
{
CHECK_ARGS (1);
g_cmdline.fontPath = argv[++i];
return 0; /* Let DIX parse this again */
}
/*
* Look for the '-query' argument
*/
if (IS_OPTION ("-query"))
{
CHECK_ARGS (1);
g_fXdmcpEnabled = TRUE;
g_pszQueryHost = argv[++i];
return 0; /* Let DIX parse this again */
}
/*
* Look for the '-auth' argument
*/
if (IS_OPTION ("-auth"))
{
g_fAuthEnabled = TRUE;
return 0; /* Let DIX parse this again */
}
/*
* Look for the '-indirect' or '-broadcast' arguments
*/
if (IS_OPTION ("-indirect")
|| IS_OPTION ("-broadcast"))
{
g_fXdmcpEnabled = TRUE;
return 0; /* Let DIX parse this again */
}
/*
* Look for the '-config' argument
*/
if (IS_OPTION ("-config")
|| IS_OPTION ("-xf86config"))
{
CHECK_ARGS (1);
#ifdef XWIN_XF86CONFIG
g_cmdline.configFile = argv[++i];
#else
winMessageBoxF ("The %s option is not supported in this "
"release.\n"
"Ignoring this option and continuing.\n",
MB_ICONINFORMATION,
argv[i]);
#endif
return 2;
}
/*
* Look for the '-configdir' argument
*/
if (IS_OPTION ("-configdir"))
{
CHECK_ARGS (1);
#ifdef XWIN_XF86CONFIG
g_cmdline.configDir = argv[++i];
#else
winMessageBoxF ("The %s option is not supported in this "
"release.\n"
"Ignoring this option and continuing.\n",
MB_ICONINFORMATION,
argv[i]);
#endif
return 2;
}
/*
* Look for the '-keyboard' argument
*/
if (IS_OPTION ("-keyboard"))
{
#ifdef XWIN_XF86CONFIG
CHECK_ARGS (1);
g_cmdline.keyboard = argv[++i];
#else
winMessageBoxF ("The -keyboard option is not supported in this "
"release.\n"
"Ignoring this option and continuing.\n",
MB_ICONINFORMATION);
#endif
return 2;
}
/*
* Look for the '-logfile' argument
*/
if (IS_OPTION ("-logfile"))
{
CHECK_ARGS (1);
g_pszLogFile = argv[++i];
#ifdef RELOCATE_PROJECTROOT
g_fLogFileChanged = TRUE;
#endif
return 2;
}
/*
* Look for the '-logverbose' argument
*/
if (IS_OPTION ("-logverbose"))
{
CHECK_ARGS (1);
g_iLogVerbose = atoi(argv[++i]);
return 2;
}
#ifdef XWIN_CLIPBOARD
/*
* Look for the '-nounicodeclipboard' argument
*/
if (IS_OPTION ("-nounicodeclipboard"))
{
g_fUnicodeClipboard = FALSE;
/* Indicate that we have processed the argument */
return 1;
}
#endif
if (IS_OPTION ("-xkbrules"))
{
CHECK_ARGS (1);
g_cmdline.xkbRules = argv[++i];
return 2;
}
if (IS_OPTION ("-xkbmodel"))
{
CHECK_ARGS (1);
g_cmdline.xkbModel = argv[++i];
return 2;
}
if (IS_OPTION ("-xkblayout"))
{
CHECK_ARGS (1);
g_cmdline.xkbLayout = argv[++i];
return 2;
}
if (IS_OPTION ("-xkbvariant"))
{
CHECK_ARGS (1);
g_cmdline.xkbVariant = argv[++i];
return 2;
}
if (IS_OPTION ("-xkboptions"))
{
CHECK_ARGS (1);
g_cmdline.xkbOptions = argv[++i];
return 2;
}
if (IS_OPTION ("-keyhook"))
{
g_fKeyboardHookLL = TRUE;
return 1;
}
if (IS_OPTION ("-nokeyhook"))
{
g_fKeyboardHookLL = FALSE;
return 1;
}
if (IS_OPTION ("-swcursor"))
{
g_fSoftwareCursor = TRUE;
return 1;
}
if (IS_OPTION ("-silent-dup-error"))
{
g_fSilentDupError = TRUE;
return 1;
}
if (IS_OPTION("-wgl"))
{
g_fNativeGl = TRUE;
return 1;
}
if (IS_OPTION("-nowgl"))
{
g_fNativeGl = FALSE;
return 1;
}
return 0;
}
int
winKeybdProc (DeviceIntPtr pDeviceInt, int iState)
{
KeySymsRec keySyms;
CARD8 modMap[MAP_LENGTH];
DevicePtr pDevice = (DevicePtr) pDeviceInt;
#ifdef XKB
XkbComponentNamesRec names;
XkbSrvInfoPtr xkbi;
XkbControlsPtr ctrl;
#endif
switch (iState)
{
case DEVICE_INIT:
winConfigKeyboard (pDeviceInt);
winGetKeyMappings (&keySyms, modMap);
#ifdef XKB
/* FIXME: Maybe we should use winGetKbdLeds () here? */
defaultKeyboardControl.leds = g_winInfo.keyboard.leds;
#else
defaultKeyboardControl.leds = g_winInfo.keyboard.leds;
#endif
#ifdef XKB
if (g_winInfo.xkb.disable)
{
#endif
InitKeyboardDeviceStruct (pDevice,
&keySyms,
modMap,
winKeybdBell,
winKeybdCtrl);
#ifdef XKB
}
else
{
if (XkbInitialMap)
{
names.keymap = XkbInitialMap;
names.keycodes = NULL;
names.types = NULL;
names.compat = NULL;
names.symbols = NULL;
names.geometry = NULL;
}
else
{
names.keymap = g_winInfo.xkb.keymap;
names.keycodes = g_winInfo.xkb.keycodes;
names.types = g_winInfo.xkb.types;
names.compat = g_winInfo.xkb.compat;
names.symbols = g_winInfo.xkb.symbols;
names.geometry = g_winInfo.xkb.geometry;
}
winErrorFVerb(2, "Rules = \"%s\" Model = \"%s\" Layout = \"%s\""
" Variant = \"%s\" Options = \"%s\"\n",
g_winInfo.xkb.rules, g_winInfo.xkb.model,
g_winInfo.xkb.layout, g_winInfo.xkb.variant,
g_winInfo.xkb.options);
XkbSetRulesDflts (g_winInfo.xkb.rules, g_winInfo.xkb.model,
g_winInfo.xkb.layout, g_winInfo.xkb.variant,
g_winInfo.xkb.options);
XkbInitKeyboardDeviceStruct (pDeviceInt, &names, &keySyms,
modMap, winKeybdBell, winKeybdCtrl);
}
#endif
#ifdef XKB
if (!g_winInfo.xkb.disable)
{
xkbi = pDeviceInt->key->xkbInfo;
if (xkbi != NULL)
{
ctrl = xkbi->desc->ctrls;
ctrl->repeat_delay = g_winInfo.keyboard.delay;
ctrl->repeat_interval = 1000/g_winInfo.keyboard.rate;
}
else
{
winErrorFVerb (1, "winKeybdProc - Error initializing keyboard AutoRepeat (No XKB)\n");
}
}
#endif
g_winInternalModeKeyStatesPtr = &(pDeviceInt->key->state);
break;
case DEVICE_ON:
pDevice->on = TRUE;
g_winInternalModeKeyStatesPtr = &(pDeviceInt->key->state);
break;
case DEVICE_CLOSE:
case DEVICE_OFF:
pDevice->on = FALSE;
g_winInternalModeKeyStatesPtr = NULL;
break;
}
return Success;
}
