/* * X11 graphics driver initialisation functions * * Copyright 1996 Alexandre Julliard * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include #include #include "windef.h" #include "winbase.h" #include "winreg.h" #include "x11drv.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(x11drv); Display *gdi_display; /* display to use for all GDI functions */ /* a few dynamic device caps */ static int log_pixels_x; /* pixels per logical inch in x direction */ static int log_pixels_y; /* pixels per logical inch in y direction */ static int palette_size; static Pixmap stock_bitmap_pixmap; /* phys bitmap for the default stock bitmap */ static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT; static const WCHAR dpi_key_name[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\0'}; static const WCHAR def_dpi_key_name[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'}; static const WCHAR dpi_value_name[] = {'L','o','g','P','i','x','e','l','s','\0'}; static const struct gdi_dc_funcs x11drv_funcs; static const struct gdi_dc_funcs *xrender_funcs; /****************************************************************************** * get_reg_dword * * Read a DWORD value from the registry */ static BOOL get_reg_dword(HKEY base, const WCHAR *key_name, const WCHAR *value_name, DWORD *value) { HKEY key; DWORD type, data, size = sizeof(data); BOOL ret = FALSE; if (RegOpenKeyW(base, key_name, &key) == ERROR_SUCCESS) { if (RegQueryValueExW(key, value_name, NULL, &type, (void *)&data, &size) == ERROR_SUCCESS && type == REG_DWORD) { *value = data; ret = TRUE; } RegCloseKey(key); } return ret; } /****************************************************************************** * get_dpi * * get the dpi from the registry */ static DWORD get_dpi(void) { DWORD dpi; if (get_reg_dword(HKEY_CURRENT_USER, dpi_key_name, dpi_value_name, &dpi)) return dpi; if (get_reg_dword(HKEY_CURRENT_CONFIG, def_dpi_key_name, dpi_value_name, &dpi)) return dpi; return 0; } /********************************************************************** * device_init * * Perform initializations needed upon creation of the first device. */ static BOOL WINAPI device_init( INIT_ONCE *once, void *param, void **context ) { /* Initialize XRender */ xrender_funcs = X11DRV_XRender_Init(); /* Init Xcursor */ X11DRV_Xcursor_Init(); palette_size = X11DRV_PALETTE_Init(); stock_bitmap_pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, 1 ); /* Initialize device caps */ log_pixels_x = log_pixels_y = get_dpi(); if (!log_pixels_x) log_pixels_x = log_pixels_y = USER_DEFAULT_SCREEN_DPI; return TRUE; } static X11DRV_PDEVICE *create_x11_physdev( Drawable drawable ) { X11DRV_PDEVICE *physDev; InitOnceExecuteOnce( &init_once, device_init, NULL, NULL ); if (!(physDev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physDev) ))) return NULL; physDev->drawable = drawable; physDev->gc = XCreateGC( gdi_display, drawable, 0, NULL ); XSetGraphicsExposures( gdi_display, physDev->gc, False ); XSetSubwindowMode( gdi_display, physDev->gc, IncludeInferiors ); XFlush( gdi_display ); return physDev; } /********************************************************************** * X11DRV_CreateDC */ static BOOL X11DRV_CreateDC( PHYSDEV *pdev, LPCWSTR driver, LPCWSTR device, LPCWSTR output, const DEVMODEW* initData ) { X11DRV_PDEVICE *physDev = create_x11_physdev( root_window ); if (!physDev) return FALSE; physDev->depth = default_visual.depth; physDev->color_shifts = &X11DRV_PALETTE_default_shifts; physDev->dc_rect = get_virtual_screen_rect(); OffsetRect( &physDev->dc_rect, -physDev->dc_rect.left, -physDev->dc_rect.top ); push_dc_driver( pdev, &physDev->dev, &x11drv_funcs ); if (xrender_funcs && !xrender_funcs->pCreateDC( pdev, driver, device, output, initData )) return FALSE; return TRUE; } /********************************************************************** * X11DRV_CreateCompatibleDC */ static BOOL X11DRV_CreateCompatibleDC( PHYSDEV orig, PHYSDEV *pdev ) { X11DRV_PDEVICE *physDev = create_x11_physdev( stock_bitmap_pixmap ); if (!physDev) return FALSE; physDev->depth = 1; SetRect( &physDev->dc_rect, 0, 0, 1, 1 ); push_dc_driver( pdev, &physDev->dev, &x11drv_funcs ); if (orig) return TRUE; /* we already went through Xrender if we have an orig device */ if (xrender_funcs && !xrender_funcs->pCreateCompatibleDC( NULL, pdev )) return FALSE; return TRUE; } /********************************************************************** * X11DRV_DeleteDC */ static BOOL X11DRV_DeleteDC( PHYSDEV dev ) { X11DRV_PDEVICE *physDev = get_x11drv_dev( dev ); XFreeGC( gdi_display, physDev->gc ); HeapFree( GetProcessHeap(), 0, physDev ); return TRUE; } void add_device_bounds( X11DRV_PDEVICE *dev, const RECT *rect ) { RECT rc; if (!dev->bounds) return; if (dev->region && GetRgnBox( dev->region, &rc )) { if (IntersectRect( &rc, &rc, rect )) add_bounds_rect( dev->bounds, &rc ); } else add_bounds_rect( dev->bounds, rect ); } /*********************************************************************** * X11DRV_SetBoundsRect */ static UINT X11DRV_SetBoundsRect( PHYSDEV dev, RECT *rect, UINT flags ) { X11DRV_PDEVICE *pdev = get_x11drv_dev( dev ); if (flags & DCB_DISABLE) pdev->bounds = NULL; else if (flags & DCB_ENABLE) pdev->bounds = rect; return DCB_RESET; /* we don't have device-specific bounds */ } /*********************************************************************** * GetDeviceCaps (X11DRV.@) */ static INT X11DRV_GetDeviceCaps( PHYSDEV dev, INT cap ) { switch(cap) { case DRIVERVERSION: return 0x300; case TECHNOLOGY: return DT_RASDISPLAY; case HORZSIZE: { RECT primary_rect = get_primary_monitor_rect(); return MulDiv( primary_rect.right - primary_rect.left, 254, log_pixels_x * 10 ); } case VERTSIZE: { RECT primary_rect = get_primary_monitor_rect(); return MulDiv( primary_rect.bottom - primary_rect.top, 254, log_pixels_y * 10 ); } case HORZRES: { RECT primary_rect = get_primary_monitor_rect(); return primary_rect.right - primary_rect.left; } case VERTRES: { RECT primary_rect = get_primary_monitor_rect(); return primary_rect.bottom - primary_rect.top; } case DESKTOPHORZRES: { RECT virtual_rect = get_virtual_screen_rect(); return virtual_rect.right - virtual_rect.left; } case DESKTOPVERTRES: { RECT virtual_rect = get_virtual_screen_rect(); return virtual_rect.bottom - virtual_rect.top; } case BITSPIXEL: return screen_bpp; case PLANES: return 1; case NUMBRUSHES: return -1; case NUMPENS: return -1; case NUMMARKERS: return 0; case NUMFONTS: return 0; case NUMCOLORS: /* MSDN: Number of entries in the device's color table, if the device has * a color depth of no more than 8 bits per pixel.For devices with greater * color depths, -1 is returned. */ return (default_visual.depth > 8) ? -1 : (1 << default_visual.depth); case PDEVICESIZE: return sizeof(X11DRV_PDEVICE); case CURVECAPS: return (CC_CIRCLES | CC_PIE | CC_CHORD | CC_ELLIPSES | CC_WIDE | CC_STYLED | CC_WIDESTYLED | CC_INTERIORS | CC_ROUNDRECT); case LINECAPS: return (LC_POLYLINE | LC_MARKER | LC_POLYMARKER | LC_WIDE | LC_STYLED | LC_WIDESTYLED | LC_INTERIORS); case POLYGONALCAPS: return (PC_POLYGON | PC_RECTANGLE | PC_WINDPOLYGON | PC_SCANLINE | PC_WIDE | PC_STYLED | PC_WIDESTYLED | PC_INTERIORS); case TEXTCAPS: return (TC_OP_CHARACTER | TC_OP_STROKE | TC_CP_STROKE | TC_CR_ANY | TC_SF_X_YINDEP | TC_SA_DOUBLE | TC_SA_INTEGER | TC_SA_CONTIN | TC_UA_ABLE | TC_SO_ABLE | TC_RA_ABLE | TC_VA_ABLE); case CLIPCAPS: return CP_REGION; case COLORRES: /* The observed correspondence between BITSPIXEL and COLORRES is: * BITSPIXEL: 8 -> COLORRES: 18 * BITSPIXEL: 16 -> COLORRES: 16 * BITSPIXEL: 24 -> COLORRES: 24 * BITSPIXEL: 32 -> COLORRES: 24 */ return (screen_bpp <= 8) ? 18 : min( 24, screen_bpp ); case RASTERCAPS: return (RC_BITBLT | RC_BANDING | RC_SCALING | RC_BITMAP64 | RC_DI_BITMAP | RC_DIBTODEV | RC_BIGFONT | RC_STRETCHBLT | RC_STRETCHDIB | RC_DEVBITS | (palette_size ? RC_PALETTE : 0)); case SHADEBLENDCAPS: return (SB_GRAD_RECT | SB_GRAD_TRI | SB_CONST_ALPHA | SB_PIXEL_ALPHA); case ASPECTX: case ASPECTY: return 36; case ASPECTXY: return 51; case LOGPIXELSX: return log_pixels_x; case LOGPIXELSY: return log_pixels_y; case CAPS1: FIXME("(%p): CAPS1 is unimplemented, will return 0\n", dev->hdc ); /* please see wingdi.h for the possible bit-flag values that need to be returned. */ return 0; case SIZEPALETTE: return palette_size; case NUMRESERVED: case PHYSICALWIDTH: case PHYSICALHEIGHT: case PHYSICALOFFSETX: case PHYSICALOFFSETY: case SCALINGFACTORX: case SCALINGFACTORY: case VREFRESH: case BLTALIGNMENT: return 0; default: FIXME("(%p): unsupported capability %d, will return 0\n", dev->hdc, cap ); return 0; } } /*********************************************************************** * SelectFont */ static HFONT X11DRV_SelectFont( PHYSDEV dev, HFONT hfont, UINT *aa_flags ) { if (default_visual.depth <= 8) *aa_flags = GGO_BITMAP; /* no anti-aliasing on <= 8bpp */ dev = GET_NEXT_PHYSDEV( dev, pSelectFont ); return dev->funcs->pSelectFont( dev, hfont, aa_flags ); } /********************************************************************** * ExtEscape (X11DRV.@) */ static INT X11DRV_ExtEscape( PHYSDEV dev, INT escape, INT in_count, LPCVOID in_data, INT out_count, LPVOID out_data ) { X11DRV_PDEVICE *physDev = get_x11drv_dev( dev ); switch(escape) { case QUERYESCSUPPORT: if (in_data && in_count >= sizeof(DWORD)) { switch (*(const INT *)in_data) { case X11DRV_ESCAPE: return TRUE; } } break; case X11DRV_ESCAPE: if (in_data && in_count >= sizeof(enum x11drv_escape_codes)) { switch(*(const enum x11drv_escape_codes *)in_data) { case X11DRV_SET_DRAWABLE: if (in_count >= sizeof(struct x11drv_escape_set_drawable)) { const struct x11drv_escape_set_drawable *data = in_data; physDev->dc_rect = data->dc_rect; physDev->drawable = data->drawable; XFreeGC( gdi_display, physDev->gc ); physDev->gc = XCreateGC( gdi_display, physDev->drawable, 0, NULL ); XSetGraphicsExposures( gdi_display, physDev->gc, False ); XSetSubwindowMode( gdi_display, physDev->gc, data->mode ); TRACE( "SET_DRAWABLE hdc %p drawable %lx dc_rect %s\n", dev->hdc, physDev->drawable, wine_dbgstr_rect(&physDev->dc_rect) ); return TRUE; } break; case X11DRV_GET_DRAWABLE: if (out_count >= sizeof(struct x11drv_escape_get_drawable)) { struct x11drv_escape_get_drawable *data = out_data; data->drawable = physDev->drawable; return TRUE; } break; case X11DRV_FLUSH_GL_DRAWABLE: if (in_count >= sizeof(struct x11drv_escape_flush_gl_drawable)) { const struct x11drv_escape_flush_gl_drawable *data = in_data; RECT rect = physDev->dc_rect; OffsetRect( &rect, -physDev->dc_rect.left, -physDev->dc_rect.top ); XSetFunction( gdi_display, physDev->gc, GXcopy ); XCopyArea( gdi_display, data->gl_drawable, physDev->drawable, physDev->gc, 0, 0, rect.right, rect.bottom, physDev->dc_rect.left, physDev->dc_rect.top ); add_device_bounds( physDev, &rect ); return TRUE; } break; case X11DRV_START_EXPOSURES: XSetGraphicsExposures( gdi_display, physDev->gc, True ); physDev->exposures = 0; return TRUE; case X11DRV_END_EXPOSURES: if (out_count >= sizeof(HRGN)) { HRGN hrgn = 0, tmp = 0; XSetGraphicsExposures( gdi_display, physDev->gc, False ); if (physDev->exposures) { for (;;) { XEvent event; XWindowEvent( gdi_display, physDev->drawable, ~0, &event ); if (event.type == NoExpose) break; if (event.type == GraphicsExpose) { RECT rect; rect.left = event.xgraphicsexpose.x - physDev->dc_rect.left; rect.top = event.xgraphicsexpose.y - physDev->dc_rect.top; rect.right = rect.left + event.xgraphicsexpose.width; rect.bottom = rect.top + event.xgraphicsexpose.height; if (GetLayout( dev->hdc ) & LAYOUT_RTL) mirror_rect( &physDev->dc_rect, &rect ); TRACE( "got %s count %d\n", wine_dbgstr_rect(&rect), event.xgraphicsexpose.count ); if (!tmp) tmp = CreateRectRgnIndirect( &rect ); else SetRectRgn( tmp, rect.left, rect.top, rect.right, rect.bottom ); if (hrgn) CombineRgn( hrgn, hrgn, tmp, RGN_OR ); else { hrgn = tmp; tmp = 0; } if (!event.xgraphicsexpose.count) break; } else { ERR( "got unexpected event %d\n", event.type ); break; } } if (tmp) DeleteObject( tmp ); } *(HRGN *)out_data = hrgn; return TRUE; } break; default: break; } } break; } return 0; } /********************************************************************** * X11DRV_wine_get_wgl_driver */ static struct opengl_funcs * X11DRV_wine_get_wgl_driver( PHYSDEV dev, UINT version ) { struct opengl_funcs *ret; if (!(ret = get_glx_driver( version ))) { dev = GET_NEXT_PHYSDEV( dev, wine_get_wgl_driver ); ret = dev->funcs->wine_get_wgl_driver( dev, version ); } return ret; } static const struct gdi_dc_funcs x11drv_funcs = { NULL, /* pAbortDoc */ NULL, /* pAbortPath */ NULL, /* pAlphaBlend */ NULL, /* pAngleArc */ X11DRV_Arc, /* pArc */ NULL, /* pArcTo */ NULL, /* pBeginPath */ NULL, /* pBlendImage */ X11DRV_Chord, /* pChord */ NULL, /* pCloseFigure */ X11DRV_CreateCompatibleDC, /* pCreateCompatibleDC */ X11DRV_CreateDC, /* pCreateDC */ X11DRV_DeleteDC, /* pDeleteDC */ NULL, /* pDeleteObject */ NULL, /* pDeviceCapabilities */ X11DRV_Ellipse, /* pEllipse */ NULL, /* pEndDoc */ NULL, /* pEndPage */ NULL, /* pEndPath */ NULL, /* pEnumFonts */ X11DRV_EnumICMProfiles, /* pEnumICMProfiles */ NULL, /* pExcludeClipRect */ NULL, /* pExtDeviceMode */ X11DRV_ExtEscape, /* pExtEscape */ X11DRV_ExtFloodFill, /* pExtFloodFill */ NULL, /* pExtSelectClipRgn */ NULL, /* pExtTextOut */ X11DRV_FillPath, /* pFillPath */ NULL, /* pFillRgn */ NULL, /* pFlattenPath */ NULL, /* pFontIsLinked */ NULL, /* pFrameRgn */ NULL, /* pGdiComment */ NULL, /* pGetBoundsRect */ NULL, /* pGetCharABCWidths */ NULL, /* pGetCharABCWidthsI */ NULL, /* pGetCharWidth */ X11DRV_GetDeviceCaps, /* pGetDeviceCaps */ X11DRV_GetDeviceGammaRamp, /* pGetDeviceGammaRamp */ NULL, /* pGetFontData */ NULL, /* pGetFontRealizationInfo */ NULL, /* pGetFontUnicodeRanges */ NULL, /* pGetGlyphIndices */ NULL, /* pGetGlyphOutline */ X11DRV_GetICMProfile, /* pGetICMProfile */ X11DRV_GetImage, /* pGetImage */ NULL, /* pGetKerningPairs */ X11DRV_GetNearestColor, /* pGetNearestColor */ NULL, /* pGetOutlineTextMetrics */ NULL, /* pGetPixel */ X11DRV_GetSystemPaletteEntries, /* pGetSystemPaletteEntries */ NULL, /* pGetTextCharsetInfo */ NULL, /* pGetTextExtentExPoint */ NULL, /* pGetTextExtentExPointI */ NULL, /* pGetTextFace */ NULL, /* pGetTextMetrics */ X11DRV_GradientFill, /* pGradientFill */ NULL, /* pIntersectClipRect */ NULL, /* pInvertRgn */ X11DRV_LineTo, /* pLineTo */ NULL, /* pModifyWorldTransform */ NULL, /* pMoveTo */ NULL, /* pOffsetClipRgn */ NULL, /* pOffsetViewportOrg */ NULL, /* pOffsetWindowOrg */ X11DRV_PaintRgn, /* pPaintRgn */ X11DRV_PatBlt, /* pPatBlt */ X11DRV_Pie, /* pPie */ NULL, /* pPolyBezier */ NULL, /* pPolyBezierTo */ NULL, /* pPolyDraw */ X11DRV_PolyPolygon, /* pPolyPolygon */ X11DRV_PolyPolyline, /* pPolyPolyline */ X11DRV_Polygon, /* pPolygon */ NULL, /* pPolyline */ NULL, /* pPolylineTo */ X11DRV_PutImage, /* pPutImage */ X11DRV_RealizeDefaultPalette, /* pRealizeDefaultPalette */ X11DRV_RealizePalette, /* pRealizePalette */ X11DRV_Rectangle, /* pRectangle */ NULL, /* pResetDC */ NULL, /* pRestoreDC */ X11DRV_RoundRect, /* pRoundRect */ NULL, /* pSaveDC */ NULL, /* pScaleViewportExt */ NULL, /* pScaleWindowExt */ NULL, /* pSelectBitmap */ X11DRV_SelectBrush, /* pSelectBrush */ NULL, /* pSelectClipPath */ X11DRV_SelectFont, /* pSelectFont */ NULL, /* pSelectPalette */ X11DRV_SelectPen, /* pSelectPen */ NULL, /* pSetArcDirection */ NULL, /* pSetBkColor */ NULL, /* pSetBkMode */ X11DRV_SetBoundsRect, /* pSetBoundsRect */ X11DRV_SetDCBrushColor, /* pSetDCBrushColor */ X11DRV_SetDCPenColor, /* pSetDCPenColor */ NULL, /* pSetDIBitsToDevice */ X11DRV_SetDeviceClipping, /* pSetDeviceClipping */ X11DRV_SetDeviceGammaRamp, /* pSetDeviceGammaRamp */ NULL, /* pSetLayout */ NULL, /* pSetMapMode */ NULL, /* pSetMapperFlags */ X11DRV_SetPixel, /* pSetPixel */ NULL, /* pSetPolyFillMode */ NULL, /* pSetROP2 */ NULL, /* pSetRelAbs */ NULL, /* pSetStretchBltMode */ NULL, /* pSetTextAlign */ NULL, /* pSetTextCharacterExtra */ NULL, /* pSetTextColor */ NULL, /* pSetTextJustification */ NULL, /* pSetViewportExt */ NULL, /* pSetViewportOrg */ NULL, /* pSetWindowExt */ NULL, /* pSetWindowOrg */ NULL, /* pSetWorldTransform */ NULL, /* pStartDoc */ NULL, /* pStartPage */ X11DRV_StretchBlt, /* pStretchBlt */ NULL, /* pStretchDIBits */ X11DRV_StrokeAndFillPath, /* pStrokeAndFillPath */ X11DRV_StrokePath, /* pStrokePath */ X11DRV_UnrealizePalette, /* pUnrealizePalette */ NULL, /* pWidenPath */ X11DRV_wine_get_wgl_driver, /* wine_get_wgl_driver */ GDI_PRIORITY_GRAPHICS_DRV /* priority */ }; /****************************************************************************** * X11DRV_get_gdi_driver */ const struct gdi_dc_funcs * CDECL X11DRV_get_gdi_driver( unsigned int version ) { if (version != WINE_GDI_DRIVER_VERSION) { ERR( "version mismatch, gdi32 wants %u but winex11 has %u\n", version, WINE_GDI_DRIVER_VERSION ); return NULL; } return &x11drv_funcs; }