winex11.drv: X11DRV_XF86VM_SetExclusiveMode() is unused so remove it.
[wine] / 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 /* All Windows drivers seen so far either support 32 bit depths, or 24 bit depths, but never both. So if we have
48  * a 32 bit framebuffer, report 32 bit bpps, otherwise 24 bit ones.
49  */
50 static const unsigned int depths_24[]  = {8, 16, 24};
51 static const unsigned int depths_32[]  = {8, 16, 32};
52
53 /* pointers to functions that actually do the hard stuff */
54 static int (*pGetCurrentMode)(void);
55 static LONG (*pSetCurrentMode)(int mode);
56 static const char *handler_name;
57
58 /*
59  * Set the handlers for resolution changing functions
60  * and initialize the master list of modes
61  */
62 LPDDHALMODEINFO X11DRV_Settings_SetHandlers(const char *name,
63                                  int (*pNewGCM)(void),
64                                  LONG (*pNewSCM)(int),
65                                  unsigned int nmodes,
66                                  int reserve_depths)
67 {
68     handler_name = name;
69     pGetCurrentMode = pNewGCM;
70     pSetCurrentMode = pNewSCM;
71     TRACE("Resolution settings now handled by: %s\n", name);
72     if (reserve_depths)
73         /* leave room for other depths */
74         dd_max_modes = (3+1)*(nmodes);
75     else 
76         dd_max_modes = nmodes;
77
78     if (dd_modes) 
79     {
80         TRACE("Destroying old display modes array\n");
81         HeapFree(GetProcessHeap(), 0, dd_modes);
82     }
83     dd_modes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DDHALMODEINFO) * dd_max_modes);
84     dd_mode_count = 0;
85     TRACE("Initialized new display modes array\n");
86     return dd_modes;
87 }
88
89 /* Add one mode to the master list */
90 void X11DRV_Settings_AddOneMode(unsigned int width, unsigned int height, unsigned int bpp, unsigned int freq)
91 {
92     LPDDHALMODEINFO info = &(dd_modes[dd_mode_count]);
93     DWORD dwBpp = screen_bpp;
94     if (dd_mode_count >= dd_max_modes)
95     {
96         ERR("Maximum modes (%d) exceeded\n", dd_max_modes);
97         return;
98     }
99     if (bpp == 0) bpp = dwBpp;
100     info->dwWidth        = width;
101     info->dwHeight       = height;
102     info->wRefreshRate   = freq;
103     info->lPitch         = 0;
104     info->dwBPP          = bpp;
105     info->wFlags         = 0;
106     info->dwRBitMask     = 0;
107     info->dwGBitMask     = 0;
108     info->dwBBitMask     = 0;
109     info->dwAlphaBitMask = 0;
110     TRACE("initialized mode %d: %dx%dx%d @%d Hz (%s)\n", 
111           dd_mode_count, width, height, bpp, freq, handler_name);
112     dd_mode_count++;
113 }
114
115 /* copy all the current modes using the other color depths */
116 void X11DRV_Settings_AddDepthModes(void)
117 {
118     int i, j;
119     int existing_modes = dd_mode_count;
120     DWORD dwBpp = screen_bpp;
121     const DWORD *depths = screen_bpp == 32 ? depths_32 : depths_24;
122
123     for (j=0; j<3; j++)
124     {
125         if (depths[j] != dwBpp)
126         {
127             for (i=0; i < existing_modes; i++)
128             {
129                 X11DRV_Settings_AddOneMode(dd_modes[i].dwWidth, dd_modes[i].dwHeight, 
130                                            depths[j], dd_modes[i].wRefreshRate);
131             }
132         }
133     }
134 }
135
136 /* return the number of modes that are initialized */
137 unsigned int X11DRV_Settings_GetModeCount(void)
138 {
139     return dd_mode_count;
140 }
141
142 /***********************************************************************
143  * Default handlers if resolution switching is not enabled
144  *
145  */
146 static int X11DRV_nores_GetCurrentMode(void)
147 {
148     return 0;
149 }
150
151 static LONG X11DRV_nores_SetCurrentMode(int mode)
152 {
153     TRACE("Ignoring mode change request\n");
154     return DISP_CHANGE_FAILED;
155 }
156
157 /* default handler only gets the current X desktop resolution */
158 void X11DRV_Settings_Init(void)
159 {
160     X11DRV_Settings_SetHandlers("NoRes", 
161                                 X11DRV_nores_GetCurrentMode, 
162                                 X11DRV_nores_SetCurrentMode, 
163                                 1, 0);
164     X11DRV_Settings_AddOneMode(screen_width, screen_height, 0, 60);
165 }
166
167 static BOOL get_display_device_reg_key(char *key, unsigned len)
168 {
169     static const char display_device_guid_prop[] = "__wine_display_device_guid";
170     static const char video_path[] = "System\\CurrentControlSet\\Control\\Video\\{";
171     static const char display0[] = "}\\0000";
172     ATOM guid_atom;
173
174     assert(len >= sizeof(video_path) + sizeof(display0) + 40);
175
176     guid_atom = HandleToULong(GetPropA(GetDesktopWindow(), display_device_guid_prop));
177     if (!guid_atom) return FALSE;
178
179     memcpy(key, video_path, sizeof(video_path));
180
181     if (!GlobalGetAtomNameA(guid_atom, key + strlen(key), 40))
182         return FALSE;
183
184     strcat(key, display0);
185
186     TRACE("display device key %s\n", wine_dbgstr_a(key));
187     return TRUE;
188 }
189
190 static BOOL read_registry_settings(DEVMODEW *dm)
191 {
192     char wine_x11_reg_key[128];
193     HKEY hkey;
194     DWORD type, size;
195     BOOL ret = TRUE;
196
197     dm->dmFields = 0;
198
199     if (!get_display_device_reg_key(wine_x11_reg_key, sizeof(wine_x11_reg_key)))
200         return FALSE;
201
202     if (RegOpenKeyExA(HKEY_CURRENT_CONFIG, wine_x11_reg_key, 0, KEY_READ, &hkey))
203         return FALSE;
204
205 #define query_value(name, data) \
206     size = sizeof(DWORD); \
207     if (RegQueryValueExA(hkey, name, 0, &type, (LPBYTE)(data), &size) || \
208         type != REG_DWORD || size != sizeof(DWORD)) \
209         ret = FALSE
210
211     query_value("DefaultSettings.BitsPerPel", &dm->dmBitsPerPel);
212     dm->dmFields |= DM_BITSPERPEL;
213     query_value("DefaultSettings.XResolution", &dm->dmPelsWidth);
214     dm->dmFields |= DM_PELSWIDTH;
215     query_value("DefaultSettings.YResolution", &dm->dmPelsHeight);
216     dm->dmFields |= DM_PELSHEIGHT;
217     query_value("DefaultSettings.VRefresh", &dm->dmDisplayFrequency);
218     dm->dmFields |= DM_DISPLAYFREQUENCY;
219     query_value("DefaultSettings.Flags", &dm->u2.dmDisplayFlags);
220     dm->dmFields |= DM_DISPLAYFLAGS;
221     query_value("DefaultSettings.XPanning", &dm->u1.s2.dmPosition.x);
222     query_value("DefaultSettings.YPanning", &dm->u1.s2.dmPosition.y);
223     query_value("DefaultSettings.Orientation", &dm->u1.s2.dmDisplayOrientation);
224     query_value("DefaultSettings.FixedOutput", &dm->u1.s2.dmDisplayFixedOutput);
225
226 #undef query_value
227
228     RegCloseKey(hkey);
229     return ret;
230 }
231
232 static BOOL write_registry_settings(const DEVMODEW *dm)
233 {
234     char wine_x11_reg_key[128];
235     HKEY hkey;
236     BOOL ret = TRUE;
237
238     if (!get_display_device_reg_key(wine_x11_reg_key, sizeof(wine_x11_reg_key)))
239         return FALSE;
240
241     if (RegCreateKeyExA(HKEY_CURRENT_CONFIG, wine_x11_reg_key, 0, NULL,
242                         REG_OPTION_VOLATILE, KEY_WRITE, NULL, &hkey, NULL))
243         return FALSE;
244
245 #define set_value(name, data) \
246     if (RegSetValueExA(hkey, name, 0, REG_DWORD, (LPBYTE)(data), sizeof(DWORD))) \
247         ret = FALSE
248
249     set_value("DefaultSettings.BitsPerPel", &dm->dmBitsPerPel);
250     set_value("DefaultSettings.XResolution", &dm->dmPelsWidth);
251     set_value("DefaultSettings.YResolution", &dm->dmPelsHeight);
252     set_value("DefaultSettings.VRefresh", &dm->dmDisplayFrequency);
253     set_value("DefaultSettings.Flags", &dm->u2.dmDisplayFlags);
254     set_value("DefaultSettings.XPanning", &dm->u1.s2.dmPosition.x);
255     set_value("DefaultSettings.YPanning", &dm->u1.s2.dmPosition.y);
256     set_value("DefaultSettings.Orientation", &dm->u1.s2.dmDisplayOrientation);
257     set_value("DefaultSettings.FixedOutput", &dm->u1.s2.dmDisplayFixedOutput);
258
259 #undef set_value
260
261     RegCloseKey(hkey);
262     return ret;
263 }
264
265 /***********************************************************************
266  *              EnumDisplaySettingsEx  (X11DRV.@)
267  *
268  */
269 BOOL CDECL X11DRV_EnumDisplaySettingsEx( LPCWSTR name, DWORD n, LPDEVMODEW devmode, DWORD flags)
270 {
271     static const WCHAR dev_name[CCHDEVICENAME] =
272         { 'W','i','n','e',' ','X','1','1',' ','d','r','i','v','e','r',0 };
273
274     devmode->dmSize = FIELD_OFFSET(DEVMODEW, dmICMMethod);
275     devmode->dmSpecVersion = DM_SPECVERSION;
276     devmode->dmDriverVersion = DM_SPECVERSION;
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                             DM_DISPLAYFLAGS;
304         if (devmode->dmDisplayFrequency)
305         {
306             devmode->dmFields |= DM_DISPLAYFREQUENCY;
307             TRACE("mode %d -- %dx%dx%dbpp @%d Hz (%s)\n", n,
308                   devmode->dmPelsWidth, devmode->dmPelsHeight, devmode->dmBitsPerPel,
309                   devmode->dmDisplayFrequency, handler_name);
310         }
311         else
312         {
313             TRACE("mode %d -- %dx%dx%dbpp (%s)\n", n,
314                   devmode->dmPelsWidth, devmode->dmPelsHeight, devmode->dmBitsPerPel, 
315                   handler_name);
316         }
317         return TRUE;
318     }
319     TRACE("mode %d -- not present (%s)\n", n, handler_name);
320     SetLastError(ERROR_NO_MORE_FILES);
321     return FALSE;
322 }
323
324 #define _X_FIELD(prefix, bits) if ((fields) & prefix##_##bits) {p+=sprintf(p, "%s%s", first ? "" : ",", #bits); first=FALSE;}
325 static const char * _CDS_flags(DWORD fields)
326 {
327     BOOL first = TRUE;
328     char buf[128];
329     char *p = buf;
330     _X_FIELD(CDS,UPDATEREGISTRY);_X_FIELD(CDS,TEST);_X_FIELD(CDS,FULLSCREEN);
331     _X_FIELD(CDS,GLOBAL);_X_FIELD(CDS,SET_PRIMARY);_X_FIELD(CDS,RESET);
332     _X_FIELD(CDS,SETRECT);_X_FIELD(CDS,NORESET);
333     *p = 0;
334     return wine_dbg_sprintf("%s", buf);
335 }
336 static const char * _DM_fields(DWORD fields)
337 {
338     BOOL first = TRUE;
339     char buf[128];
340     char *p = buf;
341     _X_FIELD(DM,BITSPERPEL);_X_FIELD(DM,PELSWIDTH);_X_FIELD(DM,PELSHEIGHT);
342     _X_FIELD(DM,DISPLAYFLAGS);_X_FIELD(DM,DISPLAYFREQUENCY);_X_FIELD(DM,POSITION);
343     *p = 0;
344     return wine_dbg_sprintf("%s", buf);
345 }
346 #undef _X_FIELD
347
348 /***********************************************************************
349  *              ChangeDisplaySettingsEx  (X11DRV.@)
350  *
351  */
352 LONG CDECL X11DRV_ChangeDisplaySettingsEx( LPCWSTR devname, LPDEVMODEW devmode,
353                                            HWND hwnd, DWORD flags, LPVOID lpvoid )
354 {
355     DWORD i, dwBpp = 0;
356     DEVMODEW dm;
357     BOOL def_mode = TRUE;
358
359     TRACE("(%s,%p,%p,0x%08x,%p)\n",debugstr_w(devname),devmode,hwnd,flags,lpvoid);
360     TRACE("flags=%s\n",_CDS_flags(flags));
361     if (devmode)
362     {
363         /* this is the minimal dmSize that XP accepts */
364         if (devmode->dmSize < FIELD_OFFSET(DEVMODEW, dmFields))
365             return DISP_CHANGE_FAILED;
366
367         TRACE("DM_fields=%s\n",_DM_fields(devmode->dmFields));
368         TRACE("width=%d height=%d bpp=%d freq=%d (%s)\n",
369               devmode->dmPelsWidth,devmode->dmPelsHeight,
370               devmode->dmBitsPerPel,devmode->dmDisplayFrequency, handler_name);
371
372         dwBpp = devmode->dmBitsPerPel;
373         if (devmode->dmFields & DM_BITSPERPEL) def_mode &= !dwBpp;
374         if (devmode->dmFields & DM_PELSWIDTH)  def_mode &= !devmode->dmPelsWidth;
375         if (devmode->dmFields & DM_PELSHEIGHT) def_mode &= !devmode->dmPelsHeight;
376         if (devmode->dmFields & DM_DISPLAYFREQUENCY) def_mode &= !devmode->dmDisplayFrequency;
377     }
378
379     if (def_mode || !dwBpp)
380     {
381         if (!X11DRV_EnumDisplaySettingsEx(devname, ENUM_REGISTRY_SETTINGS, &dm, 0))
382         {
383             ERR("Default mode not found!\n");
384             return DISP_CHANGE_BADMODE;
385         }
386         if (def_mode)
387         {
388             TRACE("Return to original display mode (%s)\n", handler_name);
389             devmode = &dm;
390         }
391         dwBpp = dm.dmBitsPerPel;
392     }
393
394     if ((devmode->dmFields & (DM_PELSWIDTH | DM_PELSHEIGHT)) != (DM_PELSWIDTH | DM_PELSHEIGHT))
395     {
396         WARN("devmode doesn't specify the resolution: %04x\n", devmode->dmFields);
397         return DISP_CHANGE_BADMODE;
398     }
399
400     for (i = 0; i < dd_mode_count; i++)
401     {
402         if (devmode->dmFields & DM_BITSPERPEL)
403         {
404             if (dwBpp != dd_modes[i].dwBPP)
405                 continue;
406         }
407         if (devmode->dmFields & DM_PELSWIDTH)
408         {
409             if (devmode->dmPelsWidth != dd_modes[i].dwWidth)
410                 continue;
411         }
412         if (devmode->dmFields & DM_PELSHEIGHT)
413         {
414             if (devmode->dmPelsHeight != dd_modes[i].dwHeight)
415                 continue;
416         }
417         if ((devmode->dmFields & DM_DISPLAYFREQUENCY) && (dd_modes[i].wRefreshRate != 0) &&
418             devmode->dmDisplayFrequency != 0)
419         {
420             if (devmode->dmDisplayFrequency != dd_modes[i].wRefreshRate)
421                 continue;
422         }
423         /* we have a valid mode */
424         TRACE("Requested display settings match mode %d (%s)\n", i, handler_name);
425
426         if (flags & CDS_UPDATEREGISTRY)
427             write_registry_settings(devmode);
428
429         if (!(flags & (CDS_TEST | CDS_NORESET)))
430             return pSetCurrentMode(i);
431
432         return DISP_CHANGE_SUCCESSFUL;
433     }
434
435     /* no valid modes found */
436     ERR("No matching mode found %ux%ux%u @%u! (%s)\n",
437         devmode->dmPelsWidth, devmode->dmPelsHeight,
438         devmode->dmBitsPerPel, devmode->dmDisplayFrequency, handler_name);
439     return DISP_CHANGE_BADMODE;
440 }
441
442
443
444
445 /***********************************************************************
446  * DirectDraw HAL interface
447  *
448  */
449 static DWORD PASCAL X11DRV_Settings_SetMode(LPDDHAL_SETMODEDATA data)
450 {
451     TRACE("Mode %d requested by DDHAL (%s)\n", data->dwModeIndex, handler_name);
452     switch (pSetCurrentMode(data->dwModeIndex))
453     {
454     case DISP_CHANGE_SUCCESSFUL:
455         X11DRV_DDHAL_SwitchMode(data->dwModeIndex, NULL, NULL);
456         data->ddRVal = DD_OK;
457         break;
458     case DISP_CHANGE_BADMODE:
459         data->ddRVal = DDERR_WRONGMODE;
460         break;
461     default:
462         data->ddRVal = DDERR_UNSUPPORTEDMODE;
463     }
464     return DDHAL_DRIVER_HANDLED;
465 }
466 int X11DRV_Settings_CreateDriver(LPDDHALINFO info)
467 {
468     if (!dd_mode_count) return 0; /* no settings defined */
469
470     TRACE("Setting up display settings for DDRAW (%s)\n", handler_name);
471     info->dwNumModes = dd_mode_count;
472     info->lpModeInfo = dd_modes;
473     X11DRV_DDHAL_SwitchMode(pGetCurrentMode(), NULL, NULL);
474     info->lpDDCallbacks->SetMode = X11DRV_Settings_SetMode;
475     return TRUE;
476 }