dlls/winex11.drv/settings.c

   1 /*
   2  * Wine X11drv display settings functions
   3  *
   4  * Copyright 2003 Alexander James Pasadyn
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <assert.h>
  25
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28
  29 #include "x11drv.h"
  30
  31 #include "windef.h"
  32 #include "winreg.h"
  33 #include "wingdi.h"
  34 #include "ddrawi.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(x11settings);
  38
  39 /*
  40  * The DDHALMODEINFO type is used to hold all the mode information.
  41  * This is done because the array of DDHALMODEINFO structures must be
  42  * created for use by DirectDraw anyway.
  43  */
  44 static LPDDHALMODEINFO dd_modes = NULL;
  45 static unsigned int dd_mode_count = 0;
  46 static unsigned int dd_max_modes = 0;
  47 static int dd_mode_default = 0;
  48 static const unsigned int depths[]  = {8, 16, 32};
  49
  50 /* pointers to functions that actually do the hard stuff */
  51 static int (*pGetCurrentMode)(void);
  52 static LONG (*pSetCurrentMode)(int mode);
  53 static const char *handler_name;
  54
  55 /*
  56  * Set the handlers for resolution changing functions
  57  * and initialize the master list of modes
  58  */
  59 LPDDHALMODEINFO X11DRV_Settings_SetHandlers(const char *name,
  60                                  int (*pNewGCM)(void),
  61                                  LONG (*pNewSCM)(int),
  62                                  unsigned int nmodes,
  63                                  int reserve_depths)
  64 {
  65     handler_name = name;
  66     pGetCurrentMode = pNewGCM;
  67     pSetCurrentMode = pNewSCM;
  68     TRACE("Resolution settings now handled by: %s\n", name);
  69     if (reserve_depths)
  70         /* leave room for other depths */
  71         dd_max_modes = (3+1)*(nmodes);
  72     else
  73         dd_max_modes = nmodes;
  74
  75     if (dd_modes)
  76     {
  77         TRACE("Destroying old display modes array\n");
  78         HeapFree(GetProcessHeap(), 0, dd_modes);
  79     }
  80     dd_modes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DDHALMODEINFO) * dd_max_modes);
  81     dd_mode_count = 0;
  82     TRACE("Initialized new display modes array\n");
  83     return dd_modes;
  84 }
  85
  86 /* Add one mode to the master list */
  87 void X11DRV_Settings_AddOneMode(unsigned int width, unsigned int height, unsigned int bpp, unsigned int freq)
  88 {
  89     LPDDHALMODEINFO info = &(dd_modes[dd_mode_count]);
  90     DWORD dwBpp = screen_depth;
  91     if (dd_mode_count >= dd_max_modes)
  92     {
  93         ERR("Maximum modes (%d) exceeded\n", dd_max_modes);
  94         return;
  95     }
  96     if (dwBpp == 24) dwBpp = 32;
  97     if (bpp == 0) bpp = dwBpp;
  98     info->dwWidth        = width;
  99     info->dwHeight       = height;
 100     info->wRefreshRate   = freq;
 101     info->lPitch         = 0;
 102     info->dwBPP          = bpp;
 103     info->wFlags         = 0;
 104     info->dwRBitMask     = 0;
 105     info->dwGBitMask     = 0;
 106     info->dwBBitMask     = 0;
 107     info->dwAlphaBitMask = 0;
 108     TRACE("initialized mode %d: %dx%dx%d @%d Hz (%s)\n",
 109           dd_mode_count, width, height, bpp, freq, handler_name);
 110     dd_mode_count++;
 111 }
 112
 113 /* copy all the current modes using the other color depths */
 114 void X11DRV_Settings_AddDepthModes(void)
 115 {
 116     int i, j;
 117     int existing_modes = dd_mode_count;
 118     DWORD dwBpp = screen_depth;
 119     if (dwBpp == 24) dwBpp = 32;
 120     for (j=0; j<3; j++)
 121     {
 122         if (depths[j] != dwBpp)
 123         {
 124             for (i=0; i < existing_modes; i++)
 125             {
 126                 X11DRV_Settings_AddOneMode(dd_modes[i].dwWidth, dd_modes[i].dwHeight,
 127                                            depths[j], dd_modes[i].wRefreshRate);
 128             }
 129         }
 130     }
 131 }
 132
 133 /* set the default mode */
 134 void X11DRV_Settings_SetDefaultMode(int mode)
 135 {
 136     dd_mode_default = mode;
 137 }
 138
 139 /* return the number of modes that are initialized */
 140 unsigned int X11DRV_Settings_GetModeCount(void)
 141 {
 142     return dd_mode_count;
 143 }
 144
 145 /***********************************************************************
 146  * Default handlers if resolution switching is not enabled
 147  *
 148  */
 149 static int X11DRV_nores_GetCurrentMode(void)
 150 {
 151     return 0;
 152 }
 153
 154 static LONG X11DRV_nores_SetCurrentMode(int mode)
 155 {
 156     TRACE("Ignoring mode change request\n");
 157     return DISP_CHANGE_FAILED;
 158 }
 159
 160 /* default handler only gets the current X desktop resolution */
 161 void X11DRV_Settings_Init(void)
 162 {
 163     X11DRV_Settings_SetHandlers("NoRes",
 164                                 X11DRV_nores_GetCurrentMode,
 165                                 X11DRV_nores_SetCurrentMode,
 166                                 1, 0);
 167     X11DRV_Settings_AddOneMode(screen_width, screen_height, 0, 60);
 168 }
 169
 170 static BOOL get_display_device_reg_key(char *key, unsigned len)
 171 {
 172     static const char display_device_guid_prop[] = "__wine_display_device_guid";
 173     static const char video_path[] = "System\\CurrentControlSet\\Control\\Video\\{";
 174     static const char display0[] = "}\\0000";
 175     ATOM guid_atom;
 176
 177     assert(len >= sizeof(video_path) + sizeof(display0) + 40);
 178
 179     guid_atom = HandleToULong(GetPropA(GetDesktopWindow(), display_device_guid_prop));
 180     if (!guid_atom) return FALSE;
 181
 182     memcpy(key, video_path, sizeof(video_path));
 183
 184     if (!GlobalGetAtomNameA(guid_atom, key + strlen(key), 40))
 185         return FALSE;
 186
 187     strcat(key, display0);
 188
 189     TRACE("display device key %s\n", wine_dbgstr_a(key));
 190     return TRUE;
 191 }
 192
 193 static BOOL read_registry_settings(DEVMODEW *dm)
 194 {
 195     char wine_x11_reg_key[128];
 196     HKEY hkey;
 197     DWORD type, size;
 198     BOOL ret = TRUE;
 199
 200     if (!get_display_device_reg_key(wine_x11_reg_key, sizeof(wine_x11_reg_key)))
 201         return FALSE;
 202
 203     if (RegOpenKeyExA(HKEY_CURRENT_CONFIG, wine_x11_reg_key, 0, KEY_READ, &hkey))
 204         return FALSE;
 205
 206 #define query_value(name, data) \
 207     size = sizeof(DWORD); \
 208     if (RegQueryValueExA(hkey, name, 0, &type, (LPBYTE)(data), &size) || \
 209         type != REG_DWORD || size != sizeof(DWORD)) \
 210         ret = FALSE
 211
 212     query_value("DefaultSettings.BitsPerPel", &dm->dmBitsPerPel);
 213     query_value("DefaultSettings.XResolution", &dm->dmPelsWidth);
 214     query_value("DefaultSettings.YResolution", &dm->dmPelsHeight);
 215     query_value("DefaultSettings.VRefresh", &dm->dmDisplayFrequency);
 216     query_value("DefaultSettings.Flags", &dm->u2.dmDisplayFlags);
 217     query_value("DefaultSettings.XPanning", &dm->u1.s2.dmPosition.x);
 218     query_value("DefaultSettings.YPanning", &dm->u1.s2.dmPosition.y);
 219     query_value("DefaultSettings.Orientation", &dm->u1.s2.dmDisplayOrientation);
 220     query_value("DefaultSettings.FixedOutput", &dm->u1.s2.dmDisplayFixedOutput);
 221
 222 #undef query_value
 223
 224     RegCloseKey(hkey);
 225     return ret;
 226 }
 227
 228 static BOOL write_registry_settings(const DEVMODEW *dm)
 229 {
 230     char wine_x11_reg_key[128];
 231     HKEY hkey;
 232     BOOL ret = TRUE;
 233
 234     if (!get_display_device_reg_key(wine_x11_reg_key, sizeof(wine_x11_reg_key)))
 235         return FALSE;
 236
 237     if (RegCreateKeyExA(HKEY_CURRENT_CONFIG, wine_x11_reg_key, 0, NULL,
 238                         REG_OPTION_VOLATILE, KEY_WRITE, NULL, &hkey, NULL))
 239         return FALSE;
 240
 241 #define set_value(name, data) \
 242     if (RegSetValueExA(hkey, name, 0, REG_DWORD, (LPBYTE)(data), sizeof(DWORD))) \
 243         ret = FALSE
 244
 245     set_value("DefaultSettings.BitsPerPel", &dm->dmBitsPerPel);
 246     set_value("DefaultSettings.XResolution", &dm->dmPelsWidth);
 247     set_value("DefaultSettings.YResolution", &dm->dmPelsHeight);
 248     set_value("DefaultSettings.VRefresh", &dm->dmDisplayFrequency);
 249     set_value("DefaultSettings.Flags", &dm->u2.dmDisplayFlags);
 250     set_value("DefaultSettings.XPanning", &dm->u1.s2.dmPosition.x);
 251     set_value("DefaultSettings.YPanning", &dm->u1.s2.dmPosition.y);
 252     set_value("DefaultSettings.Orientation", &dm->u1.s2.dmDisplayOrientation);
 253     set_value("DefaultSettings.FixedOutput", &dm->u1.s2.dmDisplayFixedOutput);
 254
 255 #undef set_value
 256
 257     RegCloseKey(hkey);
 258     return ret;
 259 }
 260
 261 /***********************************************************************
 262  *              EnumDisplaySettingsEx  (X11DRV.@)
 263  *
 264  */
 265 BOOL X11DRV_EnumDisplaySettingsEx( LPCWSTR name, DWORD n, LPDEVMODEW devmode, DWORD flags)
 266 {
 267     static const WCHAR dev_name[CCHDEVICENAME] =
 268         { 'W','i','n','e',' ','X','1','1',' ','d','r','i','v','e','r',0 };
 269     DWORD dwBpp;
 270
 271     dwBpp = screen_depth;
 272     if (dwBpp == 24) dwBpp = 32;
 273
 274     devmode->dmSize = sizeof(DEVMODEW);
 275     devmode->dmSpecVersion = MAKEWORD(1,4);
 276     devmode->dmDriverVersion = MAKEWORD(1,4);
 277     memcpy(devmode->dmDeviceName, dev_name, sizeof(dev_name));
 278     devmode->dmDriverExtra = 0;
 279     devmode->u2.dmDisplayFlags = 0;
 280     devmode->dmDisplayFrequency = 0;
 281     devmode->u1.s2.dmPosition.x = 0;
 282     devmode->u1.s2.dmPosition.y = 0;
 283     devmode->u1.s2.dmDisplayOrientation = 0;
 284     devmode->u1.s2.dmDisplayFixedOutput = 0;
 285
 286     if (n == ENUM_CURRENT_SETTINGS)
 287     {
 288         TRACE("mode %d (current) -- getting current mode (%s)\n", n, handler_name);
 289         n = pGetCurrentMode();
 290     }
 291     if (n == ENUM_REGISTRY_SETTINGS)
 292     {
 293         TRACE("mode %d (registry) -- getting default mode (%s)\n", n, handler_name);
 294         return read_registry_settings(devmode);
 295     }
 296     if (n < dd_mode_count)
 297     {
 298         devmode->dmPelsWidth = dd_modes[n].dwWidth;
 299         devmode->dmPelsHeight = dd_modes[n].dwHeight;
 300         devmode->dmBitsPerPel = dd_modes[n].dwBPP;
 301         devmode->dmDisplayFrequency = dd_modes[n].wRefreshRate;
 302         devmode->dmFields = (DM_PELSWIDTH|DM_PELSHEIGHT|DM_BITSPERPEL);
 303         if (devmode->dmDisplayFrequency)
 304         {
 305             devmode->dmFields |= DM_DISPLAYFREQUENCY;
 306             TRACE("mode %d -- %dx%dx%dbpp @%d Hz (%s)\n", n,
 307                   devmode->dmPelsWidth, devmode->dmPelsHeight, devmode->dmBitsPerPel,
 308                   devmode->dmDisplayFrequency, handler_name);
 309         }
 310         else
 311         {
 312             TRACE("mode %d -- %dx%dx%dbpp (%s)\n", n,
 313                   devmode->dmPelsWidth, devmode->dmPelsHeight, devmode->dmBitsPerPel,
 314                   handler_name);
 315         }
 316         return TRUE;
 317     }
 318     TRACE("mode %d -- not present (%s)\n", n, handler_name);
 319     return FALSE;
 320 }
 321
 322 #define _X_FIELD(prefix, bits) if ((fields) & prefix##_##bits) {p+=sprintf(p, "%s%s", first ? "" : ",", #bits); first=FALSE;}
 323 static const char * _CDS_flags(DWORD fields)
 324 {
 325     BOOL first = TRUE;
 326     char buf[128];
 327     char *p = buf;
 328     _X_FIELD(CDS,UPDATEREGISTRY);_X_FIELD(CDS,TEST);_X_FIELD(CDS,FULLSCREEN);
 329     _X_FIELD(CDS,GLOBAL);_X_FIELD(CDS,SET_PRIMARY);_X_FIELD(CDS,RESET);
 330     _X_FIELD(CDS,SETRECT);_X_FIELD(CDS,NORESET);
 331     *p = 0;
 332     return wine_dbg_sprintf("%s", buf);
 333 }
 334 static const char * _DM_fields(DWORD fields)
 335 {
 336     BOOL first = TRUE;
 337     char buf[128];
 338     char *p = buf;
 339     _X_FIELD(DM,BITSPERPEL);_X_FIELD(DM,PELSWIDTH);_X_FIELD(DM,PELSHEIGHT);
 340     _X_FIELD(DM,DISPLAYFLAGS);_X_FIELD(DM,DISPLAYFREQUENCY);_X_FIELD(DM,POSITION);
 341     *p = 0;
 342     return wine_dbg_sprintf("%s", buf);
 343 }
 344 #undef _X_FIELD
 345
 346 /***********************************************************************
 347  *              ChangeDisplaySettingsEx  (X11DRV.@)
 348  *
 349  */
 350 LONG X11DRV_ChangeDisplaySettingsEx( LPCWSTR devname, LPDEVMODEW devmode,
 351                                      HWND hwnd, DWORD flags, LPVOID lpvoid )
 352 {
 353     DWORD i, dwBpp = 0;
 354     DEVMODEW dm;
 355     BOOL def_mode = TRUE;
 356
 357     TRACE("(%s,%p,%p,0x%08x,%p)\n",debugstr_w(devname),devmode,hwnd,flags,lpvoid);
 358     TRACE("flags=%s\n",_CDS_flags(flags));
 359     if (devmode)
 360     {
 361         TRACE("DM_fields=%s\n",_DM_fields(devmode->dmFields));
 362         TRACE("width=%d height=%d bpp=%d freq=%d (%s)\n",
 363               devmode->dmPelsWidth,devmode->dmPelsHeight,
 364               devmode->dmBitsPerPel,devmode->dmDisplayFrequency, handler_name);
 365
 366         dwBpp = (devmode->dmBitsPerPel == 24) ? 32 : devmode->dmBitsPerPel;
 367         if (devmode->dmFields & DM_BITSPERPEL) def_mode &= !dwBpp;
 368         if (devmode->dmFields & DM_PELSWIDTH)  def_mode &= !devmode->dmPelsWidth;
 369         if (devmode->dmFields & DM_PELSHEIGHT) def_mode &= !devmode->dmPelsHeight;
 370         if (devmode->dmFields & DM_DISPLAYFREQUENCY) def_mode &= !devmode->dmDisplayFrequency;
 371     }
 372
 373     if (def_mode)
 374     {
 375         TRACE("Return to original display mode (%s)\n", handler_name);
 376         if (!X11DRV_EnumDisplaySettingsEx(devname, dd_mode_default, &dm, 0))
 377         {
 378             ERR("Default mode not found!\n");
 379             return DISP_CHANGE_BADMODE;
 380         }
 381         devmode = &dm;
 382     }
 383     dwBpp = !dwBpp ? dd_modes[dd_mode_default].dwBPP : dwBpp;
 384
 385     if ((devmode->dmFields & (DM_PELSWIDTH | DM_PELSHEIGHT)) != (DM_PELSWIDTH | DM_PELSHEIGHT))
 386         return DISP_CHANGE_BADMODE;
 387
 388     for (i = 0; i < dd_mode_count; i++)
 389     {
 390         if (devmode->dmFields & DM_BITSPERPEL)
 391         {
 392             if (dwBpp != dd_modes[i].dwBPP)
 393                 continue;
 394         }
 395         if (devmode->dmFields & DM_PELSWIDTH)
 396         {
 397             if (devmode->dmPelsWidth != dd_modes[i].dwWidth)
 398                 continue;
 399         }
 400         if (devmode->dmFields & DM_PELSHEIGHT)
 401         {
 402             if (devmode->dmPelsHeight != dd_modes[i].dwHeight)
 403                 continue;
 404         }
 405         if ((devmode->dmFields & DM_DISPLAYFREQUENCY) && (dd_modes[i].wRefreshRate != 0) &&
 406             devmode->dmDisplayFrequency != 0)
 407         {
 408             if (devmode->dmDisplayFrequency != dd_modes[i].wRefreshRate)
 409                 continue;
 410         }
 411         /* we have a valid mode */
 412         TRACE("Requested display settings match mode %d (%s)\n", i, handler_name);
 413
 414         if (flags & CDS_UPDATEREGISTRY)
 415             write_registry_settings(devmode);
 416
 417         if (!(flags & (CDS_TEST | CDS_NORESET)))
 418             return pSetCurrentMode(i);
 419         return DISP_CHANGE_SUCCESSFUL;
 420     }
 421
 422     /* no valid modes found */
 423     ERR("No matching mode found(%dx%dx%d)! (%s)\n",
 424         devmode->dmPelsWidth, devmode->dmPelsHeight,
 425         devmode->dmBitsPerPel, handler_name);
 426     return DISP_CHANGE_BADMODE;
 427 }
 428
 429
 430
 431
 432 /***********************************************************************
 433  * DirectDraw HAL interface
 434  *
 435  */
 436 static DWORD PASCAL X11DRV_Settings_SetMode(LPDDHAL_SETMODEDATA data)
 437 {
 438     TRACE("Mode %d requested by DDHAL (%s)\n", data->dwModeIndex, handler_name);
 439     switch (pSetCurrentMode(data->dwModeIndex))
 440     {
 441     case DISP_CHANGE_SUCCESSFUL:
 442         X11DRV_DDHAL_SwitchMode(data->dwModeIndex, NULL, NULL);
 443         data->ddRVal = DD_OK;
 444         break;
 445     case DISP_CHANGE_BADMODE:
 446         data->ddRVal = DDERR_WRONGMODE;
 447         break;
 448     default:
 449         data->ddRVal = DDERR_UNSUPPORTEDMODE;
 450     }
 451     return DDHAL_DRIVER_HANDLED;
 452 }
 453 int X11DRV_Settings_CreateDriver(LPDDHALINFO info)
 454 {
 455     if (!dd_mode_count) return 0; /* no settings defined */
 456
 457     TRACE("Setting up display settings for DDRAW (%s)\n", handler_name);
 458     info->dwNumModes = dd_mode_count;
 459     info->lpModeInfo = dd_modes;
 460     X11DRV_DDHAL_SwitchMode(pGetCurrentMode(), NULL, NULL);
 461     info->lpDDCallbacks->SetMode = X11DRV_Settings_SetMode;
 462     return TRUE;
 463 }