git.oblomov.eu Git - wine/blob - graphics/x11drv/init.c

   1 /*
   2  * X11 graphics driver initialisation functions
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include "ts_xlib.h"
  10
  11 #include <string.h>
  12
  13 #include "bitmap.h"
  14 #include "palette.h"
  15 #include "debugtools.h"
  16 #include "winnt.h"
  17 #include "x11drv.h"
  18 #include "ddrawi.h"
  19
  20 DEFAULT_DEBUG_CHANNEL(x11drv);
  21
  22 const DC_FUNCTIONS *X11DRV_DC_Funcs = NULL;  /* hack */
  23
  24 BITMAP_DRIVER X11DRV_BITMAP_Driver =
  25 {
  26   X11DRV_DIB_SetDIBits,
  27   X11DRV_DIB_GetDIBits,
  28   X11DRV_DIB_DeleteDIBSection,
  29   X11DRV_DIB_SetDIBColorTable,
  30   X11DRV_DIB_GetDIBColorTable,
  31   X11DRV_DIB_Lock,
  32   X11DRV_DIB_Unlock
  33 };
  34
  35 PALETTE_DRIVER X11DRV_PALETTE_Driver =
  36 {
  37   X11DRV_PALETTE_SetMapping,
  38   X11DRV_PALETTE_UpdateMapping,
  39   X11DRV_PALETTE_IsDark
  40 };
  41
  42
  43 Display *gdi_display;  /* display to use for all GDI functions */
  44
  45
  46 /* a few dynamic device caps */
  47 static int log_pixels_x;  /* pixels per logical inch in x direction */
  48 static int log_pixels_y;  /* pixels per logical inch in y direction */
  49 static int horz_size;     /* horz. size of screen in millimeters */
  50 static int vert_size;     /* vert. size of screen in millimeters */
  51 static int palette_size;
  52 static int text_caps;
  53
  54 /**********************************************************************
  55  *           X11DRV_GDI_Initialize
  56  */
  57 BOOL X11DRV_GDI_Initialize( Display *display )
  58 {
  59     Screen *screen = DefaultScreenOfDisplay(display);
  60
  61     gdi_display = display;
  62     BITMAP_Driver = &X11DRV_BITMAP_Driver;
  63     PALETTE_Driver = &X11DRV_PALETTE_Driver;
  64
  65     palette_size = X11DRV_PALETTE_Init();
  66
  67     if (!X11DRV_BITMAP_Init()) return FALSE;
  68
  69     /* Initialize fonts and text caps */
  70
  71     log_pixels_x = MulDiv( WidthOfScreen(screen), 254, WidthMMOfScreen(screen) * 10 );
  72     log_pixels_y = MulDiv( HeightOfScreen(screen), 254, HeightMMOfScreen(screen) * 10 );
  73     text_caps = X11DRV_FONT_Init( &log_pixels_x, &log_pixels_y );
  74     horz_size = MulDiv( screen_width, 254, log_pixels_x * 10 );
  75     vert_size = MulDiv( screen_height, 254, log_pixels_y * 10 );
  76     return TRUE;
  77 }
  78
  79 /**********************************************************************
  80  *           X11DRV_GDI_Finalize
  81  */
  82 void X11DRV_GDI_Finalize(void)
  83 {
  84     X11DRV_PALETTE_Cleanup();
  85     XCloseDisplay( gdi_display );
  86     gdi_display = NULL;
  87 }
  88
  89 /**********************************************************************
  90  *           X11DRV_CreateDC
  91  */
  92 BOOL X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
  93                       LPCSTR output, const DEVMODEA* initData )
  94 {
  95     X11DRV_PDEVICE *physDev;
  96
  97     if (!X11DRV_DC_Funcs) X11DRV_DC_Funcs = dc->funcs;  /* hack */
  98
  99     dc->physDev = physDev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 100                                        sizeof(*physDev) );
 101     if(!physDev) {
 102         ERR("Can't allocate physDev\n");
 103         return FALSE;
 104     }
 105
 106     if (dc->flags & DC_MEMORY)
 107     {
 108         BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( dc->hBitmap, BITMAP_MAGIC );
 109         if (!bmp)
 110         {
 111             HeapFree( GetProcessHeap(), 0, physDev );
 112             return FALSE;
 113         }
 114         if (!bmp->physBitmap) X11DRV_CreateBitmap( dc->hBitmap );
 115         physDev->drawable  = (Pixmap)bmp->physBitmap;
 116         physDev->gc        = TSXCreateGC( gdi_display, physDev->drawable, 0, NULL );
 117         dc->bitsPerPixel       = bmp->bitmap.bmBitsPixel;
 118         dc->totalExtent.left   = 0;
 119         dc->totalExtent.top    = 0;
 120         dc->totalExtent.right  = bmp->bitmap.bmWidth;
 121         dc->totalExtent.bottom = bmp->bitmap.bmHeight;
 122         GDI_ReleaseObj( dc->hBitmap );
 123     }
 124     else
 125     {
 126         physDev->drawable  = root_window;
 127         physDev->gc        = TSXCreateGC( gdi_display, physDev->drawable, 0, NULL );
 128         dc->bitsPerPixel       = screen_depth;
 129         dc->totalExtent.left   = 0;
 130         dc->totalExtent.top    = 0;
 131         dc->totalExtent.right  = screen_width;
 132         dc->totalExtent.bottom = screen_height;
 133     }
 134
 135     physDev->current_pf   = 0;
 136     physDev->used_visuals = 0;
 137
 138     if (!(dc->hVisRgn = CreateRectRgnIndirect( &dc->totalExtent )))
 139     {
 140         TSXFreeGC( gdi_display, physDev->gc );
 141         HeapFree( GetProcessHeap(), 0, physDev );
 142         return FALSE;
 143     }
 144
 145     wine_tsx11_lock();
 146     XSetGraphicsExposures( gdi_display, physDev->gc, False );
 147     XSetSubwindowMode( gdi_display, physDev->gc, IncludeInferiors );
 148     XFlush( gdi_display );
 149     wine_tsx11_unlock();
 150     return TRUE;
 151 }
 152
 153
 154 /**********************************************************************
 155  *           X11DRV_DeleteDC
 156  */
 157 BOOL X11DRV_DeleteDC( DC *dc )
 158 {
 159     X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
 160     wine_tsx11_lock();
 161     XFreeGC( gdi_display, physDev->gc );
 162     while (physDev->used_visuals-- > 0)
 163         XFree(physDev->visuals[physDev->used_visuals]);
 164     wine_tsx11_unlock();
 165     HeapFree( GetProcessHeap(), 0, physDev );
 166     dc->physDev = NULL;
 167     return TRUE;
 168 }
 169
 170
 171 /***********************************************************************
 172  *           GetDeviceCaps    (X11DRV.@)
 173  */
 174 INT X11DRV_GetDeviceCaps( DC *dc, INT cap )
 175 {
 176     switch(cap)
 177     {
 178     case DRIVERVERSION:
 179         return 0x300;
 180     case TECHNOLOGY:
 181         return DT_RASDISPLAY;
 182     case HORZSIZE:
 183         return horz_size;
 184     case VERTSIZE:
 185         return vert_size;
 186     case HORZRES:
 187         return screen_width;
 188     case VERTRES:
 189         return screen_height;
 190     case BITSPIXEL:
 191         return screen_depth;
 192     case PLANES:
 193         return 1;
 194     case NUMBRUSHES:
 195         return -1;
 196     case NUMPENS:
 197         return -1;
 198     case NUMMARKERS:
 199         return 0;
 200     case NUMFONTS:
 201         return 0;
 202     case NUMCOLORS:
 203         /* MSDN: Number of entries in the device's color table, if the device has
 204          * a color depth of no more than 8 bits per pixel.For devices with greater
 205          * color depths, -1 is returned. */
 206         return (screen_depth > 8) ? -1 : (1 << screen_depth);
 207     case PDEVICESIZE:
 208         return sizeof(X11DRV_PDEVICE);
 209     case CURVECAPS:
 210         return (CC_CIRCLES | CC_PIE | CC_CHORD | CC_ELLIPSES | CC_WIDE |
 211                 CC_STYLED | CC_WIDESTYLED | CC_INTERIORS | CC_ROUNDRECT);
 212     case LINECAPS:
 213         return (LC_POLYLINE | LC_MARKER | LC_POLYMARKER | LC_WIDE |
 214                 LC_STYLED | LC_WIDESTYLED | LC_INTERIORS);
 215     case POLYGONALCAPS:
 216         return (PC_POLYGON | PC_RECTANGLE | PC_WINDPOLYGON | PC_SCANLINE |
 217                 PC_WIDE | PC_STYLED | PC_WIDESTYLED | PC_INTERIORS);
 218     case TEXTCAPS:
 219         return text_caps;
 220     case CLIPCAPS:
 221         return CP_REGION;
 222     case RASTERCAPS:
 223         return (RC_BITBLT | RC_BANDING | RC_SCALING | RC_BITMAP64 | RC_DI_BITMAP |
 224                 RC_DIBTODEV | RC_BIGFONT | RC_STRETCHBLT | RC_STRETCHDIB | RC_DEVBITS |
 225                 (palette_size ? RC_PALETTE : 0));
 226     case ASPECTX:
 227     case ASPECTY:
 228         return 36;
 229     case ASPECTXY:
 230         return 51;
 231     case LOGPIXELSX:
 232         return log_pixels_x;
 233     case LOGPIXELSY:
 234         return log_pixels_y;
 235     case CAPS1:
 236         FIXME("(%04x): CAPS1 is unimplemented, will return 0\n", dc->hSelf );
 237         /* please see wingdi.h for the possible bit-flag values that need
 238            to be returned. also, see
 239            http://msdn.microsoft.com/library/ddkdoc/win95ddk/graphcnt_1m0p.htm */
 240         return 0;
 241     case SIZEPALETTE:
 242         return palette_size;
 243     case NUMRESERVED:
 244     case COLORRES:
 245     case PHYSICALWIDTH:
 246     case PHYSICALHEIGHT:
 247     case PHYSICALOFFSETX:
 248     case PHYSICALOFFSETY:
 249     case SCALINGFACTORX:
 250     case SCALINGFACTORY:
 251     case VREFRESH:
 252     case DESKTOPVERTRES:
 253     case DESKTOPHORZRES:
 254     case BTLALIGNMENT:
 255         return 0;
 256     default:
 257         FIXME("(%04x): unsupported capability %d, will return 0\n", dc->hSelf, cap );
 258         return 0;
 259     }
 260 }
 261
 262
 263 /**********************************************************************
 264  *           ExtEscape  (X11DRV.@)
 265  */
 266 INT X11DRV_ExtEscape( DC *dc, INT escape, INT in_count, LPCVOID in_data,
 267                       INT out_count, LPVOID out_data )
 268 {
 269     switch(escape)
 270     {
 271     case QUERYESCSUPPORT:
 272         if (in_data)
 273         {
 274             switch (*(INT *)in_data)
 275             {
 276             case DCICOMMAND:
 277                 return DD_HAL_VERSION;
 278             }
 279         }
 280         break;
 281
 282     case DCICOMMAND:
 283         if (in_data)
 284         {
 285             const DCICMD *lpCmd = in_data;
 286             if (lpCmd->dwVersion != DD_VERSION) break;
 287             return X11DRV_DCICommand(in_count, lpCmd, out_data);
 288         }
 289         break;
 290     }
 291     return 0;
 292 }