/* *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: Harold L Hunt II */ #ifdef HAVE_XWIN_CONFIG_H #include <xwin-config.h> #endif #include "win.h" /* * Local function prototypes */ static Bool winAllocateFBNativeGDI(ScreenPtr pScreen); static void winShadowUpdateNativeGDI(ScreenPtr pScreen, shadowBufPtr pBuf); static Bool winCloseScreenNativeGDI(ScreenPtr pScreen); static Bool winInitVisualsNativeGDI(ScreenPtr pScreen); static Bool winAdjustVideoModeNativeGDI(ScreenPtr pScreen); #if 0 static Bool winBltExposedRegionsNativeGDI(ScreenPtr pScreen); #endif static Bool winActivateAppNativeGDI(ScreenPtr pScreen); static Bool winRedrawScreenNativeGDI(ScreenPtr pScreen); static Bool winRealizeInstalledPaletteNativeGDI(ScreenPtr pScreen); static Bool winInstallColormapNativeGDI(ColormapPtr pColormap); static Bool winStoreColorsNativeGDI(ColormapPtr pmap, int ndef, xColorItem * pdefs); static Bool winCreateColormapNativeGDI(ColormapPtr pColormap); static Bool winDestroyColormapNativeGDI(ColormapPtr pColormap); static Bool winAllocateFBNativeGDI(ScreenPtr pScreen) { FatalError("winAllocateFBNativeGDI\n"); return TRUE; } static void winFreeFBNativeGDI(ScreenPtr pScreen) { FatalError("winFreeFBNativeGDI\n"); } static Bool winInitScreenNativeGDI(ScreenPtr pScreen) { FatalError("winInitScreenNativeGDI\n"); } /* * We wrap whatever CloseScreen procedure was specified by fb; * a pointer to said procedure is stored in our privates. */ static Bool winCloseScreenNativeGDI(ScreenPtr pScreen) { winScreenPriv(pScreen); winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo; ErrorF("winCloseScreenNativeGDI - Freeing screen resources\n"); /* Flag that the screen is closed */ pScreenPriv->fClosed = TRUE; pScreenPriv->fActive = FALSE; /* * NOTE: mi doesn't use a CloseScreen procedure, so we do not * need to call a wrapped procedure here. */ /* Delete the window property */ RemoveProp(pScreenPriv->hwndScreen, WIN_SCR_PROP); ErrorF("winCloseScreenNativeGDI - Destroying window\n"); /* Delete tray icon, if we have one */ if (!pScreenInfo->fNoTrayIcon) winDeleteNotifyIcon(pScreenPriv); /* Free the exit confirmation dialog box, if it exists */ if (g_hDlgExit != NULL) { DestroyWindow(g_hDlgExit); g_hDlgExit = NULL; } /* Kill our window */ if (pScreenPriv->hwndScreen) { DestroyWindow(pScreenPriv->hwndScreen); pScreenPriv->hwndScreen = NULL; } /* Invalidate our screeninfo's pointer to the screen */ pScreenInfo->pScreen = NULL; /* Free the screen privates for this screen */ free(pScreenPriv); ErrorF("winCloseScreenNativeGDI - Returning\n"); return TRUE; } static void winShadowUpdateNativeGDI(ScreenPtr pScreen, shadowBufPtr pBuf) { FatalError("winShadowUpdateNativeGDI\n"); return; } static Bool winInitVisualsNativeGDI(ScreenPtr pScreen) { winScreenPriv(pScreen); winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo; /* Set the bitsPerRGB and bit masks */ switch (pScreenInfo->dwDepth) { case 24: pScreenPriv->dwBitsPerRGB = 8; pScreenPriv->dwRedMask = 0x00FF0000; pScreenPriv->dwGreenMask = 0x0000FF00; pScreenPriv->dwBlueMask = 0x000000FF; break; case 16: pScreenPriv->dwBitsPerRGB = 6; pScreenPriv->dwRedMask = 0xF800; pScreenPriv->dwGreenMask = 0x07E0; pScreenPriv->dwBlueMask = 0x001F; break; case 15: pScreenPriv->dwBitsPerRGB = 5; pScreenPriv->dwRedMask = 0x7C00; pScreenPriv->dwGreenMask = 0x03E0; pScreenPriv->dwBlueMask = 0x001F; break; case 8: pScreenPriv->dwBitsPerRGB = 8; pScreenPriv->dwRedMask = 0; pScreenPriv->dwGreenMask = 0; pScreenPriv->dwBlueMask = 0; break; default: ErrorF("winInitVisualsNativeGDI - Unknown screen depth\n"); return FALSE; break; } /* Tell the user how many bits per RGB we are using */ ErrorF("winInitVisualsNativeGDI - Using dwBitsPerRGB: %d\n", (int) pScreenPriv->dwBitsPerRGB); /* Create a single visual according to the Windows screen depth */ switch (pScreenInfo->dwDepth) { case 24: case 16: case 15: if (!miSetVisualTypesAndMasks(pScreenInfo->dwDepth, TrueColorMask, pScreenPriv->dwBitsPerRGB, TrueColor, pScreenPriv->dwRedMask, pScreenPriv->dwGreenMask, pScreenPriv->dwBlueMask)) { ErrorF("winInitVisuals - miSetVisualTypesAndMasks failed\n"); return FALSE; } break; case 8: ErrorF("winInitVisuals - Calling miSetVisualTypesAndMasks\n"); if (!miSetVisualTypesAndMasks(pScreenInfo->dwDepth, StaticColorMask, pScreenPriv->dwBitsPerRGB, StaticColor, pScreenPriv->dwRedMask, pScreenPriv->dwGreenMask, pScreenPriv->dwBlueMask)) { ErrorF("winInitVisuals - miSetVisualTypesAndMasks failed\n"); return FALSE; } break; default: ErrorF("winInitVisualsNativeGDI - Unknown screen depth\n"); return FALSE; } #if 1 ErrorF("winInitVisualsNativeGDI - Returning\n"); #endif return TRUE; } /* Adjust the video mode */ static Bool winAdjustVideoModeNativeGDI(ScreenPtr pScreen) { winScreenPriv(pScreen); winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo; HDC hdc = NULL; DWORD dwBPP; hdc = GetDC(NULL); /* We're in serious trouble if we can't get a DC */ if (hdc == NULL) { ErrorF("winAdjustVideoModeNativeGDI - GetDC () failed\n"); return FALSE; } /* Query GDI for current display depth */ dwBPP = GetDeviceCaps(hdc, BITSPIXEL); pScreenInfo->dwDepth = GetDeviceCaps(hdc, PLANES); switch (pScreenInfo->dwDepth) { case 24: case 16: case 15: case 8: break; default: if (dwBPP == 32) pScreenInfo->dwDepth = 24; else pScreenInfo->dwDepth = dwBPP; break; } /* GDI cannot change the screen depth, so we'll use GDI's depth */ pScreenInfo->dwBPP = dwBPP; /* Release our DC */ ReleaseDC(NULL, hdc); return TRUE; } static Bool winActivateAppNativeGDI(ScreenPtr pScreen) { winScreenPriv(pScreen); /* * Are we active? * Are we fullscreen? */ if (pScreenPriv != NULL && pScreenPriv->fActive && pScreenPriv->pScreenInfo && pScreenPriv->pScreenInfo->fFullScreen) { /* * Activating, attempt to bring our window * to the top of the display */ ShowWindow(pScreenPriv->hwndScreen, SW_RESTORE); } /* * Are we inactive? * Are we fullscreen? */ if (pScreenPriv != NULL && !pScreenPriv->fActive && pScreenPriv->pScreenInfo && pScreenPriv->pScreenInfo->fFullScreen) { /* * Deactivating, stuff our window onto the * task bar. */ ShowWindow(pScreenPriv->hwndScreen, SW_MINIMIZE); } return TRUE; } HBITMAP winCreateDIBNativeGDI(int iWidth, int iHeight, int iDepth, BYTE ** ppbBits, BITMAPINFO ** ppbmi) { BITMAPINFOHEADER *pbmih = NULL; HBITMAP hBitmap = NULL; BITMAPINFO *pbmi = NULL; /* Don't create an invalid bitmap */ if (iWidth == 0 || iHeight == 0 || iDepth == 0) { ErrorF("\nwinCreateDIBNativeGDI - Invalid specs w %d h %d d %d\n\n", iWidth, iHeight, iDepth); return NULL; } /* Allocate bitmap info header */ pbmih = (BITMAPINFOHEADER *) malloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)); if (pbmih == NULL) { ErrorF("winCreateDIBNativeGDI - malloc () failed\n"); return FALSE; } ZeroMemory(pbmih, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)); /* Describe bitmap to be created */ pbmih->biSize = sizeof(BITMAPINFOHEADER); pbmih->biWidth = iWidth; pbmih->biHeight = -iHeight; pbmih->biPlanes = 1; pbmih->biBitCount = iDepth; pbmih->biCompression = BI_RGB; pbmih->biSizeImage = 0; pbmih->biXPelsPerMeter = 0; pbmih->biYPelsPerMeter = 0; pbmih->biClrUsed = 0; pbmih->biClrImportant = 0; /* Setup color table for mono DIBs */ if (iDepth == 1) { pbmi = (BITMAPINFO *) pbmih; pbmi->bmiColors[1].rgbBlue = 255; pbmi->bmiColors[1].rgbGreen = 255; pbmi->bmiColors[1].rgbRed = 255; } /* Create a DIB with a bit pointer */ hBitmap = CreateDIBSection(NULL, (BITMAPINFO *) pbmih, DIB_RGB_COLORS, (void **) ppbBits, NULL, 0); if (hBitmap == NULL) { ErrorF("winCreateDIBNativeGDI - CreateDIBSection () failed\n"); return NULL; } /* Free the bitmap info header memory */ if (ppbmi != NULL) { /* Store the address of the BMIH in the ppbmih parameter */ *ppbmi = (BITMAPINFO *) pbmih; } else { free(pbmih); pbmih = NULL; } return hBitmap; } #if 0 static Bool winBltExposedRegionsNativeGDI(ScreenPtr pScreen) { return TRUE; } #endif static Bool winRedrawScreenNativeGDI(ScreenPtr pScreen) { FatalError("winRedrawScreenNativeGDI\n"); return TRUE; } static Bool winRealizeInstalledPaletteNativeGDI(ScreenPtr pScreen) { FatalError("winRealizeInstalledPaletteNativeGDI\n"); return TRUE; } static Bool winInstallColormapNativeGDI(ColormapPtr pColormap) { FatalError("winInstallColormapNativeGDI\n"); return TRUE; } static Bool winStoreColorsNativeGDI(ColormapPtr pmap, int ndef, xColorItem * pdefs) { FatalError("winStoreColorsNativeGDI\n"); return TRUE; } static Bool winCreateColormapNativeGDI(ColormapPtr pColormap) { FatalError("winCreateColormapNativeGDI\n"); return TRUE; } static Bool winDestroyColormapNativeGDI(ColormapPtr pColormap) { FatalError("winDestroyColormapNativeGDI\n"); return TRUE; } /* Set engine specific funtions */ Bool winSetEngineFunctionsNativeGDI(ScreenPtr pScreen) { winScreenPriv(pScreen); winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo; /* Set our pointers */ pScreenPriv->pwinAllocateFB = winAllocateFBNativeGDI; pScreenPriv->pwinFreeFB = winFreeFBNativeGDI; pScreenPriv->pwinShadowUpdate = winShadowUpdateNativeGDI; pScreenPriv->pwinInitScreen = winInitScreenNativeGDI; pScreenPriv->pwinCloseScreen = winCloseScreenNativeGDI; pScreenPriv->pwinInitVisuals = winInitVisualsNativeGDI; pScreenPriv->pwinAdjustVideoMode = winAdjustVideoModeNativeGDI; if (pScreenInfo->fFullScreen) pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowFullScreen; else pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowWindowed; pScreenPriv->pwinFinishScreenInit = winFinishScreenInitNativeGDI; /* * WARNING: Do not set the BltExposedRegions procedure pointer to anything * other than NULL until a working painting procedure is in place. * Else, winWindowProc will get stuck in an infinite loop because * Windows expects the BeginPaint and EndPaint functions to be called * before a WM_PAINT message can be removed from the queue. We are * using NULL here as a signal for winWindowProc that it should * not signal that the WM_PAINT message has been processed. */ pScreenPriv->pwinBltExposedRegions = NULL; pScreenPriv->pwinActivateApp = winActivateAppNativeGDI; pScreenPriv->pwinRedrawScreen = winRedrawScreenNativeGDI; pScreenPriv->pwinRealizeInstalledPalette = winRealizeInstalledPaletteNativeGDI; pScreenPriv->pwinInstallColormap = winInstallColormapNativeGDI; pScreenPriv->pwinStoreColors = winStoreColorsNativeGDI; pScreenPriv->pwinCreateColormap = winCreateColormapNativeGDI; pScreenPriv->pwinDestroyColormap = winDestroyColormapNativeGDI; pScreenPriv->pwinHotKeyAltTab = (winHotKeyAltTabProcPtr) (void (*)(void)) NoopDDA; return TRUE; }