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 "x11drv.h"
  25
  26 #include "windef.h"
  27 #include "wingdi.h"
  28 #include "ddrawi.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(x11settings);
  32
  33 /*
  34  * The DDHALMODEINFO type is used to hold all the mode information.
  35  * This is done because the array of DDHALMODEINFO structures must be
  36  * created for use by DirectDraw anyway.
  37  */
  38 static LPDDHALMODEINFO dd_modes = NULL;
  39 static unsigned int dd_mode_count = 0;
  40 static unsigned int dd_max_modes = 0;
  41 static int dd_mode_default = 0;
  42 static const unsigned int depths[]  = {8, 16, 32};
  43
  44 /* pointers to functions that actually do the hard stuff */
  45 static int (*pGetCurrentMode)(void);
  46 static void (*pSetCurrentMode)(int mode);
  47 static const char *handler_name;
  48
  49 /*
  50  * Set the handlers for resolution changing functions
  51  * and initialize the master list of modes
  52  */
  53 LPDDHALMODEINFO X11DRV_Settings_SetHandlers(const char *name,
  54                                  int (*pNewGCM)(void),
  55                                  void (*pNewSCM)(int),
  56                                  unsigned int nmodes,
  57                                  int reserve_depths)
  58 {
  59     handler_name = name;
  60     pGetCurrentMode = pNewGCM;
  61     pSetCurrentMode = pNewSCM;
  62     TRACE("Resolution settings now handled by: %s\n", name);
  63     if (reserve_depths)
  64         /* leave room for other depths */
  65         dd_max_modes = (3+1)*(nmodes);
  66     else
  67         dd_max_modes = nmodes;
  68
  69     if (dd_modes)
  70     {
  71         TRACE("Destroying old display modes array\n");
  72         HeapFree(GetProcessHeap(), 0, dd_modes);
  73     }
  74     dd_modes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DDHALMODEINFO) * dd_max_modes);
  75     dd_mode_count = 0;
  76     TRACE("Initialized new display modes array\n");
  77     return dd_modes;
  78 }
  79
  80 /* Add one mode to the master list */
  81 void X11DRV_Settings_AddOneMode(unsigned int width, unsigned int height, unsigned int bpp, unsigned int freq)
  82 {
  83     LPDDHALMODEINFO info = &(dd_modes[dd_mode_count]);
  84     DWORD dwBpp = screen_depth;
  85     if (dd_mode_count >= dd_max_modes)
  86     {
  87         ERR("Maximum modes (%d) exceeded\n", dd_max_modes);
  88         return;
  89     }
  90     if (dwBpp == 24) dwBpp = 32;
  91     if (bpp == 0) bpp = dwBpp;
  92     info->dwWidth        = width;
  93     info->dwHeight       = height;
  94     info->wRefreshRate   = freq;
  95     info->lPitch         = 0;
  96     info->dwBPP          = bpp;
  97     info->wFlags         = 0;
  98     info->dwRBitMask     = 0;
  99     info->dwGBitMask     = 0;
 100     info->dwBBitMask     = 0;
 101     info->dwAlphaBitMask = 0;
 102     TRACE("initialized mode %d: %dx%dx%d @%d Hz (%s)\n",
 103           dd_mode_count, width, height, bpp, freq, handler_name);
 104     dd_mode_count++;
 105 }
 106
 107 /* copy all the current modes using the other color depths */
 108 void X11DRV_Settings_AddDepthModes(void)
 109 {
 110     int i, j;
 111     int existing_modes = dd_mode_count;
 112     DWORD dwBpp = screen_depth;
 113     if (dwBpp == 24) dwBpp = 32;
 114     for (j=0; j<3; j++)
 115     {
 116         if (depths[j] != dwBpp)
 117         {
 118             for (i=0; i < existing_modes; i++)
 119             {
 120                 X11DRV_Settings_AddOneMode(dd_modes[i].dwWidth, dd_modes[i].dwHeight,
 121                                            depths[j], dd_modes[i].wRefreshRate);
 122             }
 123         }
 124     }
 125 }
 126
 127 /* set the default mode */
 128 void X11DRV_Settings_SetDefaultMode(int mode)
 129 {
 130     dd_mode_default = mode;
 131 }
 132
 133 /* return the number of modes that are initialized */
 134 unsigned int X11DRV_Settings_GetModeCount(void)
 135 {
 136     return dd_mode_count;
 137 }
 138
 139 /***********************************************************************
 140  * Default handlers if resolution switching is not enabled
 141  *
 142  */
 143 static int X11DRV_nores_GetCurrentMode(void)
 144 {
 145     return 0;
 146 }
 147 static void X11DRV_nores_SetCurrentMode(int mode)
 148 {
 149     TRACE("Ignoring mode change request\n");
 150 }
 151 /* default handler only gets the current X desktop resolution */
 152 void X11DRV_Settings_Init(void)
 153 {
 154     X11DRV_Settings_SetHandlers("NoRes",
 155                                 X11DRV_nores_GetCurrentMode,
 156                                 X11DRV_nores_SetCurrentMode,
 157                                 1, 0);
 158     X11DRV_Settings_AddOneMode(screen_width, screen_height, 0, 0);
 159 }
 160
 161 /***********************************************************************
 162  *              EnumDisplaySettingsEx  (X11DRV.@)
 163  *
 164  */
 165 BOOL X11DRV_EnumDisplaySettingsEx( LPCWSTR name, DWORD n, LPDEVMODEW devmode, DWORD flags)
 166 {
 167     DWORD dwBpp = screen_depth;
 168     if (dwBpp == 24) dwBpp = 32;
 169     devmode->dmDisplayFlags = 0;
 170     devmode->dmDisplayFrequency = 0;
 171     devmode->dmSize = sizeof(DEVMODEW);
 172     if (n == ENUM_CURRENT_SETTINGS)
 173     {
 174         TRACE("mode %ld (current) -- getting current mode (%s)\n", n, handler_name);
 175         n = pGetCurrentMode();
 176     }
 177     if (n == ENUM_REGISTRY_SETTINGS)
 178     {
 179         TRACE("mode %ld (registry) -- getting default mode (%s)\n", n, handler_name);
 180         n = dd_mode_default;
 181     }
 182     if (n < dd_mode_count)
 183     {
 184         devmode->dmPelsWidth = dd_modes[n].dwWidth;
 185         devmode->dmPelsHeight = dd_modes[n].dwHeight;
 186         devmode->dmBitsPerPel = dd_modes[n].dwBPP;
 187         devmode->dmDisplayFrequency = dd_modes[n].wRefreshRate;
 188         devmode->dmFields = (DM_PELSWIDTH|DM_PELSHEIGHT|DM_BITSPERPEL);
 189         if (devmode->dmDisplayFrequency)
 190         {
 191             devmode->dmFields |= DM_DISPLAYFREQUENCY;
 192             TRACE("mode %ld -- %ldx%ldx%ldbpp @%ld Hz (%s)\n", n,
 193                   devmode->dmPelsWidth, devmode->dmPelsHeight, devmode->dmBitsPerPel,
 194                   devmode->dmDisplayFrequency, handler_name);
 195         }
 196         else
 197         {
 198             TRACE("mode %ld -- %ldx%ldx%ldbpp (%s)\n", n,
 199                   devmode->dmPelsWidth, devmode->dmPelsHeight, devmode->dmBitsPerPel,
 200                   handler_name);
 201         }
 202         return TRUE;
 203     }
 204     TRACE("mode %ld -- not present (%s)\n", n, handler_name);
 205     return FALSE;
 206 }
 207
 208 #define _X_FIELD(prefix, bits) if ((fields) & prefix##_##bits) {p+=sprintf(p, "%s%s", first ? "" : ",", #bits); first=FALSE;}
 209 static const char * _CDS_flags(DWORD fields)
 210 {
 211     BOOL first = TRUE;
 212     char buf[128];
 213     char *p = buf;
 214     _X_FIELD(CDS,UPDATEREGISTRY);_X_FIELD(CDS,TEST);_X_FIELD(CDS,FULLSCREEN);
 215     _X_FIELD(CDS,GLOBAL);_X_FIELD(CDS,SET_PRIMARY);_X_FIELD(CDS,RESET);
 216     _X_FIELD(CDS,SETRECT);_X_FIELD(CDS,NORESET);
 217     *p = 0;
 218     return wine_dbg_sprintf("%s", buf);
 219 }
 220 static const char * _DM_fields(DWORD fields)
 221 {
 222     BOOL first = TRUE;
 223     char buf[128];
 224     char *p = buf;
 225     _X_FIELD(DM,BITSPERPEL);_X_FIELD(DM,PELSWIDTH);_X_FIELD(DM,PELSHEIGHT);
 226     _X_FIELD(DM,DISPLAYFLAGS);_X_FIELD(DM,DISPLAYFREQUENCY);_X_FIELD(DM,POSITION);
 227     *p = 0;
 228     return wine_dbg_sprintf("%s", buf);
 229 }
 230 #undef _X_FIELD
 231
 232 /***********************************************************************
 233  *              ChangeDisplaySettingsEx  (X11DRV.@)
 234  *
 235  */
 236 LONG X11DRV_ChangeDisplaySettingsEx( LPCWSTR devname, LPDEVMODEW devmode,
 237                                      HWND hwnd, DWORD flags, LPVOID lpvoid )
 238 {
 239     DWORD i, dwBpp = 0;
 240     DEVMODEW dm;
 241     BOOL def_mode = TRUE;
 242
 243     TRACE("(%s,%p,%p,0x%08lx,%p)\n",debugstr_w(devname),devmode,hwnd,flags,lpvoid);
 244     TRACE("flags=%s\n",_CDS_flags(flags));
 245     if (devmode)
 246     {
 247         TRACE("DM_fields=%s\n",_DM_fields(devmode->dmFields));
 248         TRACE("width=%ld height=%ld bpp=%ld freq=%ld (%s)\n",
 249               devmode->dmPelsWidth,devmode->dmPelsHeight,
 250               devmode->dmBitsPerPel,devmode->dmDisplayFrequency, handler_name);
 251
 252         dwBpp = (devmode->dmBitsPerPel == 24) ? 32 : devmode->dmBitsPerPel;
 253         if (devmode->dmFields & DM_BITSPERPEL) def_mode &= !dwBpp;
 254         if (devmode->dmFields & DM_PELSWIDTH)  def_mode &= !devmode->dmPelsWidth;
 255         if (devmode->dmFields & DM_PELSHEIGHT) def_mode &= !devmode->dmPelsHeight;
 256         if (devmode->dmFields & DM_DISPLAYFREQUENCY) def_mode &= !devmode->dmDisplayFrequency;
 257     }
 258
 259     if (def_mode)
 260     {
 261         TRACE("Return to original display mode (%s)\n", handler_name);
 262         if (!X11DRV_EnumDisplaySettingsEx(devname, dd_mode_default, &dm, 0))
 263         {
 264             ERR("Default mode not found!\n");
 265             return DISP_CHANGE_BADMODE;
 266         }
 267         devmode = &dm;
 268     }
 269     dwBpp = !dwBpp ? dd_modes[dd_mode_default].dwBPP : dwBpp;
 270
 271     if ((devmode->dmFields & (DM_PELSWIDTH | DM_PELSHEIGHT)) != (DM_PELSWIDTH | DM_PELSHEIGHT))
 272         return DISP_CHANGE_BADMODE;
 273
 274     for (i = 0; i < dd_mode_count; i++)
 275     {
 276         if (devmode->dmFields & DM_BITSPERPEL)
 277         {
 278             if (dwBpp != dd_modes[i].dwBPP)
 279                 continue;
 280         }
 281         if (devmode->dmFields & DM_PELSWIDTH)
 282         {
 283             if (devmode->dmPelsWidth != dd_modes[i].dwWidth)
 284                 continue;
 285         }
 286         if (devmode->dmFields & DM_PELSHEIGHT)
 287         {
 288             if (devmode->dmPelsHeight != dd_modes[i].dwHeight)
 289                 continue;
 290         }
 291         if ((devmode->dmFields & DM_DISPLAYFREQUENCY) && (dd_modes[i].wRefreshRate != 0) &&
 292             devmode->dmDisplayFrequency != 0)
 293         {
 294             if (devmode->dmDisplayFrequency != dd_modes[i].wRefreshRate)
 295                 continue;
 296         }
 297         /* we have a valid mode */
 298         TRACE("Requested display settings match mode %ld (%s)\n", i, handler_name);
 299         if (!(flags & CDS_TEST))
 300             pSetCurrentMode(i);
 301         return DISP_CHANGE_SUCCESSFUL;
 302     }
 303
 304     /* no valid modes found */
 305     ERR("No matching mode found! (%s)\n", handler_name);
 306     return DISP_CHANGE_BADMODE;
 307 }
 308
 309
 310
 311
 312 /***********************************************************************
 313  * DirectDraw HAL interface
 314  *
 315  */
 316 static DWORD PASCAL X11DRV_Settings_SetMode(LPDDHAL_SETMODEDATA data)
 317 {
 318     TRACE("Mode %ld requested by DDHAL (%s)\n", data->dwModeIndex, handler_name);
 319     pSetCurrentMode(data->dwModeIndex);
 320     X11DRV_DDHAL_SwitchMode(data->dwModeIndex, NULL, NULL);
 321     data->ddRVal = DD_OK;
 322     return DDHAL_DRIVER_HANDLED;
 323 }
 324 int X11DRV_Settings_CreateDriver(LPDDHALINFO info)
 325 {
 326     if (!dd_mode_count) return 0; /* no settings defined */
 327
 328     TRACE("Setting up display settings for DDRAW (%s)\n", handler_name);
 329     info->dwNumModes = dd_mode_count;
 330     info->lpModeInfo = dd_modes;
 331     X11DRV_DDHAL_SwitchMode(pGetCurrentMode(), NULL, NULL);
 332     info->lpDDCallbacks->SetMode = X11DRV_Settings_SetMode;
 333     return TRUE;
 334 }