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