?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 149f0a5527ac85057a8ef03858d34d91c36f97e8
[wine/hacks.git] / dlls / user32 / sysparams.c
blobc6cb4940e8a2529ba868a2da67582d3f08f93d17
1 /*
2 * System parameters functions
3 *
4 * Copyright 1994 Alexandre Julliard
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
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #define NONAMELESSUNION
30 #define NONAMELESSSTRUCT
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winnls.h"
35 #include "wingdi.h"
36 #include "winreg.h"
37 #include "wine/winuser16.h"
38 #include "winerror.h"
39
40 #include "controls.h"
41 #include "user_private.h"
42 #include "wine/unicode.h"
43 #include "wine/debug.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(system);
46
47 /* System parameter indexes */
48 enum spi_index
49 {
50 SPI_SETBEEP_IDX,
51 SPI_SETMOUSE_IDX,
52 SPI_SETBORDER_IDX,
53 SPI_SETKEYBOARDSPEED_IDX,
54 SPI_ICONHORIZONTALSPACING_IDX,
55 SPI_SETSCREENSAVETIMEOUT_IDX,
56 SPI_SETGRIDGRANULARITY_IDX,
57 SPI_SETKEYBOARDDELAY_IDX,
58 SPI_ICONVERTICALSPACING_IDX,
59 SPI_SETICONTITLEWRAP_IDX,
60 SPI_SETMENUDROPALIGNMENT_IDX,
61 SPI_SETDOUBLECLKWIDTH_IDX,
62 SPI_SETDOUBLECLKHEIGHT_IDX,
63 SPI_SETDOUBLECLICKTIME_IDX,
64 SPI_SETMOUSEBUTTONSWAP_IDX,
65 SPI_SETDRAGFULLWINDOWS_IDX,
66 SPI_SETWORKAREA_IDX,
67 SPI_SETSHOWSOUNDS_IDX,
68 SPI_SETKEYBOARDPREF_IDX,
69 SPI_SETSCREENREADER_IDX,
70 SPI_SETSCREENSAVERRUNNING_IDX,
71 SPI_SETFONTSMOOTHING_IDX,
72 SPI_SETLISTBOXSMOOTHSCROLLING_IDX,
73 SPI_SETMOUSEHOVERWIDTH_IDX,
74 SPI_SETMOUSEHOVERHEIGHT_IDX,
75 SPI_SETMOUSEHOVERTIME_IDX,
76 SPI_SETMOUSESCROLLCHARS_IDX,
77 SPI_SETMOUSESCROLLLINES_IDX,
78 SPI_SETMENUSHOWDELAY_IDX,
79 SPI_SETICONTITLELOGFONT_IDX,
80 SPI_SETLOWPOWERACTIVE_IDX,
81 SPI_SETSNAPTODEFBUTTON_IDX,
82 SPI_SETPOWEROFFACTIVE_IDX,
83 SPI_USERPREFERENCEMASK_IDX,
84 SPI_NONCLIENTMETRICS_IDX,
85 SPI_MINIMIZEDMETRICS_IDX,
86 SPI_SETFOREGROUNDLOCKTIMEOUT_IDX,
87 SPI_CARETWIDTH_IDX,
88 SPI_SETMOUSESPEED_IDX,
89 SPI_SETFONTSMOOTHINGTYPE_IDX,
90 SPI_SETFONTSMOOTHINGCONTRAST_IDX,
91 SPI_SETFONTSMOOTHINGORIENTATION_IDX,
92 SPI_INDEX_COUNT
93 };
94
95 static const char * const DefSysColors[] =
96 {
97 "Scrollbar", "212 208 200", /* COLOR_SCROLLBAR */
98 "Background", "58 110 165", /* COLOR_BACKGROUND */
99 "ActiveTitle", "10 36 106", /* COLOR_ACTIVECAPTION */
100 "InactiveTitle", "128 128 128", /* COLOR_INACTIVECAPTION */
101 "Menu", "212 208 200", /* COLOR_MENU */
102 "Window", "255 255 255", /* COLOR_WINDOW */
103 "WindowFrame", "0 0 0", /* COLOR_WINDOWFRAME */
104 "MenuText", "0 0 0", /* COLOR_MENUTEXT */
105 "WindowText", "0 0 0", /* COLOR_WINDOWTEXT */
106 "TitleText", "255 255 255", /* COLOR_CAPTIONTEXT */
107 "ActiveBorder", "212 208 200", /* COLOR_ACTIVEBORDER */
108 "InactiveBorder", "212 208 200", /* COLOR_INACTIVEBORDER */
109 "AppWorkSpace", "128 128 128", /* COLOR_APPWORKSPACE */
110 "Hilight", "10 36 106", /* COLOR_HIGHLIGHT */
111 "HilightText", "255 255 255", /* COLOR_HIGHLIGHTTEXT */
112 "ButtonFace", "212 208 200", /* COLOR_BTNFACE */
113 "ButtonShadow", "128 128 128", /* COLOR_BTNSHADOW */
114 "GrayText", "128 128 128", /* COLOR_GRAYTEXT */
115 "ButtonText", "0 0 0", /* COLOR_BTNTEXT */
116 "InactiveTitleText", "212 208 200", /* COLOR_INACTIVECAPTIONTEXT */
117 "ButtonHilight", "255 255 255", /* COLOR_BTNHIGHLIGHT */
118 "ButtonDkShadow", "64 64 64", /* COLOR_3DDKSHADOW */
119 "ButtonLight", "212 208 200", /* COLOR_3DLIGHT */
120 "InfoText", "0 0 0", /* COLOR_INFOTEXT */
121 "InfoWindow", "255 255 225", /* COLOR_INFOBK */
122 "ButtonAlternateFace", "181 181 181", /* COLOR_ALTERNATEBTNFACE */
123 "HotTrackingColor", "0 0 128", /* COLOR_HOTLIGHT */
124 "GradientActiveTitle", "166 202 240", /* COLOR_GRADIENTACTIVECAPTION */
125 "GradientInactiveTitle", "192 192 192", /* COLOR_GRADIENTINACTIVECAPTION */
126 "MenuHilight", "10 36 106", /* COLOR_MENUHILIGHT */
127 "MenuBar", "212 208 200" /* COLOR_MENUBAR */
128 };
129
130 /**
131 * Names of the registry subkeys of HKEY_CURRENT_USER key and value names
132 * for the system parameters.
133 * Names of the keys are created by adding string "_REGKEY" to
134 * "SET" action names, value names are created by adding "_REG_NAME"
135 * to the "SET" action name.
136 */
137 static const WCHAR SPI_SETBEEP_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','S','o','u','n','d',0};
138 static const WCHAR SPI_SETBEEP_VALNAME[]= {'B','e','e','p',0};
139 static const WCHAR SPI_SETMOUSE_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
140 static const WCHAR SPI_SETMOUSE_VALNAME1[]= {'M','o','u','s','e','T','h','r','e','s','h','o','l','d','1',0};
141 static const WCHAR SPI_SETMOUSE_VALNAME2[]= {'M','o','u','s','e','T','h','r','e','s','h','o','l','d','2',0};
142 static const WCHAR SPI_SETMOUSE_VALNAME3[]= {'M','o','u','s','e','S','p','e','e','d',0};
143 static const WCHAR SPI_SETBORDER_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
144 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
145 static const WCHAR SPI_SETBORDER_VALNAME[]= {'B','o','r','d','e','r','W','i','d','t','h',0};
146 static const WCHAR SPI_SETKEYBOARDSPEED_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','K','e','y','b','o','a','r','d',0};
147 static const WCHAR SPI_SETKEYBOARDSPEED_VALNAME[]= {'K','e','y','b','o','a','r','d','S','p','e','e','d',0};
148 static const WCHAR SPI_ICONHORIZONTALSPACING_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
149 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
150 static const WCHAR SPI_ICONHORIZONTALSPACING_VALNAME[]= {'I','c','o','n','S','p','a','c','i','n','g',0};
151 static const WCHAR SPI_SETSCREENSAVETIMEOUT_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
152 static const WCHAR SPI_SETSCREENSAVETIMEOUT_VALNAME[]= {'S','c','r','e','e','n','S','a','v','e','T','i','m','e','O','u','t',0};
153 static const WCHAR SPI_SETSCREENSAVEACTIVE_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
154 static const WCHAR SPI_SETSCREENSAVEACTIVE_VALNAME[]= {'S','c','r','e','e','n','S','a','v','e','A','c','t','i','v','e',0};
155 static const WCHAR SPI_SETGRIDGRANULARITY_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
156 static const WCHAR SPI_SETGRIDGRANULARITY_VALNAME[]= {'G','r','i','d','G','r','a','n','u','l','a','r','i','t','y',0};
157 static const WCHAR SPI_SETKEYBOARDDELAY_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','K','e','y','b','o','a','r','d',0};
158 static const WCHAR SPI_SETKEYBOARDDELAY_VALNAME[]= {'K','e','y','b','o','a','r','d','D','e','l','a','y',0};
159 static const WCHAR SPI_ICONVERTICALSPACING_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
160 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
161 static const WCHAR SPI_ICONVERTICALSPACING_VALNAME[]= {'I','c','o','n','V','e','r','t','i','c','a','l','S','p','a','c','i','n','g',0};
162 static const WCHAR SPI_SETICONTITLEWRAP_REGKEY1[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
163 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
164 static const WCHAR SPI_SETICONTITLEWRAP_REGKEY2[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
165 static const WCHAR SPI_SETICONTITLEWRAP_VALNAME[]= {'I','c','o','n','T','i','t','l','e','W','r','a','p',0};
166 static const WCHAR SPI_SETICONTITLELOGFONT_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
167 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
168 static const WCHAR SPI_SETICONTITLELOGFONT_VALNAME[]= {'I','c','o','n','F','o','n','t',0};
169 static const WCHAR SPI_SETMENUDROPALIGNMENT_REGKEY1[]= {'S','o','f','t','w','a','r','e','\\',
170 'M','i','c','r','o','s','o','f','t','\\',
171 'W','i','n','d','o','w','s',' ','N','T','\\',
172 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
173 'W','i','n','d','o','w','s',0};
174 static const WCHAR SPI_SETMENUDROPALIGNMENT_REGKEY2[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
175 static const WCHAR SPI_SETMENUDROPALIGNMENT_VALNAME[]= {'M','e','n','u','D','r','o','p','A','l','i','g','n','m','e','n','t',0};
176 static const WCHAR SPI_SETSNAPTODEFBUTTON_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
177 static const WCHAR SPI_SETSNAPTODEFBUTTON_VALNAME[]= {'S','n','a','p','T','o','D','e','f','a','u','l','t','B','u','t','t','o','n',0};
178 static const WCHAR SPI_SETDOUBLECLKWIDTH_REGKEY1[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
179 static const WCHAR SPI_SETDOUBLECLKWIDTH_REGKEY2[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
180 static const WCHAR SPI_SETDOUBLECLKWIDTH_VALNAME[]= {'D','o','u','b','l','e','C','l','i','c','k','W','i','d','t','h',0};
181 static const WCHAR SPI_SETDOUBLECLKHEIGHT_REGKEY1[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
182 static const WCHAR SPI_SETDOUBLECLKHEIGHT_REGKEY2[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
183 static const WCHAR SPI_SETDOUBLECLKHEIGHT_VALNAME[]= {'D','o','u','b','l','e','C','l','i','c','k','H','e','i','g','h','t',0};
184 static const WCHAR SPI_SETDOUBLECLICKTIME_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
185 static const WCHAR SPI_SETDOUBLECLICKTIME_VALNAME[]= {'D','o','u','b','l','e','C','l','i','c','k','S','p','e','e','d',0};
186 static const WCHAR SPI_SETMOUSEBUTTONSWAP_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
187 static const WCHAR SPI_SETMOUSEBUTTONSWAP_VALNAME[]= {'S','w','a','p','M','o','u','s','e','B','u','t','t','o','n','s',0};
188 static const WCHAR SPI_SETDRAGFULLWINDOWS_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
189 static const WCHAR SPI_SETDRAGFULLWINDOWS_VALNAME[]= {'D','r','a','g','F','u','l','l','W','i','n','d','o','w','s',0};
190 static const WCHAR SPI_SETSHOWSOUNDS_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
191 'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
192 'S','h','o','w','S','o','u','n','d','s',0};
193 static const WCHAR SPI_SETSHOWSOUNDS_VALNAME[]= {'O','n',0};
194 static const WCHAR SPI_SETKEYBOARDPREF_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
195 'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
196 'K','e','y','b','o','a','r','d',' ','P','r','e','f','e','r','e','n','c','e',0};
197 static const WCHAR SPI_SETKEYBOARDPREF_VALNAME[]= {'O','n',0};
198 static const WCHAR SPI_SETSCREENREADER_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
199 'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
200 'B','l','i','n','d',' ','A','c','c','e','s','s',0};
201 static const WCHAR SPI_SETSCREENREADER_VALNAME[]= {'O','n',0};
202 static const WCHAR SPI_SETDESKWALLPAPER_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
203 static const WCHAR SPI_SETDESKWALLPAPER_VALNAME[]= {'W','a','l','l','p','a','p','e','r',0};
204 static const WCHAR SPI_SETFONTSMOOTHING_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
205 static const WCHAR SPI_SETFONTSMOOTHING_VALNAME[]= {'F','o','n','t','S','m','o','o','t','h','i','n','g',0};
206 static const WCHAR SPI_SETLOWPOWERACTIVE_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
207 static const WCHAR SPI_SETLOWPOWERACTIVE_VALNAME[]= {'L','o','w','P','o','w','e','r','A','c','t','i','v','e',0};
208 static const WCHAR SPI_SETPOWEROFFACTIVE_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
209 static const WCHAR SPI_SETPOWEROFFACTIVE_VALNAME[]= {'P','o','w','e','r','O','f','f','A','c','t','i','v','e',0};
210 static const WCHAR SPI_USERPREFERENCEMASK_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
211 static const WCHAR SPI_USERPREFERENCEMASK_VALNAME[]= {'U','s','e','r','P','r','e','f','e','r','e','n','c','e','m','a','s','k',0};
212 static const WCHAR SPI_SETMOUSEHOVERWIDTH_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
213 static const WCHAR SPI_SETMOUSEHOVERWIDTH_VALNAME[]= {'M','o','u','s','e','H','o','v','e','r','W','i','d','t','h',0};
214 static const WCHAR SPI_SETMOUSEHOVERHEIGHT_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
215 static const WCHAR SPI_SETMOUSEHOVERHEIGHT_VALNAME[]= {'M','o','u','s','e','H','o','v','e','r','H','e','i','g','h','t',0};
216 static const WCHAR SPI_SETMOUSEHOVERTIME_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
217 static const WCHAR SPI_SETMOUSEHOVERTIME_VALNAME[]= {'M','o','u','s','e','H','o','v','e','r','T','i','m','e',0};
218 static const WCHAR SPI_SETMOUSESCROLLCHARS_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
219 static const WCHAR SPI_SETMOUSESCROLLCHARS_VALNAME[]= {'W','h','e','e','l','S','c','r','o','l','l','C','h','a','r','s',0};
220 static const WCHAR SPI_SETMOUSESCROLLLINES_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
221 static const WCHAR SPI_SETMOUSESCROLLLINES_VALNAME[]= {'W','h','e','e','l','S','c','r','o','l','l','L','i','n','e','s',0};
222 static const WCHAR SPI_SETMENUSHOWDELAY_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
223 static const WCHAR SPI_SETMENUSHOWDELAY_VALNAME[]= {'M','e','n','u','S','h','o','w','D','e','l','a','y',0};
224 static const WCHAR SPI_SETFOREGROUNDLOCKTIMEOUT_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
225 static const WCHAR SPI_SETFOREGROUNDLOCKTIMEOUT_VALNAME[]= {'F','o','r','e','g','r','o','u','n','d','L','o','c','k','T','i','m','e','o','u','t',0};
226 static const WCHAR SPI_CARETWIDTH_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
227 static const WCHAR SPI_CARETWIDTH_VALNAME[]= {'C','a','r','e','t','W','i','d','t','h',0};
228 static const WCHAR SPI_SETMOUSESPEED_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
229 static const WCHAR SPI_SETMOUSESPEED_VALNAME[]= {'M','o','u','s','e','S','e','n','s','i','t','i','v','i','t','y',0};
230 static const WCHAR SPI_SETFONTSMOOTHINGTYPE_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
231 static const WCHAR SPI_SETFONTSMOOTHINGTYPE_VALNAME[]= {'F','o','n','t','S','m','o','o','t','h','i','n','g','T','y','p','e',0};
232 static const WCHAR SPI_SETFONTSMOOTHINGCONTRAST_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
233 static const WCHAR SPI_SETFONTSMOOTHINGCONTRAST_VALNAME[]= {'F','o','n','t','S','m','o','o','t','h','i','n','g','G','a','m','m','a',0};
234 static const WCHAR SPI_SETFONTSMOOTHINGORIENTATION_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
235 static const WCHAR SPI_SETFONTSMOOTHINGORIENTATION_VALNAME[]= {'F','o','n','t','S','m','o','o','t','h','i','n','g','O','r','i','e','n','t','a','t','i','o','n',0};
236
237 /* FIXME - real values */
238 static const WCHAR SPI_SETSCREENSAVERRUNNING_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
239 static const WCHAR SPI_SETSCREENSAVERRUNNING_VALNAME[]= {'W','I','N','E','_','S','c','r','e','e','n','S','a','v','e','r','R','u','n','n','i','n','g',0};
240
241 static const WCHAR METRICS_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
242 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
243 static const WCHAR METRICS_SCROLLWIDTH_VALNAME[]= {'S','c','r','o','l','l','W','i','d','t','h',0};
244 static const WCHAR METRICS_SCROLLHEIGHT_VALNAME[]= {'S','c','r','o','l','l','H','e','i','g','h','t',0};
245 static const WCHAR METRICS_CAPTIONWIDTH_VALNAME[]= {'C','a','p','t','i','o','n','W','i','d','t','h',0};
246 static const WCHAR METRICS_CAPTIONHEIGHT_VALNAME[]= {'C','a','p','t','i','o','n','H','e','i','g','h','t',0};
247 static const WCHAR METRICS_SMCAPTIONWIDTH_VALNAME[]= {'S','m','C','a','p','t','i','o','n','W','i','d','t','h',0};
248 static const WCHAR METRICS_SMCAPTIONHEIGHT_VALNAME[]= {'S','m','C','a','p','t','i','o','n','H','e','i','g','h','t',0};
249 static const WCHAR METRICS_MENUWIDTH_VALNAME[]= {'M','e','n','u','W','i','d','t','h',0};
250 static const WCHAR METRICS_MENUHEIGHT_VALNAME[]= {'M','e','n','u','H','e','i','g','h','t',0};
251 static const WCHAR METRICS_ICONSIZE_VALNAME[]= {'S','h','e','l','l',' ','I','c','o','n',' ','S','i','z','e',0};
252 static const WCHAR METRICS_BORDERWIDTH_VALNAME[]= {'B','o','r','d','e','r','W','i','d','t','h',0};
253 static const WCHAR METRICS_CAPTIONLOGFONT_VALNAME[]= {'C','a','p','t','i','o','n','F','o','n','t',0};
254 static const WCHAR METRICS_SMCAPTIONLOGFONT_VALNAME[]={'S','m','C','a','p','t','i','o','n','F','o','n','t',0};
255 static const WCHAR METRICS_MENULOGFONT_VALNAME[]= {'M','e','n','u','F','o','n','t',0};
256 static const WCHAR METRICS_MESSAGELOGFONT_VALNAME[]= {'M','e','s','s','a','g','e','F','o','n','t',0};
257 static const WCHAR METRICS_STATUSLOGFONT_VALNAME[]= {'S','t','a','t','u','s','F','o','n','t',0};
258 /* minimized metrics */
259 static const WCHAR METRICS_MINWIDTH_VALNAME[] = {'M','i','n','W','i','d','t','h','\0'};
260 static const WCHAR METRICS_MINHORZGAP_VALNAME[] = {'M','i','n','H','o','r','z','G','a','p','\0'};
261 static const WCHAR METRICS_MINVERTGAP_VALNAME[] = {'M','i','n','V','e','r','t','G','a','p','\0'};
262 static const WCHAR METRICS_MINARRANGE_VALNAME[] = {'M','i','n','A','r','r','a','n','g','e','\0'};
263
264 static const WCHAR WINE_CURRENT_USER_REGKEY[] = {'S','o','f','t','w','a','r','e','\\',
265 'W','i','n','e',0};
266
267 /* volatile registry branch under WINE_CURRENT_USER_REGKEY for temporary values storage */
268 static const WCHAR WINE_CURRENT_USER_REGKEY_TEMP_PARAMS[] = {'T','e','m','p','o','r','a','r','y',' ',
269 'S','y','s','t','e','m',' ',
270 'P','a','r','a','m','e','t','e','r','s',0};
271
272 static const WCHAR Yes[]= {'Y','e','s',0};
273 static const WCHAR No[]= {'N','o',0};
274 static const WCHAR Desktop[]= {'D','e','s','k','t','o','p',0};
275 static const WCHAR Pattern[]= {'P','a','t','t','e','r','n',0};
276 static const WCHAR MenuFont[]= {'M','e','n','u','F','o','n','t',0};
277 static const WCHAR MenuFontSize[]= {'M','e','n','u','F','o','n','t','S','i','z','e',0};
278 static const WCHAR StatusFont[]= {'S','t','a','t','u','s','F','o','n','t',0};
279 static const WCHAR StatusFontSize[]= {'S','t','a','t','u','s','F','o','n','t','S','i','z','e',0};
280 static const WCHAR MessageFont[]= {'M','e','s','s','a','g','e','F','o','n','t',0};
281 static const WCHAR MessageFontSize[]= {'M','e','s','s','a','g','e','F','o','n','t','S','i','z','e',0};
282 static const WCHAR System[]= {'S','y','s','t','e','m',0};
283 static const WCHAR IconTitleSize[]= {'I','c','o','n','T','i','t','l','e','S','i','z','e',0};
284 static const WCHAR IconTitleFaceName[]= {'I','c','o','n','T','i','t','l','e','F','a','c','e','N','a','m','e',0};
285 static const WCHAR defPattern[]= {'0',' ','0',' ','0',' ','0',' ','0',' ','0',' ','0',' ','0',0};
286 static const WCHAR CSu[]= {'%','u',0};
287 static const WCHAR CSd[]= {'%','d',0};
288
289 /* Indicators whether system parameter value is loaded */
290 static char spi_loaded[SPI_INDEX_COUNT];
291
292 static BOOL notify_change = TRUE;
293
294 /* System parameters storage */
295 static BOOL beep_active = TRUE;
296 static int mouse_threshold1 = 6;
297 static int mouse_threshold2 = 10;
298 static int mouse_speed = 1;
299 static UINT border = 1;
300 static UINT keyboard_speed = 31;
301 static UINT screensave_timeout = 300;
302 static UINT grid_granularity = 0;
303 static UINT keyboard_delay = 1;
304 static UINT double_click_width = 4;
305 static UINT double_click_height = 4;
306 static UINT double_click_time = 500;
307 static BOOL drag_full_windows = FALSE;
308 static RECT work_area;
309 static BOOL keyboard_pref = TRUE;
310 static BOOL screen_reader = FALSE;
311 static UINT mouse_hover_width = 4;
312 static UINT mouse_hover_height = 4;
313 static UINT mouse_hover_time = 400;
314 static UINT mouse_scroll_chars = 3;
315 static UINT mouse_scroll_lines = 3;
316 static UINT menu_show_delay = 400;
317 static UINT menu_drop_alignment = 0;
318 static BOOL screensaver_running = FALSE;
319 static UINT font_smoothing = 0; /* 0x01 for 95/98/NT, 0x02 for 98/ME/2k/XP */
320 static BOOL lowpoweractive = FALSE;
321 static BOOL poweroffactive = FALSE;
322 static BOOL show_sounds = FALSE;
323 static BOOL snap_to_default_button = FALSE;
324 static BOOL swap_buttons = FALSE;
325 static UINT foreground_lock_timeout = 0;
326 static UINT caret_width = 1;
327 static UINT mouse_sensitivity = 10;
328 static UINT font_smoothing_type = 0;
329 static UINT font_smoothing_contrast = 0;
330 static UINT font_smoothing_orientation = 0;
331 static BYTE user_prefs[4];
332
333 static MINIMIZEDMETRICS minimized_metrics =
334 {
335 sizeof(MINIMIZEDMETRICS),
336 154, /* iWidth */
337 0, /* iHorzGap */
338 0, /* iVertGap */
339 ARW_HIDE /* iArrange */
340 };
341
342 static ICONMETRICSW icon_metrics =
343 {
344 sizeof(ICONMETRICSW),
345 75, /* iHorzSpacing */
346 75, /* iVertSpacing */
347 TRUE, /* iTitleWrap */
348 { -11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
349 OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH } /* lfFont */
350 };
351
352 static NONCLIENTMETRICSW nonclient_metrics =
353 {
354 sizeof(NONCLIENTMETRICSW),
355 1, /* iBorderWidth */
356 16, /* iScrollWidth */
357 16, /* iScrollHeight */
358 18, /* iCaptionWidth */
359 18, /* iCaptionHeight */
360 { 0 }, /* lfCaptionFont */
361 13, /* iSmCaptionWidth */
362 15, /* iSmCaptionHeight */
363 { 0 }, /* lfSmCaptionFont */
364 18, /* iMenuWidth */
365 18, /* iMenuHeight */
366 { 0 }, /* lfMenuFont */
367 { 0 }, /* lfStatusFont */
368 { 0 } /* lfMessageFont */
369 };
370
371 /* some additional non client metric info */
372 static TEXTMETRICW tmMenuFont;
373 static UINT CaptionFontAvCharWidth;
374
375 static SIZE icon_size = { 32, 32 };
376
377 #define NUM_SYS_COLORS (COLOR_MENUBAR+1)
378
379 static COLORREF SysColors[NUM_SYS_COLORS];
380 static HBRUSH SysColorBrushes[NUM_SYS_COLORS];
381 static HPEN SysColorPens[NUM_SYS_COLORS];
382
383 static const WORD wPattern55AA[] = { 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa };
384
385 HBRUSH SYSCOLOR_55AABrush = 0;
386
387 extern void CDECL __wine_make_gdi_object_system( HGDIOBJ handle, BOOL set );
388
389
390 /* This function is a copy of the one in objects/font.c */
391 static void SYSPARAMS_LogFont32ATo16( const LOGFONTA* font32, LPLOGFONT16 font16 )
392 {
393 font16->lfHeight = font32->lfHeight;
394 font16->lfWidth = font32->lfWidth;
395 font16->lfEscapement = font32->lfEscapement;
396 font16->lfOrientation = font32->lfOrientation;
397 font16->lfWeight = font32->lfWeight;
398 font16->lfItalic = font32->lfItalic;
399 font16->lfUnderline = font32->lfUnderline;
400 font16->lfStrikeOut = font32->lfStrikeOut;
401 font16->lfCharSet = font32->lfCharSet;
402 font16->lfOutPrecision = font32->lfOutPrecision;
403 font16->lfClipPrecision = font32->lfClipPrecision;
404 font16->lfQuality = font32->lfQuality;
405 font16->lfPitchAndFamily = font32->lfPitchAndFamily;
406 lstrcpynA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
407 }
408
409 static void SYSPARAMS_LogFont16To32W( const LOGFONT16 *font16, LPLOGFONTW font32 )
410 {
411 font32->lfHeight = font16->lfHeight;
412 font32->lfWidth = font16->lfWidth;
413 font32->lfEscapement = font16->lfEscapement;
414 font32->lfOrientation = font16->lfOrientation;
415 font32->lfWeight = font16->lfWeight;
416 font32->lfItalic = font16->lfItalic;
417 font32->lfUnderline = font16->lfUnderline;
418 font32->lfStrikeOut = font16->lfStrikeOut;
419 font32->lfCharSet = font16->lfCharSet;
420 font32->lfOutPrecision = font16->lfOutPrecision;
421 font32->lfClipPrecision = font16->lfClipPrecision;
422 font32->lfQuality = font16->lfQuality;
423 font32->lfPitchAndFamily = font16->lfPitchAndFamily;
424 MultiByteToWideChar( CP_ACP, 0, font16->lfFaceName, -1, font32->lfFaceName, LF_FACESIZE );
425 font32->lfFaceName[LF_FACESIZE-1] = 0;
426 }
427
428 static void SYSPARAMS_LogFont32WTo32A( const LOGFONTW* font32W, LPLOGFONTA font32A )
429 {
430 font32A->lfHeight = font32W->lfHeight;
431 font32A->lfWidth = font32W->lfWidth;
432 font32A->lfEscapement = font32W->lfEscapement;
433 font32A->lfOrientation = font32W->lfOrientation;
434 font32A->lfWeight = font32W->lfWeight;
435 font32A->lfItalic = font32W->lfItalic;
436 font32A->lfUnderline = font32W->lfUnderline;
437 font32A->lfStrikeOut = font32W->lfStrikeOut;
438 font32A->lfCharSet = font32W->lfCharSet;
439 font32A->lfOutPrecision = font32W->lfOutPrecision;
440 font32A->lfClipPrecision = font32W->lfClipPrecision;
441 font32A->lfQuality = font32W->lfQuality;
442 font32A->lfPitchAndFamily = font32W->lfPitchAndFamily;
443 WideCharToMultiByte( CP_ACP, 0, font32W->lfFaceName, -1, font32A->lfFaceName, LF_FACESIZE, NULL, NULL );
444 font32A->lfFaceName[LF_FACESIZE-1] = 0;
445 }
446
447 static void SYSPARAMS_LogFont32ATo32W( const LOGFONTA* font32A, LPLOGFONTW font32W )
448 {
449 font32W->lfHeight = font32A->lfHeight;
450 font32W->lfWidth = font32A->lfWidth;
451 font32W->lfEscapement = font32A->lfEscapement;
452 font32W->lfOrientation = font32A->lfOrientation;
453 font32W->lfWeight = font32A->lfWeight;
454 font32W->lfItalic = font32A->lfItalic;
455 font32W->lfUnderline = font32A->lfUnderline;
456 font32W->lfStrikeOut = font32A->lfStrikeOut;
457 font32W->lfCharSet = font32A->lfCharSet;
458 font32W->lfOutPrecision = font32A->lfOutPrecision;
459 font32W->lfClipPrecision = font32A->lfClipPrecision;
460 font32W->lfQuality = font32A->lfQuality;
461 font32W->lfPitchAndFamily = font32A->lfPitchAndFamily;
462 MultiByteToWideChar( CP_ACP, 0, font32A->lfFaceName, -1, font32W->lfFaceName, LF_FACESIZE );
463 font32W->lfFaceName[LF_FACESIZE-1] = 0;
464 }
465
466 static void SYSPARAMS_NonClientMetrics32ATo16( const NONCLIENTMETRICSA* lpnm32, LPNONCLIENTMETRICS16 lpnm16 )
467 {
468 lpnm16->iBorderWidth = lpnm32->iBorderWidth;
469 lpnm16->iScrollWidth = lpnm32->iScrollWidth;
470 lpnm16->iScrollHeight = lpnm32->iScrollHeight;
471 lpnm16->iCaptionWidth = lpnm32->iCaptionWidth;
472 lpnm16->iCaptionHeight = lpnm32->iCaptionHeight;
473 SYSPARAMS_LogFont32ATo16( &lpnm32->lfCaptionFont, &lpnm16->lfCaptionFont );
474 lpnm16->iSmCaptionWidth = lpnm32->iSmCaptionWidth;
475 lpnm16->iSmCaptionHeight = lpnm32->iSmCaptionHeight;
476 SYSPARAMS_LogFont32ATo16( &lpnm32->lfSmCaptionFont, &lpnm16->lfSmCaptionFont );
477 lpnm16->iMenuWidth = lpnm32->iMenuWidth;
478 lpnm16->iMenuHeight = lpnm32->iMenuHeight;
479 SYSPARAMS_LogFont32ATo16( &lpnm32->lfMenuFont, &lpnm16->lfMenuFont );
480 SYSPARAMS_LogFont32ATo16( &lpnm32->lfStatusFont, &lpnm16->lfStatusFont );
481 SYSPARAMS_LogFont32ATo16( &lpnm32->lfMessageFont, &lpnm16->lfMessageFont );
482 }
483
484 static void SYSPARAMS_NonClientMetrics32WTo32A( const NONCLIENTMETRICSW* lpnm32W, LPNONCLIENTMETRICSA lpnm32A )
485 {
486 lpnm32A->iBorderWidth = lpnm32W->iBorderWidth;
487 lpnm32A->iScrollWidth = lpnm32W->iScrollWidth;
488 lpnm32A->iScrollHeight = lpnm32W->iScrollHeight;
489 lpnm32A->iCaptionWidth = lpnm32W->iCaptionWidth;
490 lpnm32A->iCaptionHeight = lpnm32W->iCaptionHeight;
491 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfCaptionFont, &lpnm32A->lfCaptionFont );
492 lpnm32A->iSmCaptionWidth = lpnm32W->iSmCaptionWidth;
493 lpnm32A->iSmCaptionHeight = lpnm32W->iSmCaptionHeight;
494 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfSmCaptionFont, &lpnm32A->lfSmCaptionFont );
495 lpnm32A->iMenuWidth = lpnm32W->iMenuWidth;
496 lpnm32A->iMenuHeight = lpnm32W->iMenuHeight;
497 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMenuFont, &lpnm32A->lfMenuFont );
498 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfStatusFont, &lpnm32A->lfStatusFont );
499 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMessageFont, &lpnm32A->lfMessageFont );
500 }
501
502 static void SYSPARAMS_NonClientMetrics32ATo32W( const NONCLIENTMETRICSA* lpnm32A, LPNONCLIENTMETRICSW lpnm32W )
503 {
504 lpnm32W->iBorderWidth = lpnm32A->iBorderWidth;
505 lpnm32W->iScrollWidth = lpnm32A->iScrollWidth;
506 lpnm32W->iScrollHeight = lpnm32A->iScrollHeight;
507 lpnm32W->iCaptionWidth = lpnm32A->iCaptionWidth;
508 lpnm32W->iCaptionHeight = lpnm32A->iCaptionHeight;
509 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfCaptionFont, &lpnm32W->lfCaptionFont );
510 lpnm32W->iSmCaptionWidth = lpnm32A->iSmCaptionWidth;
511 lpnm32W->iSmCaptionHeight = lpnm32A->iSmCaptionHeight;
512 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfSmCaptionFont, &lpnm32W->lfSmCaptionFont );
513 lpnm32W->iMenuWidth = lpnm32A->iMenuWidth;
514 lpnm32W->iMenuHeight = lpnm32A->iMenuHeight;
515 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMenuFont, &lpnm32W->lfMenuFont );
516 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfStatusFont, &lpnm32W->lfStatusFont );
517 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMessageFont, &lpnm32W->lfMessageFont );
518 }
519
520
521 /* Helper functions to retrieve monitors info */
522
523 struct monitor_info
524 {
525 int count;
526 RECT virtual_rect;
527 };
528
529 static BOOL CALLBACK monitor_info_proc( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
530 {
531 struct monitor_info *info = (struct monitor_info *)lp;
532 info->count++;
533 UnionRect( &info->virtual_rect, &info->virtual_rect, rect );
534 return TRUE;
535 }
536
537 static void get_monitors_info( struct monitor_info *info )
538 {
539 info->count = 0;
540 SetRectEmpty( &info->virtual_rect );
541 EnumDisplayMonitors( 0, NULL, monitor_info_proc, (LPARAM)info );
542 }
543
544
545 /* get text metrics and/or "average" char width of the specified logfont
546 * for the specified dc */
547 static void get_text_metr_size( HDC hdc, LOGFONTW *plf, TEXTMETRICW * ptm, UINT *psz)
548 {
549 HFONT hfont, hfontsav;
550 TEXTMETRICW tm;
551 if( !ptm) ptm = &tm;
552 hfont = CreateFontIndirectW( plf);
553 if( !hfont || ( hfontsav = SelectObject( hdc, hfont)) == NULL ) {
554 ptm->tmHeight = -1;
555 if( psz) *psz = 10;
556 if( hfont) DeleteObject( hfont);
557 return;
558 }
559 GetTextMetricsW( hdc, ptm);
560 if( psz)
561 if( !(*psz = GdiGetCharDimensions( hdc, ptm, NULL)))
562 *psz = 10;
563 SelectObject( hdc, hfontsav);
564 DeleteObject( hfont);
565 }
566
567 /***********************************************************************
568 * get_volatile_regkey
569 *
570 * Return a handle to the volatile registry key used to store
571 * non-permanently modified parameters.
572 */
573 static HKEY get_volatile_regkey(void)
574 {
575 static HKEY volatile_key;
576
577 if (!volatile_key)
578 {
579 HKEY key;
580 /* This must be non-volatile! */
581 if (RegCreateKeyExW( HKEY_CURRENT_USER, WINE_CURRENT_USER_REGKEY,
582 0, 0, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, 0,
583 &key, 0 ) != ERROR_SUCCESS)
584 {
585 ERR("Can't create wine registry branch\n");
586 }
587 else
588 {
589 /* @@ Wine registry key: HKCU\Software\Wine\Temporary System Parameters */
590 if (RegCreateKeyExW( key, WINE_CURRENT_USER_REGKEY_TEMP_PARAMS,
591 0, 0, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, 0,
592 &volatile_key, 0 ) != ERROR_SUCCESS)
593 ERR("Can't create non-permanent wine registry branch\n");
594
595 RegCloseKey(key);
596 }
597 }
598 return volatile_key;
599 }
600
601 /***********************************************************************
602 * SYSPARAMS_NotifyChange
603 *
604 * Sends notification about system parameter update.
605 */
606 static void SYSPARAMS_NotifyChange( UINT uiAction, UINT fWinIni )
607 {
608 static const WCHAR emptyW[1];
609
610 if (notify_change)
611 {
612 if (fWinIni & SPIF_UPDATEINIFILE)
613 {
614 if (fWinIni & (SPIF_SENDWININICHANGE | SPIF_SENDCHANGE))
615 SendMessageTimeoutW(HWND_BROADCAST, WM_SETTINGCHANGE,
616 uiAction, (LPARAM) emptyW,
617 SMTO_ABORTIFHUNG, 2000, NULL );
618 }
619 else
620 {
621 /* FIXME notify other wine processes with internal message */
622 }
623 }
624 }
625
626
627 /***********************************************************************
628 * Loads system parameter from user profile.
629 */
630 static BOOL SYSPARAMS_LoadRaw( LPCWSTR lpRegKey, LPCWSTR lpValName, LPBYTE lpBuf, DWORD count )
631 {
632 BOOL ret = FALSE;
633 DWORD type;
634 HKEY hKey;
635
636 memset( lpBuf, 0, count );
637 if ((RegOpenKeyW( get_volatile_regkey(), lpRegKey, &hKey ) == ERROR_SUCCESS) ||
638 (RegOpenKeyW( HKEY_CURRENT_USER, lpRegKey, &hKey ) == ERROR_SUCCESS))
639 {
640 ret = !RegQueryValueExW( hKey, lpValName, NULL, &type, lpBuf, &count);
641 RegCloseKey( hKey );
642 }
643 return ret;
644 }
645
646 static BOOL SYSPARAMS_Load( LPCWSTR lpRegKey, LPCWSTR lpValName, LPWSTR lpBuf, DWORD count )
647 {
648 return SYSPARAMS_LoadRaw( lpRegKey, lpValName, (LPBYTE)lpBuf, count );
649 }
650
651 /***********************************************************************
652 * Saves system parameter to user profile.
653 */
654
655 /* Save data as-is */
656 static BOOL SYSPARAMS_SaveRaw( LPCWSTR lpRegKey, LPCWSTR lpValName,
657 const BYTE* lpValue, DWORD valueSize,
658 DWORD type, UINT fWinIni )
659 {
660 HKEY hKey;
661 HKEY hBaseKey;
662 DWORD dwOptions;
663 BOOL ret = FALSE;
664
665 if (fWinIni & SPIF_UPDATEINIFILE)
666 {
667 hBaseKey = HKEY_CURRENT_USER;
668 dwOptions = 0;
669 }
670 else
671 {
672 hBaseKey = get_volatile_regkey();
673 dwOptions = REG_OPTION_VOLATILE;
674 }
675
676 if (RegCreateKeyExW( hBaseKey, lpRegKey,
677 0, 0, dwOptions, KEY_ALL_ACCESS,
678 0, &hKey, 0 ) == ERROR_SUCCESS)
679 {
680 if (RegSetValueExW( hKey, lpValName, 0, type,
681 lpValue, valueSize) == ERROR_SUCCESS)
682 {
683 ret = TRUE;
684 if (hBaseKey == HKEY_CURRENT_USER)
685 RegDeleteKeyW( get_volatile_regkey(), lpRegKey );
686 }
687 RegCloseKey( hKey );
688 }
689 return ret;
690 }
691
692 /* Convenience function to save strings */
693 static BOOL SYSPARAMS_Save( LPCWSTR lpRegKey, LPCWSTR lpValName, LPCWSTR lpValue,
694 UINT fWinIni )
695 {
696 return SYSPARAMS_SaveRaw( lpRegKey, lpValName, (const BYTE*)lpValue,
697 (strlenW(lpValue) + 1)*sizeof(WCHAR), REG_SZ, fWinIni );
698 }
699
700 /* Convenience function to save logical fonts */
701 static BOOL SYSPARAMS_SaveLogFont( LPCWSTR lpRegKey, LPCWSTR lpValName,
702 const LOGFONTW *plf, UINT fWinIni )
703 {
704 LOGFONTW lf = *plf;
705 int len;
706
707 /* Zero pad the end of lfFaceName so we don't write uninitialised
708 data to the registry */
709 lf.lfFaceName[LF_FACESIZE-1] = 0;
710 len = strlenW(lf.lfFaceName);
711 if(len < LF_FACESIZE-1)
712 memset(lf.lfFaceName + len, 0, (LF_FACESIZE - 1 - len) * sizeof(WCHAR));
713
714 return SYSPARAMS_SaveRaw( lpRegKey, lpValName, (const BYTE*)&lf,
715 sizeof(LOGFONTW), REG_BINARY, fWinIni );
716 }
717
718
719 static inline HDC get_display_dc(void)
720 {
721 static const WCHAR DISPLAY[] = {'D','I','S','P','L','A','Y',0};
722 static HDC display_dc;
723 if (!display_dc)
724 {
725 display_dc = CreateICW( DISPLAY, NULL, NULL, NULL );
726 __wine_make_gdi_object_system( display_dc, TRUE );
727 }
728 return display_dc;
729 }
730
731 static inline int get_display_dpi(void)
732 {
733 static int display_dpi;
734 if (!display_dpi) display_dpi = GetDeviceCaps( get_display_dc(), LOGPIXELSY );
735 return display_dpi;
736 }
737
738 /***********************************************************************
739 * SYSPARAMS_Twips2Pixels
740 *
741 * Convert a dimension value that was obtained from the registry. These are
742 * quoted as being "twips" values if negative and pixels if positive.
743 * One inch is 1440 twips. So to convert, divide by 1440 to get inches and
744 * multiply that by the dots-per-inch to get the size in pixels.
745 * See for example
746 * MSDN Library - April 2001 -> Resource Kits ->
747 * Windows 2000 Resource Kit Reference ->
748 * Technical Reference to the Windows 2000 Registry ->
749 * HKEY_CURRENT_USER -> Control Panel -> Desktop -> WindowMetrics
750 */
751 static inline int SYSPARAMS_Twips2Pixels(int x)
752 {
753 if (x < 0)
754 x = (-x * get_display_dpi() + 720) / 1440;
755 return x;
756 }
757
758 /***********************************************************************
759 * get_reg_metric
760 *
761 * Get a registry entry from the already open key. This allows us to open the
762 * section once and read several values.
763 *
764 * Of course this function belongs somewhere more usable but here will do
765 * for now.
766 */
767 static int get_reg_metric( HKEY hkey, LPCWSTR lpValName, int default_value )
768 {
769 int value = default_value;
770 if (hkey)
771 {
772 WCHAR buffer[128];
773 DWORD type, count = sizeof(buffer);
774 if(!RegQueryValueExW( hkey, lpValName, NULL, &type, (LPBYTE)buffer, &count) )
775 {
776 if (type != REG_SZ)
777 {
778 /* Are there any utilities for converting registry entries
779 * between formats?
780 */
781 /* FIXME_(reg)("We need reg format converter\n"); */
782 }
783 else
784 value = atoiW(buffer);
785 }
786 }
787 return SYSPARAMS_Twips2Pixels(value);
788 }
789
790
791 /*************************************************************************
792 * SYSPARAMS_SetSysColor
793 */
794 static void SYSPARAMS_SetSysColor( int index, COLORREF color )
795 {
796 if (index < 0 || index >= NUM_SYS_COLORS) return;
797 SysColors[index] = color;
798 if (SysColorBrushes[index])
799 {
800 __wine_make_gdi_object_system( SysColorBrushes[index], FALSE);
801 DeleteObject( SysColorBrushes[index] );
802 }
803 SysColorBrushes[index] = CreateSolidBrush( color );
804 __wine_make_gdi_object_system( SysColorBrushes[index], TRUE);
805
806 if (SysColorPens[index])
807 {
808 __wine_make_gdi_object_system( SysColorPens[index], FALSE);
809 DeleteObject( SysColorPens[index] );
810 }
811 SysColorPens[index] = CreatePen( PS_SOLID, 1, color );
812 __wine_make_gdi_object_system( SysColorPens[index], TRUE);
813 }
814
815 /* load a uint parameter from the registry */
816 static BOOL get_uint_param( unsigned int idx, LPCWSTR regkey, LPCWSTR value,
817 UINT *value_ptr, UINT *ret_ptr )
818 {
819 if (!ret_ptr) return FALSE;
820 if (!spi_loaded[idx])
821 {
822 WCHAR buf[12];
823
824 if (SYSPARAMS_Load( regkey, value, buf, sizeof(buf) )) *value_ptr = atoiW( buf );
825 spi_loaded[idx] = TRUE;
826 }
827 *ret_ptr = *value_ptr;
828 return TRUE;
829 }
830
831 /* load a twips parameter from the registry */
832 static BOOL get_twips_param( unsigned int idx, LPCWSTR regkey, LPCWSTR value,
833 UINT *value_ptr, UINT *ret_ptr )
834 {
835 if (!ret_ptr) return FALSE;
836 if (!spi_loaded[idx])
837 {
838 WCHAR buf[12];
839
840 if (SYSPARAMS_Load( regkey, value, buf, sizeof(buf) ))
841 *value_ptr = SYSPARAMS_Twips2Pixels( atoiW(buf) );
842 spi_loaded[idx] = TRUE;
843 }
844 *ret_ptr = *value_ptr;
845 return TRUE;
846 }
847
848 /* load a boolean parameter from the registry */
849 static inline BOOL get_bool_param( unsigned int idx, LPCWSTR regkey, LPCWSTR value,
850 BOOL *value_ptr, BOOL *ret_ptr )
851 {
852 return get_uint_param( idx, regkey, value, (UINT *)value_ptr, (UINT *)ret_ptr );
853 }
854
855 /* set a uint parameter that is mirrored in two different registry locations */
856 static BOOL set_uint_param_mirrored( unsigned int idx, LPCWSTR regkey, LPCWSTR regkey_mirror,
857 LPCWSTR value, UINT *value_ptr, UINT new_val, UINT fWinIni )
858 {
859 WCHAR buf[12];
860
861 wsprintfW(buf, CSu, new_val);
862 if (!SYSPARAMS_Save( regkey, value, buf, fWinIni )) return FALSE;
863 if (regkey_mirror) SYSPARAMS_Save( regkey_mirror, value, buf, fWinIni );
864 *value_ptr = new_val;
865 spi_loaded[idx] = TRUE;
866 return TRUE;
867 }
868
869 /* save an int parameter in registry */
870 static BOOL save_int_param( LPCWSTR regkey, LPCWSTR value, INT *value_ptr,
871 INT new_val, UINT fWinIni )
872 {
873 WCHAR buf[12];
874
875 wsprintfW(buf, CSd, new_val);
876 if (!SYSPARAMS_Save( regkey, value, buf, fWinIni )) return FALSE;
877 if( value_ptr) *value_ptr = new_val;
878 return TRUE;
879 }
880
881 /* set an int parameter in the registry */
882 static inline BOOL set_int_param( unsigned int idx, LPCWSTR regkey, LPCWSTR value,
883 INT *value_ptr, INT new_val, UINT fWinIni )
884 {
885 BOOL ret = save_int_param( regkey, value, value_ptr, new_val, fWinIni );
886 if (ret) spi_loaded[idx] = TRUE;
887 return ret;
888 }
889
890 /* set a uint parameter in the registry */
891 static inline BOOL set_uint_param( unsigned int idx, LPCWSTR regkey, LPCWSTR value,
892 UINT *value_ptr, UINT new_val, UINT fWinIni )
893 {
894 return set_uint_param_mirrored( idx, regkey, NULL, value, value_ptr, new_val, fWinIni );
895 }
896
897 /* set a boolean parameter that is mirrored in two different registry locations */
898 static inline BOOL set_bool_param_mirrored( unsigned int idx, LPCWSTR regkey, LPCWSTR regkey_mirror,
899 LPCWSTR value, BOOL *value_ptr, BOOL new_val, UINT fWinIni )
900 {
901 return set_uint_param_mirrored( idx, regkey, regkey_mirror, value,
902 (UINT *)value_ptr, new_val, fWinIni );
903 }
904
905 /* set a boolean parameter in the registry */
906 static inline BOOL set_bool_param( unsigned int idx, LPCWSTR regkey, LPCWSTR value,
907 BOOL *value_ptr, BOOL new_val, UINT fWinIni )
908 {
909 return set_uint_param( idx, regkey, value, (UINT *)value_ptr, new_val, fWinIni );
910 }
911
912 /* load a boolean parameter from the user preference key */
913 static BOOL get_user_pref_param( UINT offset, UINT mask, BOOL *ret_ptr )
914 {
915 if (!ret_ptr) return FALSE;
916
917 if (!spi_loaded[SPI_USERPREFERENCEMASK_IDX])
918 {
919 SYSPARAMS_LoadRaw( SPI_USERPREFERENCEMASK_REGKEY,
920 SPI_USERPREFERENCEMASK_VALNAME,
921 user_prefs, sizeof(user_prefs) );
922 spi_loaded[SPI_USERPREFERENCEMASK_IDX] = TRUE;
923 }
924 *ret_ptr = (user_prefs[offset] & mask) != 0;
925 return TRUE;
926 }
927
928 /* set a boolean parameter in the user preference key */
929 static BOOL set_user_pref_param( UINT offset, UINT mask, BOOL value, BOOL fWinIni )
930 {
931 SYSPARAMS_LoadRaw( SPI_USERPREFERENCEMASK_REGKEY,
932 SPI_USERPREFERENCEMASK_VALNAME,
933 user_prefs, sizeof(user_prefs) );
934 spi_loaded[SPI_USERPREFERENCEMASK_IDX] = TRUE;
935
936 if (value) user_prefs[offset] |= mask;
937 else user_prefs[offset] &= ~mask;
938
939 SYSPARAMS_SaveRaw( SPI_USERPREFERENCEMASK_REGKEY,
940 SPI_USERPREFERENCEMASK_VALNAME,
941 user_prefs, sizeof(user_prefs), REG_BINARY, fWinIni );
942 return TRUE;
943 }
944
945 /***********************************************************************
946 * SYSPARAMS_Init
947 *
948 * Initialisation of the system metrics array.
949 */
950 void SYSPARAMS_Init(void)
951 {
952 HKEY hkey; /* key to the window metrics area of the registry */
953 int i, r, g, b;
954 char buffer[100];
955 HBITMAP h55AABitmap;
956
957 /* initialize system colors */
958
959 if (RegCreateKeyExA(HKEY_CURRENT_USER, "Control Panel\\Colors", 0, 0, 0, KEY_ALL_ACCESS, 0, &hkey, 0))
960 hkey = 0;
961 for (i = 0; i < NUM_SYS_COLORS; i++)
962 {
963 BOOL bOk = FALSE;
964
965 /* first try, registry */
966 if (hkey)
967 {
968 DWORD dwDataSize = sizeof(buffer);
969 if (!(RegQueryValueExA(hkey,DefSysColors[i*2], 0, 0, (LPBYTE) buffer, &dwDataSize)))
970 if (sscanf( buffer, "%d %d %d", &r, &g, &b ) == 3) bOk = TRUE;
971 }
972
973 /* second try, win.ini */
974 if (!bOk)
975 {
976 GetProfileStringA( "colors", DefSysColors[i*2], DefSysColors[i*2+1], buffer, 100 );
977 if (sscanf( buffer, " %d %d %d", &r, &g, &b ) == 3) bOk = TRUE;
978 }
979
980 /* last chance, take the default */
981 if (!bOk)
982 {
983 int iNumColors = sscanf( DefSysColors[i*2+1], " %d %d %d", &r, &g, &b );
984 assert (iNumColors==3);
985 }
986
987 SYSPARAMS_SetSysColor( i, RGB(r,g,b) );
988 }
989 if (hkey) RegCloseKey( hkey );
990
991 /* create 55AA bitmap */
992
993 h55AABitmap = CreateBitmap( 8, 8, 1, 1, wPattern55AA );
994 SYSCOLOR_55AABrush = CreatePatternBrush( h55AABitmap );
995 __wine_make_gdi_object_system( SYSCOLOR_55AABrush, TRUE );
996 }
997
998
999 /***********************************************************************
1000 * reg_get_logfont
1001 *
1002 * Tries to retrieve logfont info from the specified key and value
1003 */
1004 static BOOL reg_get_logfont(LPCWSTR key, LPCWSTR value, LOGFONTW *lf)
1005 {
1006 HKEY hkey;
1007 LOGFONTW lfbuf;
1008 DWORD type, size;
1009 BOOL found = FALSE;
1010 HKEY base_keys[2];
1011 int i;
1012
1013 base_keys[0] = get_volatile_regkey();
1014 base_keys[1] = HKEY_CURRENT_USER;
1015
1016 for(i = 0; i < 2 && !found; i++)
1017 {
1018 if(RegOpenKeyW(base_keys[i], key, &hkey) == ERROR_SUCCESS)
1019 {
1020 size = sizeof(lfbuf);
1021 if(RegQueryValueExW(hkey, value, NULL, &type, (LPBYTE)&lfbuf, &size) == ERROR_SUCCESS &&
1022 type == REG_BINARY)
1023 {
1024 if( size == sizeof(lfbuf))
1025 {
1026 found = TRUE;
1027 memcpy(lf, &lfbuf, size);
1028 } else if( size == sizeof( LOGFONT16))
1029 { /* win9x-winME format */
1030 found = TRUE;
1031 SYSPARAMS_LogFont16To32W( (LOGFONT16*) &lfbuf, lf);
1032 } else
1033 WARN("Unknown format in key %s value %s, size is %d\n",
1034 debugstr_w( key), debugstr_w( value), size);
1035 }
1036 RegCloseKey(hkey);
1037 }
1038 }
1039 if( found && lf->lfHeight > 0) {
1040 /* positive height value means points ( inch/72 ) */
1041 lf->lfHeight = -MulDiv( lf->lfHeight, get_display_dpi(), 72);
1042 }
1043 return found;
1044 }
1045
1046 /* load all the minimized metrics */
1047 static void load_minimized_metrics(void)
1048 {
1049 HKEY hkey;
1050 if (RegOpenKeyExW (HKEY_CURRENT_USER, METRICS_REGKEY,
1051 0, KEY_QUERY_VALUE, &hkey) != ERROR_SUCCESS) hkey = 0;
1052
1053 minimized_metrics.iWidth = max( get_reg_metric(hkey,
1054 METRICS_MINWIDTH_VALNAME, minimized_metrics.iWidth), 0);
1055 minimized_metrics.iHorzGap = max( get_reg_metric(hkey,
1056 METRICS_MINHORZGAP_VALNAME, minimized_metrics.iHorzGap), 0);
1057 minimized_metrics.iVertGap = max( get_reg_metric(hkey,
1058 METRICS_MINVERTGAP_VALNAME, minimized_metrics.iVertGap), 0);
1059 minimized_metrics.iArrange = 0x0f & get_reg_metric(hkey,
1060 METRICS_MINARRANGE_VALNAME, minimized_metrics.iArrange);
1061
1062 if (hkey) RegCloseKey( hkey );
1063 spi_loaded[SPI_MINIMIZEDMETRICS_IDX] = TRUE;
1064 }
1065
1066 /* adjust some of the raw values found in the registry */
1067 static void normalize_nonclientmetrics( NONCLIENTMETRICSW *pncm)
1068 {
1069 TEXTMETRICW tm;
1070 if( pncm->iBorderWidth < 1) pncm->iBorderWidth = 1;
1071 if( pncm->iCaptionWidth < 8) pncm->iCaptionWidth = 8;
1072 if( pncm->iScrollWidth < 8) pncm->iScrollWidth = 8;
1073 if( pncm->iScrollHeight < 8) pncm->iScrollHeight = 8;
1074
1075 /* get some extra metrics */
1076 get_text_metr_size( get_display_dc(), &pncm->lfMenuFont,
1077 &tmMenuFont, NULL);
1078 get_text_metr_size( get_display_dc(), &pncm->lfCaptionFont,
1079 NULL, &CaptionFontAvCharWidth);
1080
1081 /* adjust some heights to the corresponding font */
1082 pncm->iMenuHeight = max( pncm->iMenuHeight,
1083 2 + tmMenuFont.tmHeight + tmMenuFont.tmExternalLeading);
1084 get_text_metr_size( get_display_dc(), &pncm->lfCaptionFont, &tm, NULL);
1085 pncm->iCaptionHeight = max( pncm->iCaptionHeight, 2 + tm.tmHeight);
1086 get_text_metr_size( get_display_dc(), &pncm->lfSmCaptionFont, &tm, NULL);
1087 pncm->iSmCaptionHeight = max( pncm->iSmCaptionHeight, 2 + tm.tmHeight);
1088 }
1089
1090 /* load all the non-client metrics */
1091 static void load_nonclient_metrics(void)
1092 {
1093 HKEY hkey;
1094 NONCLIENTMETRICSW ncm;
1095 INT r;
1096
1097 ncm.cbSize = sizeof (ncm);
1098 if (RegOpenKeyExW (HKEY_CURRENT_USER, METRICS_REGKEY,
1099 0, KEY_QUERY_VALUE, &hkey) != ERROR_SUCCESS) hkey = 0;
1100
1101 /* initialize geometry entries */
1102 ncm.iBorderWidth = get_reg_metric(hkey, METRICS_BORDERWIDTH_VALNAME, 1);
1103 ncm.iScrollWidth = get_reg_metric(hkey, METRICS_SCROLLWIDTH_VALNAME, 16);
1104 ncm.iScrollHeight = get_reg_metric(hkey, METRICS_SCROLLHEIGHT_VALNAME, 16);
1105
1106 /* size of the normal caption buttons */
1107 ncm.iCaptionHeight = get_reg_metric(hkey, METRICS_CAPTIONHEIGHT_VALNAME, 18);
1108 ncm.iCaptionWidth = get_reg_metric(hkey, METRICS_CAPTIONWIDTH_VALNAME, ncm.iCaptionHeight);
1109
1110 /* caption font metrics */
1111 if (!reg_get_logfont(METRICS_REGKEY, METRICS_CAPTIONLOGFONT_VALNAME, &ncm.lfCaptionFont))
1112 {
1113 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, &ncm.lfCaptionFont, 0 );
1114 ncm.lfCaptionFont.lfWeight = FW_BOLD;
1115 }
1116
1117 /* size of the small caption buttons */
1118 ncm.iSmCaptionWidth = get_reg_metric(hkey, METRICS_SMCAPTIONWIDTH_VALNAME, 13);
1119 ncm.iSmCaptionHeight = get_reg_metric(hkey, METRICS_SMCAPTIONHEIGHT_VALNAME, 15);
1120
1121 /* small caption font metrics */
1122 if (!reg_get_logfont(METRICS_REGKEY, METRICS_SMCAPTIONLOGFONT_VALNAME, &ncm.lfSmCaptionFont))
1123 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, &ncm.lfSmCaptionFont, 0 );
1124
1125 /* menus, FIXME: names of wine.conf entries are bogus */
1126
1127 /* size of the menu (MDI) buttons */
1128 ncm.iMenuHeight = get_reg_metric(hkey, METRICS_MENUHEIGHT_VALNAME, 18);
1129 ncm.iMenuWidth = get_reg_metric(hkey, METRICS_MENUWIDTH_VALNAME, ncm.iMenuHeight);
1130
1131 /* menu font metrics */
1132 if (!reg_get_logfont(METRICS_REGKEY, METRICS_MENULOGFONT_VALNAME, &ncm.lfMenuFont))
1133 {
1134 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, &ncm.lfMenuFont, 0 );
1135 GetProfileStringW( Desktop, MenuFont, ncm.lfCaptionFont.lfFaceName,
1136 ncm.lfMenuFont.lfFaceName, LF_FACESIZE );
1137 r = GetProfileIntW( Desktop, MenuFontSize, 0 );
1138 if (r)
1139 ncm.lfMenuFont.lfHeight = -r;
1140 ncm.lfMenuFont.lfWeight = FW_NORMAL;
1141 }
1142
1143 /* status bar font metrics */
1144 if (!reg_get_logfont(METRICS_REGKEY, METRICS_STATUSLOGFONT_VALNAME, &ncm.lfStatusFont))
1145 {
1146 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, &ncm.lfStatusFont, 0 );
1147 GetProfileStringW( Desktop, StatusFont, ncm.lfCaptionFont.lfFaceName,
1148 ncm.lfStatusFont.lfFaceName, LF_FACESIZE );
1149 r = GetProfileIntW( Desktop, StatusFontSize, 0 );
1150 if (r)
1151 ncm.lfStatusFont.lfHeight = -r;
1152 ncm.lfStatusFont.lfWeight = FW_NORMAL;
1153 }
1154
1155 /* message font metrics */
1156 if (!reg_get_logfont(METRICS_REGKEY, METRICS_MESSAGELOGFONT_VALNAME, &ncm.lfMessageFont))
1157 {
1158 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, &ncm.lfMessageFont, 0 );
1159 GetProfileStringW( Desktop, MessageFont, ncm.lfCaptionFont.lfFaceName,
1160 ncm.lfMessageFont.lfFaceName, LF_FACESIZE );
1161 r = GetProfileIntW( Desktop, MessageFontSize, 0 );
1162 if (r)
1163 ncm.lfMessageFont.lfHeight = -r;
1164 ncm.lfMessageFont.lfWeight = FW_NORMAL;
1165 }
1166
1167 /* some extra fields not in the nonclient structure */
1168 icon_size.cx = icon_size.cy = get_reg_metric( hkey, METRICS_ICONSIZE_VALNAME, 32 );
1169
1170 if (hkey) RegCloseKey( hkey );
1171 normalize_nonclientmetrics( &ncm);
1172 nonclient_metrics = ncm;
1173 spi_loaded[SPI_NONCLIENTMETRICS_IDX] = TRUE;
1174 }
1175
1176 static BOOL CALLBACK enum_monitors( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
1177 {
1178 MONITORINFO mi;
1179
1180 mi.cbSize = sizeof(mi);
1181 if (GetMonitorInfoW( monitor, &mi ) && (mi.dwFlags & MONITORINFOF_PRIMARY))
1182 {
1183 LPRECT work = (LPRECT)lp;
1184 *work = mi.rcWork;
1185 return FALSE;
1186 }
1187 return TRUE;
1188 }
1189
1190 /***********************************************************************
1191 * SystemParametersInfoW (USER32.@)
1192 *
1193 * Each system parameter has flag which shows whether the parameter
1194 * is loaded or not. Parameters, stored directly in SysParametersInfo are
1195 * loaded from registry only when they are requested and the flag is
1196 * "false", after the loading the flag is set to "true". On interprocess
1197 * notification of the parameter change the corresponding parameter flag is
1198 * set to "false". The parameter value will be reloaded when it is requested
1199 * the next time.
1200 * Parameters, backed by or depend on GetSystemMetrics are processed
1201 * differently. These parameters are always loaded. They are reloaded right
1202 * away on interprocess change notification. We can't do lazy loading because
1203 * we don't want to complicate GetSystemMetrics.
1204 * Parameters, backed by X settings are read from corresponding setting.
1205 * On the parameter change request the setting is changed. Interprocess change
1206 * notifications are ignored.
1207 * When parameter value is updated the changed value is stored in permanent
1208 * registry branch if saving is requested. Otherwise it is stored
1209 * in temporary branch
1210 *
1211 * Some SPI values can also be stored as Twips values in the registry,
1212 * don't forget the conversion!
1213 */
1214 BOOL WINAPI SystemParametersInfoW( UINT uiAction, UINT uiParam,
1215 PVOID pvParam, UINT fWinIni )
1216 {
1217 #define WINE_SPI_FIXME(x) \
1218 case x: \
1219 { \
1220 static BOOL warn = TRUE; \
1221 if (warn) \
1222 { \
1223 warn = FALSE; \
1224 FIXME( "Unimplemented action: %u (%s)\n", x, #x ); \
1225 } \
1226 } \
1227 SetLastError( ERROR_INVALID_SPI_VALUE ); \
1228 ret = FALSE; \
1229 break
1230 #define WINE_SPI_WARN(x) \
1231 case x: \
1232 WARN( "Ignored action: %u (%s)\n", x, #x ); \
1233 break
1234
1235 BOOL ret = TRUE;
1236 unsigned spi_idx = 0;
1237
1238 switch (uiAction)
1239 {
1240 case SPI_GETBEEP: /* 1 */
1241 if (!pvParam) return FALSE;
1242
1243 spi_idx = SPI_SETBEEP_IDX;
1244 if (!spi_loaded[spi_idx])
1245 {
1246 WCHAR buf[5];
1247
1248 if (SYSPARAMS_Load( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME, buf, sizeof(buf) ))
1249 beep_active = !lstrcmpiW( Yes, buf );
1250 spi_loaded[spi_idx] = TRUE;
1251 }
1252
1253 *(BOOL *)pvParam = beep_active;
1254 break;
1255
1256 case SPI_SETBEEP: /* 2 */
1257 spi_idx = SPI_SETBEEP_IDX;
1258 if (SYSPARAMS_Save( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME,
1259 (uiParam ? Yes : No), fWinIni ))
1260 {
1261 beep_active = uiParam;
1262 spi_loaded[spi_idx] = TRUE;
1263 }
1264 else
1265 ret = FALSE;
1266 break;
1267
1268 case SPI_GETMOUSE: /* 3 */
1269 if (!pvParam) return FALSE;
1270
1271 spi_idx = SPI_SETMOUSE_IDX;
1272 if (!spi_loaded[spi_idx])
1273 {
1274 WCHAR buf[12];
1275
1276 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
1277 buf, sizeof(buf) ))
1278 mouse_threshold1 = atoiW( buf );
1279 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
1280 buf, sizeof(buf) ))
1281 mouse_threshold2 = atoiW( buf );
1282 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
1283 buf, sizeof(buf) ))
1284 mouse_speed = atoiW( buf );
1285 spi_loaded[spi_idx] = TRUE;
1286 }
1287 ((INT *)pvParam)[0] = mouse_threshold1;
1288 ((INT *)pvParam)[1] = mouse_threshold2;
1289 ((INT *)pvParam)[2] = mouse_speed;
1290 break;
1291
1292 case SPI_SETMOUSE: /* 4 */
1293 {
1294 if (!pvParam) return FALSE;
1295 ret = set_int_param( SPI_SETMOUSE_IDX, SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
1296 &mouse_threshold1, ((INT *)pvParam)[0], fWinIni);
1297 if( ret) {
1298 save_int_param( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
1299 &mouse_threshold2, ((INT *)pvParam)[1], fWinIni);
1300 save_int_param( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
1301 &mouse_speed, ((INT *)pvParam)[2], fWinIni);
1302 }
1303 break;
1304 }
1305
1306 case SPI_GETBORDER:
1307 ret = get_twips_param( SPI_SETBORDER_IDX,
1308 SPI_SETBORDER_REGKEY,
1309 SPI_SETBORDER_VALNAME,
1310 &border, pvParam );
1311 if( *(INT*)pvParam < 1) *(INT*)pvParam = 1;
1312 break;
1313
1314 case SPI_SETBORDER:
1315 nonclient_metrics.iBorderWidth = uiParam > 0 ? uiParam : 1;
1316 /* raw value goes to registry */
1317 ret = set_uint_param( SPI_SETBORDER_IDX,
1318 SPI_SETBORDER_REGKEY,
1319 SPI_SETBORDER_VALNAME,
1320 &border, uiParam, fWinIni );
1321 break;
1322
1323 case SPI_GETKEYBOARDSPEED:
1324 ret = get_uint_param( SPI_SETKEYBOARDSPEED_IDX,
1325 SPI_SETKEYBOARDSPEED_REGKEY,
1326 SPI_SETKEYBOARDSPEED_VALNAME,
1327 &keyboard_speed, pvParam );
1328 break;
1329
1330 case SPI_SETKEYBOARDSPEED:
1331 if (uiParam > 31) uiParam = 31;
1332 ret = set_uint_param( SPI_SETKEYBOARDSPEED_IDX,
1333 SPI_SETKEYBOARDSPEED_REGKEY,
1334 SPI_SETKEYBOARDSPEED_VALNAME,
1335 &keyboard_speed, uiParam, fWinIni );
1336 break;
1337
1338 /* not implemented in Windows */
1339 WINE_SPI_WARN(SPI_LANGDRIVER); /* 12 */
1340
1341 case SPI_ICONHORIZONTALSPACING:
1342 if (pvParam != NULL)
1343 {
1344 ret = get_twips_param( SPI_ICONHORIZONTALSPACING_IDX,
1345 SPI_ICONHORIZONTALSPACING_REGKEY,
1346 SPI_ICONHORIZONTALSPACING_VALNAME,
1347 (UINT*)&icon_metrics.iHorzSpacing, pvParam );
1348 }
1349 else
1350 {
1351 if (uiParam < 32) uiParam = 32;
1352 ret = set_uint_param( SPI_ICONHORIZONTALSPACING_IDX,
1353 SPI_ICONHORIZONTALSPACING_REGKEY,
1354 SPI_ICONHORIZONTALSPACING_VALNAME,
1355 (UINT*)&icon_metrics.iHorzSpacing, uiParam, fWinIni );
1356 }
1357 break;
1358
1359 case SPI_GETSCREENSAVETIMEOUT:
1360 ret = get_uint_param( SPI_SETSCREENSAVETIMEOUT_IDX,
1361 SPI_SETSCREENSAVETIMEOUT_REGKEY,
1362 SPI_SETSCREENSAVETIMEOUT_VALNAME,
1363 &screensave_timeout, pvParam );
1364 break;
1365
1366 case SPI_SETSCREENSAVETIMEOUT:
1367 ret = set_uint_param( SPI_SETSCREENSAVETIMEOUT_IDX,
1368 SPI_SETSCREENSAVETIMEOUT_REGKEY,
1369 SPI_SETSCREENSAVETIMEOUT_VALNAME,
1370 &screensave_timeout, uiParam, fWinIni );
1371 break;
1372
1373 case SPI_GETSCREENSAVEACTIVE: /* 16 */
1374 if (!pvParam) return FALSE;
1375 *(BOOL *)pvParam = USER_Driver->pGetScreenSaveActive();
1376 break;
1377
1378 case SPI_SETSCREENSAVEACTIVE: /* 17 */
1379 {
1380 WCHAR buf[12];
1381
1382 wsprintfW(buf, CSu, uiParam);
1383 USER_Driver->pSetScreenSaveActive( uiParam );
1384 /* saved value does not affect Wine */
1385 SYSPARAMS_Save( SPI_SETSCREENSAVEACTIVE_REGKEY,
1386 SPI_SETSCREENSAVEACTIVE_VALNAME,
1387 buf, fWinIni );
1388 break;
1389 }
1390
1391 case SPI_GETGRIDGRANULARITY:
1392 ret = get_uint_param( SPI_SETGRIDGRANULARITY_IDX,
1393 SPI_SETGRIDGRANULARITY_REGKEY,
1394 SPI_SETGRIDGRANULARITY_VALNAME,
1395 &grid_granularity, pvParam );
1396 break;
1397
1398 case SPI_SETGRIDGRANULARITY:
1399 ret = set_uint_param( SPI_SETGRIDGRANULARITY_IDX,
1400 SPI_SETGRIDGRANULARITY_REGKEY,
1401 SPI_SETGRIDGRANULARITY_VALNAME,
1402 &grid_granularity, uiParam, fWinIni );
1403 break;
1404
1405 case SPI_SETDESKWALLPAPER: /* 20 */
1406 if (!pvParam || !SetDeskWallPaper( pvParam )) return FALSE;
1407 SYSPARAMS_Save(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, pvParam, fWinIni);
1408 break;
1409
1410 case SPI_SETDESKPATTERN: /* 21 */
1411 /* FIXME: the ability to specify a pattern in pvParam
1412 doesn't seem to be documented for Win32 */
1413 if ((INT16)uiParam == -1)
1414 {
1415 WCHAR buf[256];
1416 GetProfileStringW( Desktop, Pattern,
1417 defPattern,
1418 buf, sizeof(buf)/sizeof(WCHAR) );
1419 ret = DESKTOP_SetPattern( buf );
1420 } else
1421 ret = DESKTOP_SetPattern( pvParam );
1422 break;
1423
1424 case SPI_GETKEYBOARDDELAY:
1425 ret = get_uint_param( SPI_SETKEYBOARDDELAY_IDX,
1426 SPI_SETKEYBOARDDELAY_REGKEY,
1427 SPI_SETKEYBOARDDELAY_VALNAME,
1428 &keyboard_delay, pvParam );
1429 break;
1430
1431 case SPI_SETKEYBOARDDELAY:
1432 ret = set_uint_param( SPI_SETKEYBOARDDELAY_IDX,
1433 SPI_SETKEYBOARDDELAY_REGKEY,
1434 SPI_SETKEYBOARDDELAY_VALNAME,
1435 &keyboard_delay, uiParam, fWinIni );
1436 break;
1437
1438 case SPI_ICONVERTICALSPACING:
1439 if (pvParam != NULL)
1440 {
1441 ret = get_twips_param( SPI_ICONVERTICALSPACING_IDX,
1442 SPI_ICONVERTICALSPACING_REGKEY,
1443 SPI_ICONVERTICALSPACING_VALNAME,
1444 (UINT*)&icon_metrics.iVertSpacing, pvParam );
1445 if( icon_metrics.iVertSpacing < 32)
1446 icon_metrics.iVertSpacing = 32;
1447 }
1448 else
1449 {
1450 if (uiParam < 32) uiParam = 32;
1451 ret = set_uint_param( SPI_ICONVERTICALSPACING_IDX,
1452 SPI_ICONVERTICALSPACING_REGKEY,
1453 SPI_ICONVERTICALSPACING_VALNAME,
1454 (UINT*)&icon_metrics.iVertSpacing, uiParam, fWinIni );
1455 }
1456 break;
1457
1458 case SPI_GETICONTITLEWRAP:
1459 ret = get_bool_param( SPI_SETICONTITLEWRAP_IDX,
1460 SPI_SETICONTITLEWRAP_REGKEY1,
1461 SPI_SETICONTITLEWRAP_VALNAME,
1462 &icon_metrics.iTitleWrap, pvParam );
1463 break;
1464
1465 case SPI_SETICONTITLEWRAP:
1466 ret = set_bool_param_mirrored( SPI_SETICONTITLEWRAP_IDX,
1467 SPI_SETICONTITLEWRAP_REGKEY1,
1468 SPI_SETICONTITLEWRAP_REGKEY2,
1469 SPI_SETICONTITLEWRAP_VALNAME,
1470 &icon_metrics.iTitleWrap, uiParam, fWinIni );
1471 break;
1472
1473 case SPI_GETMENUDROPALIGNMENT:
1474 ret = get_uint_param( SPI_SETMENUDROPALIGNMENT_IDX,
1475 SPI_SETMENUDROPALIGNMENT_REGKEY1,
1476 SPI_SETMENUDROPALIGNMENT_VALNAME,
1477 &menu_drop_alignment, pvParam );
1478 break;
1479
1480 case SPI_SETMENUDROPALIGNMENT:
1481 ret = set_uint_param_mirrored( SPI_SETMENUDROPALIGNMENT_IDX,
1482 SPI_SETMENUDROPALIGNMENT_REGKEY1,
1483 SPI_SETMENUDROPALIGNMENT_REGKEY2,
1484 SPI_SETMENUDROPALIGNMENT_VALNAME,
1485 &menu_drop_alignment, uiParam, fWinIni );
1486 break;
1487
1488 case SPI_SETDOUBLECLKWIDTH:
1489 ret = set_uint_param_mirrored( SPI_SETDOUBLECLKWIDTH_IDX,
1490 SPI_SETDOUBLECLKWIDTH_REGKEY1,
1491 SPI_SETDOUBLECLKWIDTH_REGKEY2,
1492 SPI_SETDOUBLECLKWIDTH_VALNAME,
1493 &double_click_width, uiParam, fWinIni );
1494 break;
1495
1496 case SPI_SETDOUBLECLKHEIGHT:
1497 ret = set_uint_param_mirrored( SPI_SETDOUBLECLKHEIGHT_IDX,
1498 SPI_SETDOUBLECLKHEIGHT_REGKEY1,
1499 SPI_SETDOUBLECLKHEIGHT_REGKEY2,
1500 SPI_SETDOUBLECLKHEIGHT_VALNAME,
1501 &double_click_height, uiParam, fWinIni );
1502 break;
1503
1504 case SPI_GETICONTITLELOGFONT:
1505 {
1506 LOGFONTW lfDefault;
1507
1508 if (!pvParam) return FALSE;
1509
1510 spi_idx = SPI_SETICONTITLELOGFONT_IDX;
1511 if (!spi_loaded[spi_idx])
1512 {
1513 if (!reg_get_logfont( SPI_SETICONTITLELOGFONT_REGKEY,
1514 SPI_SETICONTITLELOGFONT_VALNAME, &icon_metrics.lfFont ))
1515 {
1516 INT r;
1517
1518 /*
1519 * The 'default GDI fonts' seems to be returned.
1520 * If a returned font is not a correct font in your environment,
1521 * please try to fix objects/gdiobj.c at first.
1522 */
1523 GetObjectW( GetStockObject( DEFAULT_GUI_FONT ), sizeof(LOGFONTW), &lfDefault );
1524
1525 GetProfileStringW( Desktop, IconTitleFaceName,
1526 lfDefault.lfFaceName,
1527 icon_metrics.lfFont.lfFaceName,
1528 LF_FACESIZE );
1529
1530 r = GetProfileIntW( Desktop, IconTitleSize, 0 );
1531 if (r)
1532 icon_metrics.lfFont.lfHeight = -r;
1533 else
1534 icon_metrics.lfFont.lfHeight = lfDefault.lfHeight;
1535
1536 icon_metrics.lfFont.lfWidth = 0;
1537 icon_metrics.lfFont.lfEscapement = icon_metrics.lfFont.lfOrientation = 0;
1538 icon_metrics.lfFont.lfWeight = FW_NORMAL;
1539 icon_metrics.lfFont.lfItalic = FALSE;
1540 icon_metrics.lfFont.lfStrikeOut = FALSE;
1541 icon_metrics.lfFont.lfUnderline = FALSE;
1542 icon_metrics.lfFont.lfCharSet = lfDefault.lfCharSet; /* at least 'charset' should not be hard-coded */
1543 icon_metrics.lfFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
1544 icon_metrics.lfFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1545 icon_metrics.lfFont.lfQuality = DEFAULT_QUALITY;
1546 icon_metrics.lfFont.lfPitchAndFamily = DEFAULT_PITCH;
1547 spi_loaded[spi_idx] = TRUE;
1548 }
1549 }
1550 *(LOGFONTW *)pvParam = icon_metrics.lfFont;
1551 break;
1552 }
1553
1554 case SPI_SETDOUBLECLICKTIME:
1555 ret = set_uint_param( SPI_SETDOUBLECLICKTIME_IDX,
1556 SPI_SETDOUBLECLICKTIME_REGKEY,
1557 SPI_SETDOUBLECLICKTIME_VALNAME,
1558 &double_click_time, uiParam, fWinIni );
1559 break;
1560
1561 case SPI_SETMOUSEBUTTONSWAP:
1562 ret = set_bool_param( SPI_SETMOUSEBUTTONSWAP_IDX,
1563 SPI_SETMOUSEBUTTONSWAP_REGKEY,
1564 SPI_SETMOUSEBUTTONSWAP_VALNAME,
1565 &swap_buttons, uiParam, fWinIni );
1566 break;
1567
1568 case SPI_SETICONTITLELOGFONT: /* 34 */
1569 if( uiParam == sizeof(LOGFONTW)) {
1570 ret = SYSPARAMS_SaveLogFont( SPI_SETICONTITLELOGFONT_REGKEY,
1571 SPI_SETICONTITLELOGFONT_VALNAME, pvParam, fWinIni);
1572 if( ret) {
1573 icon_metrics.lfFont = *(LOGFONTW *)pvParam;
1574 spi_loaded[SPI_SETICONTITLELOGFONT_IDX] = TRUE;
1575 }
1576 } else
1577 ret = FALSE;
1578 break;
1579
1580 case SPI_GETFASTTASKSWITCH: /* 35 */
1581 if (!pvParam) return FALSE;
1582 *(BOOL *)pvParam = 1;
1583 break;
1584
1585 case SPI_SETFASTTASKSWITCH: /* 36 */
1586 /* the action is disabled */
1587 ret = FALSE;
1588 break;
1589
1590 case SPI_SETDRAGFULLWINDOWS:
1591 ret = set_bool_param( SPI_SETDRAGFULLWINDOWS_IDX,
1592 SPI_SETDRAGFULLWINDOWS_REGKEY,
1593 SPI_SETDRAGFULLWINDOWS_VALNAME,
1594 &drag_full_windows, uiParam, fWinIni );
1595 break;
1596
1597 case SPI_GETDRAGFULLWINDOWS:
1598 ret = get_bool_param( SPI_SETDRAGFULLWINDOWS_IDX,
1599 SPI_SETDRAGFULLWINDOWS_REGKEY,
1600 SPI_SETDRAGFULLWINDOWS_VALNAME,
1601 &drag_full_windows, pvParam );
1602 break;
1603
1604 case SPI_GETNONCLIENTMETRICS:
1605 {
1606 LPNONCLIENTMETRICSW lpnm = pvParam;
1607
1608 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
1609
1610 if (lpnm && lpnm->cbSize == sizeof(NONCLIENTMETRICSW))
1611 *lpnm = nonclient_metrics;
1612 else
1613 ret = FALSE;
1614 break;
1615 }
1616
1617 case SPI_SETNONCLIENTMETRICS:
1618 {
1619 LPNONCLIENTMETRICSW lpnm = pvParam;
1620
1621 if (lpnm && lpnm->cbSize == sizeof(NONCLIENTMETRICSW))
1622 {
1623 NONCLIENTMETRICSW ncm;
1624 ret = set_uint_param( SPI_SETBORDER_IDX,
1625 SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME,
1626 &border, lpnm->iBorderWidth, fWinIni );
1627 if( ret) ret = save_int_param( METRICS_REGKEY,
1628 METRICS_SCROLLWIDTH_VALNAME, NULL,
1629 lpnm->iScrollWidth, fWinIni );
1630 if( ret) ret = save_int_param( METRICS_REGKEY,
1631 METRICS_SCROLLHEIGHT_VALNAME, NULL,
1632 lpnm->iScrollHeight, fWinIni );
1633 if( ret) ret = save_int_param( METRICS_REGKEY,
1634 METRICS_CAPTIONWIDTH_VALNAME, NULL,
1635 lpnm->iCaptionWidth, fWinIni );
1636 if( ret) ret = save_int_param( METRICS_REGKEY,
1637 METRICS_CAPTIONHEIGHT_VALNAME, NULL,
1638 lpnm->iCaptionHeight, fWinIni );
1639 if( ret) ret = save_int_param( METRICS_REGKEY,
1640 METRICS_SMCAPTIONWIDTH_VALNAME, NULL,
1641 lpnm->iSmCaptionWidth, fWinIni );
1642 if( ret) ret = save_int_param( METRICS_REGKEY,
1643 METRICS_SMCAPTIONHEIGHT_VALNAME, NULL,
1644 lpnm->iSmCaptionHeight, fWinIni );
1645 if( ret) ret = save_int_param( METRICS_REGKEY,
1646 METRICS_MENUWIDTH_VALNAME, NULL,
1647 lpnm->iMenuWidth, fWinIni );
1648 if( ret) ret = save_int_param( METRICS_REGKEY,
1649 METRICS_MENUHEIGHT_VALNAME, NULL,
1650 lpnm->iMenuHeight, fWinIni );
1651 if( ret) ret = SYSPARAMS_SaveLogFont(
1652 METRICS_REGKEY, METRICS_MENULOGFONT_VALNAME,
1653 &lpnm->lfMenuFont, fWinIni);
1654 if( ret) ret = SYSPARAMS_SaveLogFont(
1655 METRICS_REGKEY, METRICS_CAPTIONLOGFONT_VALNAME,
1656 &lpnm->lfCaptionFont, fWinIni);
1657 if( ret) ret = SYSPARAMS_SaveLogFont(
1658 METRICS_REGKEY, METRICS_SMCAPTIONLOGFONT_VALNAME,
1659 &lpnm->lfSmCaptionFont, fWinIni);
1660 if( ret) ret = SYSPARAMS_SaveLogFont(
1661 METRICS_REGKEY, METRICS_STATUSLOGFONT_VALNAME,
1662 &lpnm->lfStatusFont, fWinIni);
1663 if( ret) ret = SYSPARAMS_SaveLogFont(
1664 METRICS_REGKEY, METRICS_MESSAGELOGFONT_VALNAME,
1665 &lpnm->lfMessageFont, fWinIni);
1666 if( ret) {
1667 ncm = *lpnm;
1668 normalize_nonclientmetrics( &ncm);
1669 nonclient_metrics = ncm;
1670 spi_loaded[SPI_NONCLIENTMETRICS_IDX] = TRUE;
1671 }
1672 }
1673 break;
1674 }
1675
1676 case SPI_GETMINIMIZEDMETRICS:
1677 {
1678 MINIMIZEDMETRICS * lpMm = pvParam;
1679 if (lpMm && lpMm->cbSize == sizeof(*lpMm)) {
1680 if( spi_loaded[SPI_MINIMIZEDMETRICS_IDX]) load_minimized_metrics();
1681 *lpMm = minimized_metrics;
1682 } else
1683 ret = FALSE;
1684 break;
1685 }
1686
1687 case SPI_SETMINIMIZEDMETRICS:
1688 {
1689 MINIMIZEDMETRICS * lpMm = pvParam;
1690 if (lpMm && lpMm->cbSize == sizeof(*lpMm)) {
1691 ret = save_int_param( METRICS_REGKEY, METRICS_MINWIDTH_VALNAME,
1692 &minimized_metrics.iWidth, max( lpMm->iWidth, 0), fWinIni);
1693 if( ret) ret = save_int_param( METRICS_REGKEY,
1694 METRICS_MINHORZGAP_VALNAME, &minimized_metrics.iHorzGap,
1695 max( lpMm->iHorzGap, 0), fWinIni);
1696 if( ret) ret = save_int_param( METRICS_REGKEY,
1697 METRICS_MINVERTGAP_VALNAME, &minimized_metrics.iVertGap,
1698 max( lpMm->iVertGap, 0), fWinIni);
1699 if( ret) ret = save_int_param( METRICS_REGKEY,
1700 METRICS_MINARRANGE_VALNAME, &minimized_metrics.iArrange,
1701 0x0f & lpMm->iArrange, fWinIni);
1702 if( ret) spi_loaded[SPI_MINIMIZEDMETRICS_IDX] = TRUE;
1703 } else
1704 ret = FALSE;
1705 break;
1706 }
1707
1708 case SPI_GETICONMETRICS:
1709 {
1710 LPICONMETRICSW lpIcon = pvParam;
1711 if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
1712 {
1713 SystemParametersInfoW( SPI_ICONHORIZONTALSPACING, 0,
1714 &lpIcon->iHorzSpacing, FALSE );
1715 SystemParametersInfoW( SPI_ICONVERTICALSPACING, 0,
1716 &lpIcon->iVertSpacing, FALSE );
1717 SystemParametersInfoW( SPI_GETICONTITLEWRAP, 0,
1718 &lpIcon->iTitleWrap, FALSE );
1719 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
1720 &lpIcon->lfFont, FALSE );
1721 }
1722 else
1723 {
1724 ret = FALSE;
1725 }
1726 break;
1727 }
1728
1729 case SPI_SETICONMETRICS:
1730 {
1731 LPICONMETRICSW lpIcon = pvParam;
1732 if (lpIcon && lpIcon->cbSize == sizeof(*lpIcon)) {
1733 ret = set_int_param( SPI_ICONVERTICALSPACING_IDX,
1734 SPI_ICONVERTICALSPACING_REGKEY,
1735 SPI_ICONVERTICALSPACING_VALNAME,
1736 &icon_metrics.iVertSpacing,
1737 lpIcon->iVertSpacing, fWinIni);
1738 if( ret) {
1739 ret = set_int_param( SPI_ICONHORIZONTALSPACING_IDX,
1740 SPI_ICONHORIZONTALSPACING_REGKEY,
1741 SPI_ICONHORIZONTALSPACING_VALNAME,
1742 &icon_metrics.iHorzSpacing,
1743 lpIcon->iHorzSpacing, fWinIni );
1744 }
1745 if( ret) {
1746 ret = set_bool_param_mirrored( SPI_SETICONTITLEWRAP_IDX,
1747 SPI_SETICONTITLEWRAP_REGKEY1, SPI_SETICONTITLEWRAP_REGKEY2,
1748 SPI_SETICONTITLEWRAP_VALNAME, &icon_metrics.iTitleWrap,
1749 lpIcon->iTitleWrap, fWinIni );
1750 }
1751 if( ret) ret = SYSPARAMS_SaveLogFont( SPI_SETICONTITLELOGFONT_REGKEY,
1752 SPI_SETICONTITLELOGFONT_VALNAME, &lpIcon->lfFont, fWinIni);
1753 if( ret) {
1754 icon_metrics.lfFont = lpIcon->lfFont;
1755 spi_loaded[SPI_SETICONTITLELOGFONT_IDX] = TRUE;
1756 }
1757 } else
1758 ret = FALSE;
1759 break;
1760 }
1761
1762 case SPI_SETWORKAREA: /* 47 WINVER >= 0x400 */
1763 {
1764 if (!pvParam) return FALSE;
1765
1766 spi_idx = SPI_SETWORKAREA_IDX;
1767 CopyRect( &work_area, pvParam );
1768 spi_loaded[spi_idx] = TRUE;
1769 break;
1770 }
1771
1772 case SPI_GETWORKAREA: /* 48 WINVER >= 0x400 */
1773 {
1774 if (!pvParam) return FALSE;
1775
1776 spi_idx = SPI_SETWORKAREA_IDX;
1777 if (!spi_loaded[spi_idx])
1778 {
1779 SetRect( &work_area, 0, 0,
1780 GetSystemMetrics( SM_CXSCREEN ),
1781 GetSystemMetrics( SM_CYSCREEN ) );
1782 EnumDisplayMonitors( 0, NULL, enum_monitors, (LPARAM)&work_area );
1783 spi_loaded[spi_idx] = TRUE;
1784 }
1785 CopyRect( pvParam, &work_area );
1786 TRACE("work area %s\n", wine_dbgstr_rect( &work_area ));
1787 break;
1788 }
1789
1790 WINE_SPI_FIXME(SPI_SETPENWINDOWS); /* 49 WINVER >= 0x400 */
1791
1792 case SPI_GETFILTERKEYS: /* 50 */
1793 {
1794 LPFILTERKEYS lpFilterKeys = pvParam;
1795 WARN("SPI_GETFILTERKEYS not fully implemented\n");
1796 if (lpFilterKeys && lpFilterKeys->cbSize == sizeof(FILTERKEYS))
1797 {
1798 /* Indicate that no FilterKeys feature available */
1799 lpFilterKeys->dwFlags = 0;
1800 lpFilterKeys->iWaitMSec = 0;
1801 lpFilterKeys->iDelayMSec = 0;
1802 lpFilterKeys->iRepeatMSec = 0;
1803 lpFilterKeys->iBounceMSec = 0;
1804 }
1805 else
1806 {
1807 ret = FALSE;
1808 }
1809 break;
1810 }
1811 WINE_SPI_FIXME(SPI_SETFILTERKEYS); /* 51 */
1812
1813 case SPI_GETTOGGLEKEYS: /* 52 */
1814 {
1815 LPTOGGLEKEYS lpToggleKeys = pvParam;
1816 WARN("SPI_GETTOGGLEKEYS not fully implemented\n");
1817 if (lpToggleKeys && lpToggleKeys->cbSize == sizeof(TOGGLEKEYS))
1818 {
1819 /* Indicate that no ToggleKeys feature available */
1820 lpToggleKeys->dwFlags = 0;
1821 }
1822 else
1823 {
1824 ret = FALSE;
1825 }
1826 break;
1827 }
1828 WINE_SPI_FIXME(SPI_SETTOGGLEKEYS); /* 53 */
1829
1830 case SPI_GETMOUSEKEYS: /* 54 */
1831 {
1832 LPMOUSEKEYS lpMouseKeys = pvParam;
1833 WARN("SPI_GETMOUSEKEYS not fully implemented\n");
1834 if (lpMouseKeys && lpMouseKeys->cbSize == sizeof(MOUSEKEYS))
1835 {
1836 /* Indicate that no MouseKeys feature available */
1837 lpMouseKeys->dwFlags = 0;
1838 lpMouseKeys->iMaxSpeed = 360;
1839 lpMouseKeys->iTimeToMaxSpeed = 1000;
1840 lpMouseKeys->iCtrlSpeed = 0;
1841 lpMouseKeys->dwReserved1 = 0;
1842 lpMouseKeys->dwReserved2 = 0;
1843 }
1844 else
1845 {
1846 ret = FALSE;
1847 }
1848 break;
1849 }
1850 WINE_SPI_FIXME(SPI_SETMOUSEKEYS); /* 55 */
1851
1852 case SPI_GETSHOWSOUNDS:
1853 ret = get_bool_param( SPI_SETSHOWSOUNDS_IDX,
1854 SPI_SETSHOWSOUNDS_REGKEY,
1855 SPI_SETSHOWSOUNDS_VALNAME,
1856 &show_sounds, pvParam );
1857 break;
1858
1859 case SPI_SETSHOWSOUNDS:
1860 ret = set_bool_param( SPI_SETSHOWSOUNDS_IDX,
1861 SPI_SETSHOWSOUNDS_REGKEY,
1862 SPI_SETSHOWSOUNDS_VALNAME,
1863 &show_sounds, uiParam, fWinIni );
1864 break;
1865
1866 case SPI_GETSTICKYKEYS: /* 58 */
1867 {
1868 LPSTICKYKEYS lpStickyKeys = pvParam;
1869 WARN("SPI_GETSTICKYKEYS not fully implemented\n");
1870 if (lpStickyKeys && lpStickyKeys->cbSize == sizeof(STICKYKEYS))
1871 {
1872 /* Indicate that no StickyKeys feature available */
1873 lpStickyKeys->dwFlags = 0;
1874 }
1875 else
1876 {
1877 ret = FALSE;
1878 }
1879 break;
1880 }
1881 WINE_SPI_FIXME(SPI_SETSTICKYKEYS); /* 59 */
1882
1883 case SPI_GETACCESSTIMEOUT: /* 60 */
1884 {
1885 LPACCESSTIMEOUT lpAccessTimeout = pvParam;
1886 WARN("SPI_GETACCESSTIMEOUT not fully implemented\n");
1887 if (lpAccessTimeout && lpAccessTimeout->cbSize == sizeof(ACCESSTIMEOUT))
1888 {
1889 /* Indicate that no accessibility features timeout is available */
1890 lpAccessTimeout->dwFlags = 0;
1891 lpAccessTimeout->iTimeOutMSec = 0;
1892 }
1893 else
1894 {
1895 ret = FALSE;
1896 }
1897 break;
1898 }
1899 WINE_SPI_FIXME(SPI_SETACCESSTIMEOUT); /* 61 */
1900
1901 case SPI_GETSERIALKEYS: /* 62 WINVER >= 0x400 */
1902 {
1903 LPSERIALKEYSW lpSerialKeysW = pvParam;
1904 WARN("SPI_GETSERIALKEYS not fully implemented\n");
1905 if (lpSerialKeysW && lpSerialKeysW->cbSize == sizeof(SERIALKEYSW))
1906 {
1907 /* Indicate that no SerialKeys feature available */
1908 lpSerialKeysW->dwFlags = 0;
1909 lpSerialKeysW->lpszActivePort = NULL;
1910 lpSerialKeysW->lpszPort = NULL;
1911 lpSerialKeysW->iBaudRate = 0;
1912 lpSerialKeysW->iPortState = 0;
1913 }
1914 else
1915 {
1916 ret = FALSE;
1917 }
1918 break;
1919 }
1920 WINE_SPI_FIXME(SPI_SETSERIALKEYS); /* 63 WINVER >= 0x400 */
1921
1922 case SPI_GETSOUNDSENTRY: /* 64 */
1923 {
1924 LPSOUNDSENTRYW lpSoundSentryW = pvParam;
1925 WARN("SPI_GETSOUNDSENTRY not fully implemented\n");
1926 if (lpSoundSentryW && lpSoundSentryW->cbSize == sizeof(SOUNDSENTRYW))
1927 {
1928 /* Indicate that no SoundSentry feature available */
1929 lpSoundSentryW->dwFlags = 0;
1930 lpSoundSentryW->iFSTextEffect = 0;
1931 lpSoundSentryW->iFSTextEffectMSec = 0;
1932 lpSoundSentryW->iFSTextEffectColorBits = 0;
1933 lpSoundSentryW->iFSGrafEffect = 0;
1934 lpSoundSentryW->iFSGrafEffectMSec = 0;
1935 lpSoundSentryW->iFSGrafEffectColor = 0;
1936 lpSoundSentryW->iWindowsEffect = 0;
1937 lpSoundSentryW->iWindowsEffectMSec = 0;
1938 lpSoundSentryW->lpszWindowsEffectDLL = 0;
1939 lpSoundSentryW->iWindowsEffectOrdinal = 0;
1940 }
1941 else
1942 {
1943 ret = FALSE;
1944 }
1945 break;
1946 }
1947 WINE_SPI_FIXME(SPI_SETSOUNDSENTRY); /* 65 */
1948
1949 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
1950 {
1951 LPHIGHCONTRASTW lpHighContrastW = pvParam;
1952 WARN("SPI_GETHIGHCONTRAST not fully implemented\n");
1953 if (lpHighContrastW && lpHighContrastW->cbSize == sizeof(HIGHCONTRASTW))
1954 {
1955 /* Indicate that no high contrast feature available */
1956 lpHighContrastW->dwFlags = 0;
1957 lpHighContrastW->lpszDefaultScheme = NULL;
1958 }
1959 else
1960 {
1961 ret = FALSE;
1962 }
1963 break;
1964 }
1965 WINE_SPI_FIXME(SPI_SETHIGHCONTRAST); /* 67 WINVER >= 0x400 */
1966
1967 case SPI_GETKEYBOARDPREF:
1968 ret = get_bool_param( SPI_SETKEYBOARDPREF_IDX,
1969 SPI_SETKEYBOARDPREF_REGKEY,
1970 SPI_SETKEYBOARDPREF_VALNAME,
1971 &keyboard_pref, pvParam );
1972 break;
1973
1974 case SPI_SETKEYBOARDPREF:
1975 ret = set_bool_param( SPI_SETKEYBOARDPREF_IDX,
1976 SPI_SETKEYBOARDPREF_REGKEY,
1977 SPI_SETKEYBOARDPREF_VALNAME,
1978 &keyboard_pref, uiParam, fWinIni );
1979 break;
1980
1981 case SPI_GETSCREENREADER:
1982 ret = get_bool_param( SPI_SETSCREENREADER_IDX,
1983 SPI_SETSCREENREADER_REGKEY,
1984 SPI_SETSCREENREADER_VALNAME,
1985 &screen_reader, pvParam );
1986 break;
1987
1988 case SPI_SETSCREENREADER:
1989 ret = set_bool_param( SPI_SETSCREENREADER_IDX,
1990 SPI_SETSCREENREADER_REGKEY,
1991 SPI_SETSCREENREADER_VALNAME,
1992 &screen_reader, uiParam, fWinIni );
1993 break;
1994
1995 case SPI_GETANIMATION: /* 72 WINVER >= 0x400 */
1996 {
1997 LPANIMATIONINFO lpAnimInfo = pvParam;
1998
1999 /* Tell it "disabled" */
2000 if (lpAnimInfo && lpAnimInfo->cbSize == sizeof(ANIMATIONINFO))
2001 lpAnimInfo->iMinAnimate = 0; /* Minimise and restore animation is disabled (nonzero == enabled) */
2002 else
2003 ret = FALSE;
2004 break;
2005 }
2006 WINE_SPI_WARN(SPI_SETANIMATION); /* 73 WINVER >= 0x400 */
2007
2008 case SPI_GETFONTSMOOTHING:
2009 {
2010 UINT tmpval;
2011 ret = get_uint_param( SPI_SETFONTSMOOTHING_IDX,
2012 SPI_SETFONTSMOOTHING_REGKEY,
2013 SPI_SETFONTSMOOTHING_VALNAME,
2014 &font_smoothing, &tmpval );
2015 if (!pvParam) ret = FALSE;
2016
2017 if (ret)
2018 *(UINT *) pvParam = ( tmpval != 0);
2019 break;
2020 }
2021 case SPI_SETFONTSMOOTHING:
2022 uiParam = uiParam ? 2 : 0; /* Win NT4/2k/XP behavior */
2023 ret = set_uint_param( SPI_SETFONTSMOOTHING_IDX,
2024 SPI_SETFONTSMOOTHING_REGKEY,
2025 SPI_SETFONTSMOOTHING_VALNAME,
2026 &font_smoothing, uiParam, fWinIni );
2027 break;
2028
2029 WINE_SPI_FIXME(SPI_SETDRAGWIDTH); /* 76 WINVER >= 0x400 */
2030 WINE_SPI_FIXME(SPI_SETDRAGHEIGHT); /* 77 WINVER >= 0x400 */
2031
2032 WINE_SPI_FIXME(SPI_SETHANDHELD); /* 78 WINVER >= 0x400 */
2033
2034 WINE_SPI_FIXME(SPI_GETLOWPOWERTIMEOUT); /* 79 WINVER >= 0x400 */
2035 WINE_SPI_FIXME(SPI_GETPOWEROFFTIMEOUT); /* 80 WINVER >= 0x400 */
2036 WINE_SPI_FIXME(SPI_SETLOWPOWERTIMEOUT); /* 81 WINVER >= 0x400 */
2037 WINE_SPI_FIXME(SPI_SETPOWEROFFTIMEOUT); /* 82 WINVER >= 0x400 */
2038
2039 case SPI_GETLOWPOWERACTIVE:
2040 ret = get_bool_param( SPI_SETLOWPOWERACTIVE_IDX,
2041 SPI_SETLOWPOWERACTIVE_REGKEY,
2042 SPI_SETLOWPOWERACTIVE_VALNAME,
2043 &lowpoweractive, pvParam );
2044 break;
2045
2046 case SPI_GETPOWEROFFACTIVE:
2047 ret = get_bool_param( SPI_SETPOWEROFFACTIVE_IDX,
2048 SPI_SETPOWEROFFACTIVE_REGKEY,
2049 SPI_SETPOWEROFFACTIVE_VALNAME,
2050 &poweroffactive, pvParam );
2051 break;
2052
2053 case SPI_SETLOWPOWERACTIVE:
2054 ret = set_bool_param( SPI_SETLOWPOWERACTIVE_IDX,
2055 SPI_SETLOWPOWERACTIVE_REGKEY,
2056 SPI_SETLOWPOWERACTIVE_VALNAME,
2057 &lowpoweractive, uiParam, fWinIni );
2058 break;
2059
2060 case SPI_SETPOWEROFFACTIVE:
2061 ret = set_bool_param( SPI_SETPOWEROFFACTIVE_IDX,
2062 SPI_SETPOWEROFFACTIVE_REGKEY,
2063 SPI_SETPOWEROFFACTIVE_VALNAME,
2064 &poweroffactive, uiParam, fWinIni );
2065 break;
2066
2067 WINE_SPI_FIXME(SPI_SETCURSORS); /* 87 WINVER >= 0x400 */
2068 WINE_SPI_FIXME(SPI_SETICONS); /* 88 WINVER >= 0x400 */
2069
2070 case SPI_GETDEFAULTINPUTLANG: /* 89 WINVER >= 0x400 */
2071 ret = GetKeyboardLayout(0) ? TRUE : FALSE;
2072 break;
2073
2074 WINE_SPI_FIXME(SPI_SETDEFAULTINPUTLANG); /* 90 WINVER >= 0x400 */
2075
2076 WINE_SPI_FIXME(SPI_SETLANGTOGGLE); /* 91 WINVER >= 0x400 */
2077
2078 case SPI_GETWINDOWSEXTENSION: /* 92 WINVER >= 0x400 */
2079 WARN("pretend no support for Win9x Plus! for now.\n");
2080 ret = FALSE; /* yes, this is the result value */
2081 break;
2082
2083 WINE_SPI_FIXME(SPI_SETMOUSETRAILS); /* 93 WINVER >= 0x400 */
2084 WINE_SPI_FIXME(SPI_GETMOUSETRAILS); /* 94 WINVER >= 0x400 */
2085
2086 case SPI_GETSNAPTODEFBUTTON: /* 95 WINVER >= 0x400 */
2087 ret = get_bool_param( SPI_SETSNAPTODEFBUTTON_IDX,
2088 SPI_SETSNAPTODEFBUTTON_REGKEY,
2089 SPI_SETSNAPTODEFBUTTON_VALNAME,
2090 &snap_to_default_button, pvParam );
2091 break;
2092
2093 case SPI_SETSNAPTODEFBUTTON: /* 96 WINVER >= 0x400 */
2094 ret = set_bool_param( SPI_SETSNAPTODEFBUTTON_IDX,
2095 SPI_SETSNAPTODEFBUTTON_REGKEY,
2096 SPI_SETSNAPTODEFBUTTON_VALNAME,
2097 &snap_to_default_button, uiParam, fWinIni );
2098 break;
2099
2100 case SPI_SETSCREENSAVERRUNNING:
2101 ret = set_bool_param( SPI_SETSCREENSAVERRUNNING_IDX,
2102 SPI_SETSCREENSAVERRUNNING_REGKEY,
2103 SPI_SETSCREENSAVERRUNNING_VALNAME,
2104 &screensaver_running, uiParam, fWinIni );
2105 break;
2106
2107 case SPI_GETMOUSEHOVERWIDTH:
2108 ret = get_uint_param( SPI_SETMOUSEHOVERWIDTH_IDX,
2109 SPI_SETMOUSEHOVERWIDTH_REGKEY,
2110 SPI_SETMOUSEHOVERWIDTH_VALNAME,
2111 &mouse_hover_width, pvParam );
2112 break;
2113
2114 case SPI_SETMOUSEHOVERWIDTH:
2115 ret = set_uint_param( SPI_SETMOUSEHOVERWIDTH_IDX,
2116 SPI_SETMOUSEHOVERWIDTH_REGKEY,
2117 SPI_SETMOUSEHOVERWIDTH_VALNAME,
2118 &mouse_hover_width, uiParam, fWinIni );
2119 break;
2120
2121 case SPI_GETMOUSEHOVERHEIGHT:
2122 ret = get_uint_param( SPI_SETMOUSEHOVERHEIGHT_IDX,
2123 SPI_SETMOUSEHOVERHEIGHT_REGKEY,
2124 SPI_SETMOUSEHOVERHEIGHT_VALNAME,
2125 &mouse_hover_height, pvParam );
2126 break;
2127
2128 case SPI_SETMOUSEHOVERHEIGHT:
2129 ret = set_uint_param( SPI_SETMOUSEHOVERHEIGHT_IDX,
2130 SPI_SETMOUSEHOVERHEIGHT_REGKEY,
2131 SPI_SETMOUSEHOVERHEIGHT_VALNAME,
2132 &mouse_hover_height, uiParam, fWinIni );
2133 break;
2134
2135 case SPI_GETMOUSEHOVERTIME:
2136 ret = get_uint_param( SPI_SETMOUSEHOVERTIME_IDX,
2137 SPI_SETMOUSEHOVERTIME_REGKEY,
2138 SPI_SETMOUSEHOVERTIME_VALNAME,
2139 &mouse_hover_time, pvParam );
2140 break;
2141
2142 case SPI_SETMOUSEHOVERTIME:
2143 ret = set_uint_param( SPI_SETMOUSEHOVERTIME_IDX,
2144 SPI_SETMOUSEHOVERTIME_REGKEY,
2145 SPI_SETMOUSEHOVERTIME_VALNAME,
2146 &mouse_hover_time, uiParam, fWinIni );
2147 break;
2148
2149 case SPI_GETWHEELSCROLLLINES:
2150 ret = get_uint_param( SPI_SETMOUSESCROLLLINES_IDX,
2151 SPI_SETMOUSESCROLLLINES_REGKEY,
2152 SPI_SETMOUSESCROLLLINES_VALNAME,
2153 &mouse_scroll_lines, pvParam );
2154 break;
2155
2156 case SPI_SETWHEELSCROLLLINES:
2157 ret = set_uint_param( SPI_SETMOUSESCROLLLINES_IDX,
2158 SPI_SETMOUSESCROLLLINES_REGKEY,
2159 SPI_SETMOUSESCROLLLINES_VALNAME,
2160 &mouse_scroll_lines, uiParam, fWinIni );
2161 break;
2162
2163 case SPI_GETMENUSHOWDELAY:
2164 ret = get_uint_param( SPI_SETMENUSHOWDELAY_IDX,
2165 SPI_SETMENUSHOWDELAY_REGKEY,
2166 SPI_SETMENUSHOWDELAY_VALNAME,
2167 &menu_show_delay, pvParam );
2168 break;
2169
2170 case SPI_SETMENUSHOWDELAY:
2171 ret = set_uint_param( SPI_SETMENUSHOWDELAY_IDX,
2172 SPI_SETMENUSHOWDELAY_REGKEY,
2173 SPI_SETMENUSHOWDELAY_VALNAME,
2174 &menu_show_delay, uiParam, fWinIni );
2175 break;
2176
2177 case SPI_GETWHEELSCROLLCHARS: /* 108 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2178 ret = get_uint_param( SPI_SETMOUSESCROLLCHARS_IDX,
2179 SPI_SETMOUSESCROLLCHARS_REGKEY,
2180 SPI_SETMOUSESCROLLCHARS_VALNAME,
2181 &mouse_scroll_chars, pvParam );
2182 break;
2183
2184 case SPI_SETWHEELSCROLLCHARS: /* 109 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2185 ret = set_uint_param( SPI_SETMOUSESCROLLCHARS_IDX,
2186 SPI_SETMOUSESCROLLCHARS_REGKEY,
2187 SPI_SETMOUSESCROLLCHARS_VALNAME,
2188 &mouse_scroll_chars, uiParam, fWinIni );
2189 break;
2190
2191 WINE_SPI_FIXME(SPI_GETSHOWIMEUI); /* 110 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2192 WINE_SPI_FIXME(SPI_SETSHOWIMEUI); /* 111 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2193
2194 case SPI_GETMOUSESPEED: /* 112 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2195 ret = get_uint_param( SPI_SETMOUSESPEED_IDX,
2196 SPI_SETMOUSESPEED_REGKEY,
2197 SPI_SETMOUSESPEED_VALNAME,
2198 &mouse_sensitivity, pvParam );
2199 break;
2200
2201 case SPI_SETMOUSESPEED: /* 113 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2202 ret = set_uint_param( SPI_SETMOUSESPEED_IDX,
2203 SPI_SETMOUSESPEED_REGKEY,
2204 SPI_SETMOUSESPEED_VALNAME,
2205 &mouse_sensitivity, PtrToInt(pvParam), fWinIni );
2206
2207 break;
2208
2209 case SPI_GETSCREENSAVERRUNNING:
2210 ret = get_bool_param( SPI_SETSCREENSAVERRUNNING_IDX,
2211 SPI_SETSCREENSAVERRUNNING_REGKEY,
2212 SPI_SETSCREENSAVERRUNNING_VALNAME,
2213 &screensaver_running, pvParam );
2214 break;
2215
2216 case SPI_GETDESKWALLPAPER: /* 115 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2217 {
2218 WCHAR buf[MAX_PATH];
2219
2220 if (!pvParam) return FALSE;
2221
2222 if (uiParam > MAX_PATH)
2223 {
2224 uiParam = MAX_PATH;
2225 }
2226
2227 if (SYSPARAMS_Load(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, buf, sizeof(buf)))
2228 {
2229 lstrcpynW(pvParam, buf, uiParam);
2230 }
2231 else
2232 {
2233 /* Return an empty string */
2234 memset(pvParam, 0, uiParam);
2235 }
2236
2237 break;
2238 }
2239
2240 WINE_SPI_FIXME(SPI_GETACTIVEWINDOWTRACKING);/* 0x1000 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2241 WINE_SPI_FIXME(SPI_SETACTIVEWINDOWTRACKING);/* 0x1001 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2242 case SPI_GETMENUANIMATION: /* 0x1002 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2243 ret = get_user_pref_param( 0, 0x02, pvParam );
2244 break;
2245
2246 case SPI_SETMENUANIMATION: /* 0x1003 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2247 ret = set_user_pref_param( 0, 0x02, PtrToUlong(pvParam), fWinIni );
2248 break;
2249
2250 case SPI_GETCOMBOBOXANIMATION: /* 0x1004 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2251 ret = get_user_pref_param( 0, 0x04, pvParam );
2252 break;
2253
2254 case SPI_SETCOMBOBOXANIMATION: /* 0x1005 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2255 ret = set_user_pref_param( 0, 0x04, PtrToUlong(pvParam), fWinIni );
2256 break;
2257
2258 case SPI_GETLISTBOXSMOOTHSCROLLING: /* 0x1006 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2259 ret = get_user_pref_param( 0, 0x08, pvParam );
2260 break;
2261
2262 case SPI_SETLISTBOXSMOOTHSCROLLING: /* 0x1007 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2263 ret = set_user_pref_param( 0, 0x08, PtrToUlong(pvParam), fWinIni );
2264 break;
2265
2266 case SPI_GETGRADIENTCAPTIONS:
2267 ret = get_user_pref_param( 0, 0x10, pvParam );
2268 break;
2269
2270 case SPI_SETGRADIENTCAPTIONS:
2271 ret = set_user_pref_param( 0, 0x10, PtrToUlong(pvParam), fWinIni );
2272 break;
2273
2274 case SPI_GETKEYBOARDCUES:
2275 ret = get_user_pref_param( 0, 0x20, pvParam );
2276 break;
2277
2278 case SPI_SETKEYBOARDCUES:
2279 ret = set_user_pref_param( 0, 0x20, PtrToUlong(pvParam), fWinIni );
2280 break;
2281
2282 WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKZORDER); /* 0x100C _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2283 WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKZORDER); /* 0x100D _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2284 case SPI_GETHOTTRACKING:
2285 ret = get_user_pref_param( 0, 0x80, pvParam );
2286 break;
2287
2288 case SPI_SETHOTTRACKING:
2289 ret = set_user_pref_param( 0, 0x80, PtrToUlong(pvParam), fWinIni );
2290 break;
2291
2292 WINE_SPI_FIXME(SPI_GETMENUFADE); /* 0x1012 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2293 WINE_SPI_FIXME(SPI_SETMENUFADE); /* 0x1013 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2294 case SPI_GETSELECTIONFADE: /* 0x1014 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2295 ret = get_user_pref_param( 1, 0x04, pvParam );
2296 break;
2297
2298 case SPI_SETSELECTIONFADE: /* 0x1015 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2299 ret = set_user_pref_param( 1, 0x04, PtrToUlong(pvParam), fWinIni );
2300 break;
2301
2302 case SPI_GETTOOLTIPANIMATION: /* 0x1016 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2303 ret = get_user_pref_param( 1, 0x08, pvParam );
2304 break;
2305
2306 case SPI_SETTOOLTIPANIMATION: /* 0x1017 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2307 ret = set_user_pref_param( 1, 0x08, PtrToUlong(pvParam), fWinIni );
2308 break;
2309
2310 case SPI_GETTOOLTIPFADE: /* 0x1018 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2311 ret = get_user_pref_param( 1, 0x10, pvParam );
2312 break;
2313
2314 case SPI_SETTOOLTIPFADE: /* 0x1019 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2315 ret = set_user_pref_param( 1, 0x10, PtrToUlong(pvParam), fWinIni );
2316 break;
2317
2318 case SPI_GETCURSORSHADOW: /* 0x101A _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2319 ret = get_user_pref_param( 1, 0x20, pvParam );
2320 break;
2321
2322 case SPI_SETCURSORSHADOW: /* 0x101B _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2323 ret = set_user_pref_param( 1, 0x20, PtrToUlong(pvParam), fWinIni );
2324 break;
2325
2326 WINE_SPI_FIXME(SPI_GETMOUSESONAR); /* 0x101C _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2327 WINE_SPI_FIXME(SPI_SETMOUSESONAR); /* 0x101D _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2328 WINE_SPI_FIXME(SPI_GETMOUSECLICKLOCK); /* 0x101E _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2329 WINE_SPI_FIXME(SPI_SETMOUSECLICKLOCK); /* 0x101F _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2330
2331 case SPI_GETMOUSEVANISH:
2332 ret = get_user_pref_param( 2, 0x01, pvParam );
2333 break;
2334
2335 case SPI_SETMOUSEVANISH:
2336 ret = set_user_pref_param( 2, 0x01, PtrToUlong(pvParam), fWinIni );
2337 break;
2338
2339 case SPI_GETFLATMENU:
2340 ret = get_user_pref_param( 2, 0x02, pvParam );
2341 break;
2342
2343 case SPI_SETFLATMENU:
2344 ret = set_user_pref_param( 2, 0x02, PtrToUlong(pvParam), fWinIni );
2345 break;
2346
2347 case SPI_GETDROPSHADOW:
2348 ret = get_user_pref_param( 2, 0x04, pvParam );
2349 break;
2350
2351 case SPI_SETDROPSHADOW:
2352 ret = set_user_pref_param( 2, 0x04, PtrToUlong(pvParam), fWinIni );
2353 break;
2354
2355 WINE_SPI_FIXME(SPI_GETBLOCKSENDINPUTRESETS);
2356 WINE_SPI_FIXME(SPI_SETBLOCKSENDINPUTRESETS);
2357 case SPI_GETUIEFFECTS:
2358 ret = get_user_pref_param( 3, 0x80, pvParam );
2359 break;
2360
2361 case SPI_SETUIEFFECTS:
2362 /* FIXME: this probably should mask other UI effect values when unset */
2363 ret = set_user_pref_param( 3, 0x80, PtrToUlong(pvParam), fWinIni );
2364 break;
2365
2366 /* _WIN32_WINNT >= 0x600 */
2367 WINE_SPI_FIXME(SPI_GETDISABLEOVERLAPPEDCONTENT);
2368 WINE_SPI_FIXME(SPI_SETDISABLEOVERLAPPEDCONTENT);
2369 WINE_SPI_FIXME(SPI_GETCLIENTAREAANIMATION);
2370 WINE_SPI_FIXME(SPI_SETCLIENTAREAANIMATION);
2371 WINE_SPI_FIXME(SPI_GETCLEARTYPE);
2372 WINE_SPI_FIXME(SPI_SETCLEARTYPE);
2373 WINE_SPI_FIXME(SPI_GETSPEECHRECOGNITION);
2374 WINE_SPI_FIXME(SPI_SETSPEECHRECOGNITION);
2375
2376 case SPI_GETFOREGROUNDLOCKTIMEOUT: /* 0x2000 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2377 ret = get_uint_param( SPI_SETFOREGROUNDLOCKTIMEOUT_IDX,
2378 SPI_SETFOREGROUNDLOCKTIMEOUT_REGKEY,
2379 SPI_SETFOREGROUNDLOCKTIMEOUT_VALNAME,
2380 &foreground_lock_timeout, pvParam );
2381 break;
2382
2383 case SPI_SETFOREGROUNDLOCKTIMEOUT: /* 0x2001 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2384 /* FIXME: this should check that the calling thread
2385 * is able to change the foreground window */
2386 ret = set_uint_param( SPI_SETFOREGROUNDLOCKTIMEOUT_IDX,
2387 SPI_SETFOREGROUNDLOCKTIMEOUT_REGKEY,
2388 SPI_SETFOREGROUNDLOCKTIMEOUT_VALNAME,
2389 &foreground_lock_timeout, PtrToUlong(pvParam), fWinIni );
2390 break;
2391
2392 WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKTIMEOUT); /* 0x2002 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2393 WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKTIMEOUT); /* 0x2003 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2394 WINE_SPI_FIXME(SPI_GETFOREGROUNDFLASHCOUNT);/* 0x2004 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2395 WINE_SPI_FIXME(SPI_SETFOREGROUNDFLASHCOUNT);/* 0x2005 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2396 case SPI_GETCARETWIDTH: /* 0x2006 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2397 ret = get_uint_param( SPI_CARETWIDTH_IDX,
2398 SPI_CARETWIDTH_REGKEY,
2399 SPI_CARETWIDTH_VALNAME,
2400 &caret_width, pvParam );
2401 break;
2402
2403 case SPI_SETCARETWIDTH: /* 0x2007 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2404 ret = set_uint_param( SPI_CARETWIDTH_IDX,
2405 SPI_CARETWIDTH_REGKEY,
2406 SPI_CARETWIDTH_VALNAME,
2407 &caret_width, uiParam, fWinIni );
2408 break;
2409
2410 WINE_SPI_FIXME(SPI_GETMOUSECLICKLOCKTIME); /* 0x2008 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2411 WINE_SPI_FIXME(SPI_SETMOUSECLICKLOCKTIME); /* 0x2009 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2412 case SPI_GETFONTSMOOTHINGTYPE: /* 0x200A _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2413 spi_idx = SPI_SETFONTSMOOTHINGTYPE_IDX;
2414 if (!spi_loaded[spi_idx])
2415 {
2416 ret = SYSPARAMS_Load( SPI_SETFONTSMOOTHINGTYPE_REGKEY,
2417 SPI_SETFONTSMOOTHINGTYPE_VALNAME,
2418 (LPWSTR)&font_smoothing_type,
2419 sizeof(font_smoothing_type) );
2420 if ( ret) spi_loaded[spi_idx] = TRUE;
2421 }
2422 if (!pvParam) ret = FALSE;
2423
2424 if (ret)
2425 *(UINT *)pvParam = font_smoothing_type;
2426 break;
2427
2428 case SPI_SETFONTSMOOTHINGTYPE: /* 0x200B _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2429 spi_idx = SPI_SETFONTSMOOTHINGTYPE_IDX;
2430 if (SYSPARAMS_SaveRaw( SPI_SETFONTSMOOTHINGTYPE_REGKEY,
2431 SPI_SETFONTSMOOTHINGTYPE_VALNAME,
2432 (LPBYTE)&pvParam, sizeof(UINT), REG_DWORD, fWinIni ))
2433 {
2434 font_smoothing_type = PtrToUlong(pvParam);
2435 spi_loaded[spi_idx] = TRUE;
2436 }
2437 else
2438 ret = FALSE;
2439 break;
2440
2441 case SPI_GETFONTSMOOTHINGCONTRAST: /* 0x200C _WIN32_WINNT >= 0x510 */
2442 spi_idx = SPI_SETFONTSMOOTHINGCONTRAST_IDX;
2443 if (!spi_loaded[spi_idx])
2444 {
2445 ret = SYSPARAMS_Load( SPI_SETFONTSMOOTHINGCONTRAST_REGKEY,
2446 SPI_SETFONTSMOOTHINGCONTRAST_VALNAME,
2447 (LPWSTR)&font_smoothing_contrast,
2448 sizeof(font_smoothing_contrast) );
2449 if (ret)
2450 spi_loaded[spi_idx] = TRUE;
2451 }
2452 if (!pvParam) ret = FALSE;
2453
2454 if (ret)
2455 *(UINT *)pvParam = font_smoothing_contrast;
2456 break;
2457
2458 case SPI_SETFONTSMOOTHINGCONTRAST: /* 0x200D _WIN32_WINNT >= 0x510 */
2459 spi_idx = SPI_SETFONTSMOOTHINGCONTRAST_IDX;
2460 if (SYSPARAMS_SaveRaw( SPI_SETFONTSMOOTHINGCONTRAST_REGKEY,
2461 SPI_SETFONTSMOOTHINGCONTRAST_VALNAME,
2462 (LPBYTE)&pvParam, sizeof(UINT), REG_DWORD, fWinIni ))
2463 {
2464 font_smoothing_contrast = PtrToUlong(pvParam);
2465 spi_loaded[spi_idx] = TRUE;
2466 }
2467 else
2468 ret = FALSE;
2469 break;
2470
2471 case SPI_GETFOCUSBORDERWIDTH: /* 0x200E _WIN32_WINNT >= 0x510 */
2472 case SPI_GETFOCUSBORDERHEIGHT: /* 0x200F _WIN32_WINNT >= 0x510 */
2473 if (!pvParam)
2474 ret = FALSE;
2475 else
2476 *(UINT *)pvParam = 1;
2477 break;
2478
2479 WINE_SPI_FIXME(SPI_SETFOCUSBORDERWIDTH); /* 0x2010 _WIN32_WINNT >= 0x510 */
2480 WINE_SPI_FIXME(SPI_SETFOCUSBORDERHEIGHT); /* 0x2011 _WIN32_WINNT >= 0x510 */
2481
2482 case SPI_GETFONTSMOOTHINGORIENTATION: /* 0x2012 */
2483 spi_idx = SPI_SETFONTSMOOTHINGORIENTATION_IDX;
2484 if (!spi_loaded[spi_idx])
2485 {
2486 ret = SYSPARAMS_Load( SPI_SETFONTSMOOTHINGORIENTATION_REGKEY,
2487 SPI_SETFONTSMOOTHINGORIENTATION_VALNAME,
2488 (LPWSTR)&font_smoothing_orientation,
2489 sizeof(font_smoothing_orientation) );
2490 if (ret)
2491 spi_loaded[spi_idx] = TRUE;
2492 }
2493 if (!pvParam) ret = FALSE;
2494
2495 if (ret)
2496 *(UINT *)pvParam = font_smoothing_orientation;
2497 break;
2498
2499 case SPI_SETFONTSMOOTHINGORIENTATION: /* 0x2013 */
2500 spi_idx = SPI_SETFONTSMOOTHINGORIENTATION_IDX;
2501 if (SYSPARAMS_SaveRaw( SPI_SETFONTSMOOTHINGORIENTATION_REGKEY,
2502 SPI_SETFONTSMOOTHINGORIENTATION_VALNAME,
2503 (LPBYTE)&pvParam, sizeof(UINT), REG_DWORD, fWinIni ))
2504 {
2505 font_smoothing_orientation = PtrToUlong(pvParam);
2506 spi_loaded[spi_idx] = TRUE;
2507 }
2508 else
2509 ret = FALSE;
2510 break;
2511
2512 default:
2513 FIXME( "Unknown action: %u\n", uiAction );
2514 SetLastError( ERROR_INVALID_SPI_VALUE );
2515 ret = FALSE;
2516 break;
2517 }
2518
2519 if (ret)
2520 SYSPARAMS_NotifyChange( uiAction, fWinIni );
2521 TRACE("(%u, %u, %p, %u) ret %d\n",
2522 uiAction, uiParam, pvParam, fWinIni, ret);
2523 return ret;
2524
2525 #undef WINE_SPI_FIXME
2526 #undef WINE_SPI_WARN
2527 }
2528
2529
2530 /***********************************************************************
2531 * SystemParametersInfo (USER.483)
2532 */
2533 BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
2534 LPVOID lpvParam, UINT16 fuWinIni )
2535 {
2536 BOOL16 ret;
2537
2538 TRACE("(%u, %u, %p, %u)\n", uAction, uParam, lpvParam, fuWinIni);
2539
2540 switch (uAction)
2541 {
2542 case SPI_GETBEEP: /* 1 */
2543 case SPI_GETSCREENSAVEACTIVE: /* 16 */
2544 case SPI_GETICONTITLEWRAP: /* 25 */
2545 case SPI_GETMENUDROPALIGNMENT: /* 27 */
2546 case SPI_GETFASTTASKSWITCH: /* 35 */
2547 case SPI_GETDRAGFULLWINDOWS: /* 38 WINVER >= 0x0400 */
2548 {
2549 BOOL tmp;
2550 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2551 if (ret && lpvParam)
2552 *(BOOL16 *)lpvParam = tmp;
2553 break;
2554 }
2555
2556 case SPI_GETBORDER: /* 5 */
2557 case SPI_ICONHORIZONTALSPACING: /* 13 */
2558 case SPI_GETSCREENSAVETIMEOUT: /* 14 */
2559 case SPI_GETGRIDGRANULARITY: /* 18 */
2560 case SPI_GETKEYBOARDDELAY: /* 22 */
2561 case SPI_ICONVERTICALSPACING: /* 24 */
2562 {
2563 INT tmp;
2564 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2565 if (ret && lpvParam)
2566 *(INT16 *)lpvParam = tmp;
2567 break;
2568 }
2569
2570 case SPI_GETKEYBOARDSPEED: /* 10 */
2571 {
2572 DWORD tmp;
2573 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2574 if (ret && lpvParam)
2575 *(WORD *)lpvParam = tmp;
2576 break;
2577 }
2578
2579 case SPI_GETICONTITLELOGFONT: /* 31 */
2580 {
2581 LOGFONTA tmp;
2582 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2583 if (ret && lpvParam)
2584 SYSPARAMS_LogFont32ATo16( &tmp, (LPLOGFONT16)lpvParam );
2585 break;
2586 }
2587
2588 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
2589 {
2590 NONCLIENTMETRICSA tmp;
2591 LPNONCLIENTMETRICS16 lpnm16 = (LPNONCLIENTMETRICS16)lpvParam;
2592 if (lpnm16 && lpnm16->cbSize == sizeof(NONCLIENTMETRICS16))
2593 {
2594 tmp.cbSize = sizeof(NONCLIENTMETRICSA);
2595 ret = SystemParametersInfoA( uAction, uParam, &tmp, fuWinIni );
2596 if (ret)
2597 SYSPARAMS_NonClientMetrics32ATo16( &tmp, lpnm16 );
2598 }
2599 else /* winfile 95 sets cbSize to 340 */
2600 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
2601 break;
2602 }
2603
2604 case SPI_GETWORKAREA: /* 48 WINVER >= 0x400 */
2605 {
2606 RECT tmp;
2607 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2608 if (ret && lpvParam)
2609 {
2610 RECT16 *r16 = lpvParam;
2611 r16->left = tmp.left;
2612 r16->top = tmp.top;
2613 r16->right = tmp.right;
2614 r16->bottom = tmp.bottom;
2615 }
2616 break;
2617 }
2618
2619 case SPI_GETMOUSEHOVERWIDTH: /* 98 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2620 case SPI_GETMOUSEHOVERHEIGHT: /* 100 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2621 case SPI_GETMOUSEHOVERTIME: /* 102 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2622 {
2623 UINT tmp;
2624 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2625 if (ret && lpvParam)
2626 *(UINT16 *)lpvParam = tmp;
2627 break;
2628 }
2629
2630 default:
2631 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
2632 }
2633
2634 return ret;
2635 }
2636
2637 /***********************************************************************
2638 * SystemParametersInfoA (USER32.@)
2639 */
2640 BOOL WINAPI SystemParametersInfoA( UINT uiAction, UINT uiParam,
2641 PVOID pvParam, UINT fuWinIni )
2642 {
2643 BOOL ret;
2644
2645 TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fuWinIni);
2646
2647 switch (uiAction)
2648 {
2649 case SPI_SETDESKWALLPAPER: /* 20 */
2650 case SPI_SETDESKPATTERN: /* 21 */
2651 {
2652 WCHAR buffer[256];
2653 if (pvParam)
2654 if (!MultiByteToWideChar( CP_ACP, 0, pvParam, -1, buffer,
2655 sizeof(buffer)/sizeof(WCHAR) ))
2656 buffer[sizeof(buffer)/sizeof(WCHAR)-1] = 0;
2657 ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? buffer : NULL, fuWinIni );
2658 break;
2659 }
2660
2661 case SPI_GETICONTITLELOGFONT: /* 31 */
2662 {
2663 LOGFONTW tmp;
2664 ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? &tmp : NULL, fuWinIni );
2665 if (ret && pvParam)
2666 SYSPARAMS_LogFont32WTo32A( &tmp, pvParam );
2667 break;
2668 }
2669
2670 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
2671 {
2672 NONCLIENTMETRICSW tmp;
2673 LPNONCLIENTMETRICSA lpnmA = pvParam;
2674 if (lpnmA && lpnmA->cbSize == sizeof(NONCLIENTMETRICSA))
2675 {
2676 tmp.cbSize = sizeof(NONCLIENTMETRICSW);
2677 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2678 if (ret)
2679 SYSPARAMS_NonClientMetrics32WTo32A( &tmp, lpnmA );
2680 }
2681 else
2682 ret = FALSE;
2683 break;
2684 }
2685
2686 case SPI_SETNONCLIENTMETRICS: /* 42 WINVER >= 0x400 */
2687 {
2688 NONCLIENTMETRICSW tmp;
2689 LPNONCLIENTMETRICSA lpnmA = pvParam;
2690 if (lpnmA && lpnmA->cbSize == sizeof(NONCLIENTMETRICSA))
2691 {
2692 tmp.cbSize = sizeof(NONCLIENTMETRICSW);
2693 SYSPARAMS_NonClientMetrics32ATo32W( lpnmA, &tmp );
2694 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2695 }
2696 else
2697 ret = FALSE;
2698 break;
2699 }
2700
2701 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
2702 {
2703 ICONMETRICSW tmp;
2704 LPICONMETRICSA lpimA = pvParam;
2705 if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
2706 {
2707 tmp.cbSize = sizeof(ICONMETRICSW);
2708 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2709 if (ret)
2710 {
2711 lpimA->iHorzSpacing = tmp.iHorzSpacing;
2712 lpimA->iVertSpacing = tmp.iVertSpacing;
2713 lpimA->iTitleWrap = tmp.iTitleWrap;
2714 SYSPARAMS_LogFont32WTo32A( &tmp.lfFont, &lpimA->lfFont );
2715 }
2716 }
2717 else
2718 ret = FALSE;
2719 break;
2720 }
2721
2722 case SPI_SETICONMETRICS: /* 46 WINVER >= 0x400 */
2723 {
2724 ICONMETRICSW tmp;
2725 LPICONMETRICSA lpimA = pvParam;
2726 if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
2727 {
2728 tmp.cbSize = sizeof(ICONMETRICSW);
2729 tmp.iHorzSpacing = lpimA->iHorzSpacing;
2730 tmp.iVertSpacing = lpimA->iVertSpacing;
2731 tmp.iTitleWrap = lpimA->iTitleWrap;
2732 SYSPARAMS_LogFont32ATo32W( &lpimA->lfFont, &tmp.lfFont);
2733 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2734 }
2735 else
2736 ret = FALSE;
2737 break;
2738 }
2739
2740 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
2741 {
2742 HIGHCONTRASTW tmp;
2743 LPHIGHCONTRASTA lphcA = pvParam;
2744 if (lphcA && lphcA->cbSize == sizeof(HIGHCONTRASTA))
2745 {
2746 tmp.cbSize = sizeof(HIGHCONTRASTW);
2747 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2748 if (ret)
2749 {
2750 lphcA->dwFlags = tmp.dwFlags;
2751 lphcA->lpszDefaultScheme = NULL; /* FIXME? */
2752 }
2753 }
2754 else
2755 ret = FALSE;
2756 break;
2757 }
2758
2759 case SPI_GETDESKWALLPAPER: /* 115 */
2760 {
2761 WCHAR buffer[MAX_PATH];
2762 ret = (SystemParametersInfoW( SPI_GETDESKWALLPAPER, uiParam, buffer, fuWinIni ) &&
2763 WideCharToMultiByte(CP_ACP, 0, buffer, -1, pvParam, uiParam, NULL, NULL));
2764 break;
2765 }
2766
2767 default:
2768 ret = SystemParametersInfoW( uiAction, uiParam, pvParam, fuWinIni );
2769 break;
2770 }
2771 return ret;
2772 }
2773
2774
2775 /***********************************************************************
2776 * GetSystemMetrics (USER32.@)
2777 */
2778 INT WINAPI GetSystemMetrics( INT index )
2779 {
2780 UINT ret;
2781
2782 /* some metrics are dynamic */
2783 switch (index)
2784 {
2785 case SM_CXSCREEN:
2786 return GetDeviceCaps( get_display_dc(), HORZRES );
2787 case SM_CYSCREEN:
2788 return GetDeviceCaps( get_display_dc(), VERTRES );
2789 case SM_CXVSCROLL:
2790 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2791 return nonclient_metrics.iScrollWidth;
2792 case SM_CYHSCROLL:
2793 return GetSystemMetrics(SM_CXVSCROLL);
2794 case SM_CYCAPTION:
2795 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2796 return nonclient_metrics.iCaptionHeight + 1;
2797 case SM_CXBORDER:
2798 case SM_CYBORDER:
2799 /* SM_C{X,Y}BORDER always returns 1 regardless of 'BorderWidth' value in registry */
2800 return 1;
2801 case SM_CXDLGFRAME:
2802 case SM_CYDLGFRAME:
2803 return 3;
2804 case SM_CYVTHUMB:
2805 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2806 return nonclient_metrics.iScrollHeight;
2807 case SM_CXHTHUMB:
2808 return GetSystemMetrics(SM_CYVTHUMB);
2809 case SM_CXICON:
2810 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2811 return icon_size.cx;
2812 case SM_CYICON:
2813 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2814 return icon_size.cy;
2815 case SM_CXCURSOR:
2816 case SM_CYCURSOR:
2817 return 32;
2818 case SM_CYMENU:
2819 return GetSystemMetrics(SM_CYMENUSIZE) + 1;
2820 case SM_CXFULLSCREEN:
2821 /* see the remark for SM_CXMAXIMIZED, at least this formulation is
2822 * correct */
2823 return GetSystemMetrics( SM_CXMAXIMIZED) - 2 * GetSystemMetrics( SM_CXFRAME);
2824 case SM_CYFULLSCREEN:
2825 /* see the remark for SM_CYMAXIMIZED, at least this formulation is
2826 * correct */
2827 return GetSystemMetrics( SM_CYMAXIMIZED) - GetSystemMetrics( SM_CYMIN);
2828 case SM_CYKANJIWINDOW:
2829 return 0;
2830 case SM_MOUSEPRESENT:
2831 return 1;
2832 case SM_CYVSCROLL:
2833 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2834 return nonclient_metrics.iScrollHeight;
2835 case SM_CXHSCROLL:
2836 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2837 return nonclient_metrics.iScrollHeight;
2838 case SM_DEBUG:
2839 return 0;
2840 case SM_SWAPBUTTON:
2841 get_bool_param( SPI_SETMOUSEBUTTONSWAP_IDX, SPI_SETMOUSEBUTTONSWAP_REGKEY,
2842 SPI_SETMOUSEBUTTONSWAP_VALNAME, &swap_buttons, (BOOL*)&ret );
2843 return ret;
2844 case SM_RESERVED1:
2845 case SM_RESERVED2:
2846 case SM_RESERVED3:
2847 case SM_RESERVED4:
2848 return 0;
2849 case SM_CXMIN:
2850 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2851 return 3 * nonclient_metrics.iCaptionWidth + GetSystemMetrics( SM_CYSIZE) +
2852 4 * CaptionFontAvCharWidth + 2 * GetSystemMetrics( SM_CXFRAME) + 4;
2853 case SM_CYMIN:
2854 return GetSystemMetrics( SM_CYCAPTION) + 2 * GetSystemMetrics( SM_CYFRAME);
2855 case SM_CXSIZE:
2856 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2857 return nonclient_metrics.iCaptionWidth;
2858 case SM_CYSIZE:
2859 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2860 return nonclient_metrics.iCaptionHeight;
2861 case SM_CXFRAME:
2862 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2863 return GetSystemMetrics(SM_CXDLGFRAME) + nonclient_metrics.iBorderWidth;
2864 case SM_CYFRAME:
2865 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2866 return GetSystemMetrics(SM_CYDLGFRAME) + nonclient_metrics.iBorderWidth;
2867 case SM_CXMINTRACK:
2868 return GetSystemMetrics(SM_CXMIN);
2869 case SM_CYMINTRACK:
2870 return GetSystemMetrics(SM_CYMIN);
2871 case SM_CXDOUBLECLK:
2872 get_uint_param( SPI_SETDOUBLECLKWIDTH_IDX, SPI_SETDOUBLECLKWIDTH_REGKEY1,
2873 SPI_SETDOUBLECLKWIDTH_VALNAME, &double_click_width, &ret );
2874 return ret;
2875 case SM_CYDOUBLECLK:
2876 get_uint_param( SPI_SETDOUBLECLKHEIGHT_IDX, SPI_SETDOUBLECLKHEIGHT_REGKEY1,
2877 SPI_SETDOUBLECLKHEIGHT_VALNAME, &double_click_height, &ret );
2878 return ret;
2879 case SM_CXICONSPACING:
2880 SystemParametersInfoW( SPI_ICONHORIZONTALSPACING, 0, &ret, 0 );
2881 return ret;
2882 case SM_CYICONSPACING:
2883 SystemParametersInfoW( SPI_ICONVERTICALSPACING, 0, &ret, 0 );
2884 return ret;
2885 case SM_MENUDROPALIGNMENT:
2886 SystemParametersInfoW( SPI_GETMENUDROPALIGNMENT, 0, &ret, 0 );
2887 return ret;
2888 case SM_PENWINDOWS:
2889 return 0;
2890 case SM_DBCSENABLED:
2891 {
2892 CPINFO cpinfo;
2893 GetCPInfo( CP_ACP, &cpinfo );
2894 return (cpinfo.MaxCharSize > 1);
2895 }
2896 case SM_CMOUSEBUTTONS:
2897 return 3;
2898 case SM_SECURE:
2899 return 0;
2900 case SM_CXEDGE:
2901 return GetSystemMetrics(SM_CXBORDER) + 1;
2902 case SM_CYEDGE:
2903 return GetSystemMetrics(SM_CYBORDER) + 1;
2904 case SM_CXMINSPACING:
2905 if( spi_loaded[SPI_MINIMIZEDMETRICS_IDX]) load_minimized_metrics();
2906 return GetSystemMetrics(SM_CXMINIMIZED) + minimized_metrics.iHorzGap;
2907 case SM_CYMINSPACING:
2908 if( spi_loaded[SPI_MINIMIZEDMETRICS_IDX]) load_minimized_metrics();
2909 return GetSystemMetrics(SM_CYMINIMIZED) + minimized_metrics.iVertGap;
2910 case SM_CXSMICON:
2911 case SM_CYSMICON:
2912 return 16;
2913 case SM_CYSMCAPTION:
2914 return GetSystemMetrics(SM_CYSMSIZE) + 1;
2915 case SM_CXSMSIZE:
2916 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2917 return nonclient_metrics.iSmCaptionWidth;
2918 case SM_CYSMSIZE:
2919 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2920 return nonclient_metrics.iSmCaptionHeight;
2921 case SM_CXMENUSIZE:
2922 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2923 return nonclient_metrics.iMenuWidth;
2924 case SM_CYMENUSIZE:
2925 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2926 return nonclient_metrics.iMenuHeight;
2927 case SM_ARRANGE:
2928 if( spi_loaded[SPI_MINIMIZEDMETRICS_IDX]) load_minimized_metrics();
2929 return minimized_metrics.iArrange;
2930 case SM_CXMINIMIZED:
2931 if( spi_loaded[SPI_MINIMIZEDMETRICS_IDX]) load_minimized_metrics();
2932 return minimized_metrics.iWidth + 6;
2933 case SM_CYMINIMIZED:
2934 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2935 return nonclient_metrics.iCaptionHeight + 6;
2936 case SM_CXMAXTRACK:
2937 return GetSystemMetrics(SM_CXVIRTUALSCREEN) + 4 + 2 * GetSystemMetrics(SM_CXFRAME);
2938 case SM_CYMAXTRACK:
2939 return GetSystemMetrics(SM_CYVIRTUALSCREEN) + 4 + 2 * GetSystemMetrics(SM_CYFRAME);
2940 case SM_CXMAXIMIZED:
2941 /* FIXME: subtract the width of any vertical application toolbars*/
2942 return GetSystemMetrics(SM_CXSCREEN) + 2 * GetSystemMetrics(SM_CXFRAME);
2943 case SM_CYMAXIMIZED:
2944 /* FIXME: subtract the width of any horizontal application toolbars*/
2945 return GetSystemMetrics(SM_CYSCREEN) + 2 * GetSystemMetrics(SM_CYCAPTION);
2946 case SM_NETWORK:
2947 return 3; /* FIXME */
2948 case SM_CLEANBOOT:
2949 return 0; /* 0 = ok, 1 = failsafe, 2 = failsafe + network */
2950 case SM_CXDRAG:
2951 case SM_CYDRAG:
2952 return 4;
2953 case SM_SHOWSOUNDS:
2954 SystemParametersInfoW( SPI_GETSHOWSOUNDS, 0, &ret, 0 );
2955 return ret;
2956 case SM_CXMENUCHECK:
2957 case SM_CYMENUCHECK:
2958 if (!spi_loaded[SPI_NONCLIENTMETRICS_IDX]) load_nonclient_metrics();
2959 return tmMenuFont.tmHeight <= 0 ? 13 :
2960 ((tmMenuFont.tmHeight + tmMenuFont.tmExternalLeading + 1) / 2) * 2 - 1;
2961 case SM_SLOWMACHINE:
2962 return 0; /* Never true */
2963 case SM_MIDEASTENABLED:
2964 return 0; /* FIXME */
2965 case SM_MOUSEWHEELPRESENT:
2966 return 1;
2967 case SM_XVIRTUALSCREEN:
2968 {
2969 struct monitor_info info;
2970 get_monitors_info( &info );
2971 return info.virtual_rect.left;
2972 }
2973 case SM_YVIRTUALSCREEN:
2974 {
2975 struct monitor_info info;
2976 get_monitors_info( &info );
2977 return info.virtual_rect.top;
2978 }
2979 case SM_CXVIRTUALSCREEN:
2980 {
2981 struct monitor_info info;
2982 get_monitors_info( &info );
2983 return info.virtual_rect.right - info.virtual_rect.left;
2984 }
2985 case SM_CYVIRTUALSCREEN:
2986 {
2987 struct monitor_info info;
2988 get_monitors_info( &info );
2989 return info.virtual_rect.bottom - info.virtual_rect.top;
2990 }
2991 case SM_CMONITORS:
2992 {
2993 struct monitor_info info;
2994 get_monitors_info( &info );
2995 return info.count;
2996 }
2997 case SM_SAMEDISPLAYFORMAT:
2998 return 1;
2999 case SM_IMMENABLED:
3000 return 0; /* FIXME */
3001 case SM_CXFOCUSBORDER:
3002 case SM_CYFOCUSBORDER:
3003 return 1;
3004 case SM_TABLETPC:
3005 case SM_MEDIACENTER:
3006 return 0;
3007 case SM_CMETRICS:
3008 return SM_CMETRICS;
3009 default:
3010 return 0;
3011 }
3012 }
3013
3014
3015 /***********************************************************************
3016 * SwapMouseButton (USER32.@)
3017 * Reverse or restore the meaning of the left and right mouse buttons
3018 * fSwap [I ] TRUE - reverse, FALSE - original
3019 * RETURN
3020 * previous state
3021 */
3022 BOOL WINAPI SwapMouseButton( BOOL fSwap )
3023 {
3024 BOOL prev = GetSystemMetrics(SM_SWAPBUTTON);
3025 SystemParametersInfoW(SPI_SETMOUSEBUTTONSWAP, fSwap, 0, 0);
3026 return prev;
3027 }
3028
3029
3030 /**********************************************************************
3031 * SetDoubleClickTime (USER32.@)
3032 */
3033 BOOL WINAPI SetDoubleClickTime( UINT interval )
3034 {
3035 return SystemParametersInfoW(SPI_SETDOUBLECLICKTIME, interval, 0, 0);
3036 }
3037
3038
3039 /**********************************************************************
3040 * GetDoubleClickTime (USER32.@)
3041 */
3042 UINT WINAPI GetDoubleClickTime(void)
3043 {
3044 UINT time = 0;
3045
3046 get_uint_param( SPI_SETDOUBLECLICKTIME_IDX,
3047 SPI_SETDOUBLECLICKTIME_REGKEY,
3048 SPI_SETDOUBLECLICKTIME_VALNAME,
3049 &double_click_time, &time );
3050 if (!time) time = 500;
3051 return time;
3052 }
3053
3054
3055 /*************************************************************************
3056 * GetSysColor (USER32.@)
3057 */
3058 COLORREF WINAPI GetSysColor( INT nIndex )
3059 {
3060 if (nIndex >= 0 && nIndex < NUM_SYS_COLORS)
3061 return SysColors[nIndex];
3062 else
3063 return 0;
3064 }
3065
3066
3067 /*************************************************************************
3068 * SetSysColors (USER32.@)
3069 */
3070 BOOL WINAPI SetSysColors( INT nChanges, const INT *lpSysColor,
3071 const COLORREF *lpColorValues )
3072 {
3073 int i;
3074
3075 for (i = 0; i < nChanges; i++) SYSPARAMS_SetSysColor( lpSysColor[i], lpColorValues[i] );
3076
3077 /* Send WM_SYSCOLORCHANGE message to all windows */
3078
3079 SendMessageTimeoutW( HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0, SMTO_ABORTIFHUNG, 2000, NULL );
3080
3081 /* Repaint affected portions of all visible windows */
3082
3083 RedrawWindow( GetDesktopWindow(), NULL, 0,
3084 RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN );
3085 return TRUE;
3086 }
3087
3088
3089 /*************************************************************************
3090 * SetSysColorsTemp (USER32.@)
3091 *
3092 * UNDOCUMENTED !!
3093 *
3094 * Called by W98SE desk.cpl Control Panel Applet:
3095 * handle = SetSysColorsTemp(ptr, ptr, nCount); ("set" call)
3096 * result = SetSysColorsTemp(NULL, NULL, handle); ("restore" call)
3097 *
3098 * pPens is an array of COLORREF values, which seems to be used
3099 * to indicate the color values to create new pens with.
3100 *
3101 * pBrushes is an array of solid brush handles (returned by a previous
3102 * CreateSolidBrush), which seems to contain the brush handles to set
3103 * for the system colors.
3104 *
3105 * n seems to be used for
3106 * a) indicating the number of entries to operate on (length of pPens,
3107 * pBrushes)
3108 * b) passing the handle that points to the previously used color settings.
3109 * I couldn't figure out in hell what kind of handle this is on
3110 * Windows. I just use a heap handle instead. Shouldn't matter anyway.
3111 *
3112 * RETURNS
3113 * heap handle of our own copy of the current syscolors in case of
3114 * "set" call, i.e. pPens, pBrushes != NULL.
3115 * TRUE (unconditionally !) in case of "restore" call,
3116 * i.e. pPens, pBrushes == NULL.
3117 * FALSE in case of either pPens != NULL and pBrushes == NULL
3118 * or pPens == NULL and pBrushes != NULL.
3119 *
3120 * I'm not sure whether this implementation is 100% correct. [AM]
3121 */
3122 DWORD WINAPI SetSysColorsTemp( const COLORREF *pPens, const HBRUSH *pBrushes, DWORD n)
3123 {
3124 DWORD i;
3125
3126 if (pPens && pBrushes) /* "set" call */
3127 {
3128 /* allocate our structure to remember old colors */
3129 LPVOID pOldCol = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)+n*sizeof(HPEN)+n*sizeof(HBRUSH));
3130 LPVOID p = pOldCol;
3131 *(DWORD *)p = n; p = (char*)p + sizeof(DWORD);
3132 memcpy(p, SysColorPens, n*sizeof(HPEN)); p = (char*)p + n*sizeof(HPEN);
3133 memcpy(p, SysColorBrushes, n*sizeof(HBRUSH)); p = (char*)p + n*sizeof(HBRUSH);
3134
3135 for (i=0; i < n; i++)
3136 {
3137 SysColorPens[i] = CreatePen( PS_SOLID, 1, pPens[i] );
3138 SysColorBrushes[i] = pBrushes[i];
3139 }
3140
3141 return (DWORD)pOldCol; /* FIXME: pointer truncation */
3142 }
3143 if (!pPens && !pBrushes) /* "restore" call */
3144 {
3145 LPVOID pOldCol = (LPVOID)n; /* FIXME: not 64-bit safe */
3146 LPVOID p = pOldCol;
3147 DWORD nCount = *(DWORD *)p;
3148 p = (char*)p + sizeof(DWORD);
3149
3150 for (i=0; i < nCount; i++)
3151 {
3152 DeleteObject(SysColorPens[i]);
3153 SysColorPens[i] = *(HPEN *)p; p = (char*)p + sizeof(HPEN);
3154 }
3155 for (i=0; i < nCount; i++)
3156 {
3157 SysColorBrushes[i] = *(HBRUSH *)p; p = (char*)p + sizeof(HBRUSH);
3158 }
3159 /* get rid of storage structure */
3160 HeapFree(GetProcessHeap(), 0, pOldCol);
3161
3162 return TRUE;
3163 }
3164 return FALSE;
3165 }
3166
3167
3168 /***********************************************************************
3169 * GetSysColorBrush (USER32.@)
3170 */
3171 HBRUSH WINAPI GetSysColorBrush( INT index )
3172 {
3173 if (0 <= index && index < NUM_SYS_COLORS) return SysColorBrushes[index];
3174 WARN("Unknown index(%d)\n", index );
3175 return GetStockObject(LTGRAY_BRUSH);
3176 }
3177
3178
3179 /***********************************************************************
3180 * SYSCOLOR_GetPen
3181 */
3182 HPEN SYSCOLOR_GetPen( INT index )
3183 {
3184 /* We can assert here, because this function is internal to Wine */
3185 assert (0 <= index && index < NUM_SYS_COLORS);
3186 return SysColorPens[index];
3187 }
3188
3189
3190 /***********************************************************************
3191 * ChangeDisplaySettingsA (USER32.@)
3192 */
3193 LONG WINAPI ChangeDisplaySettingsA( LPDEVMODEA devmode, DWORD flags )
3194 {
3195 if (devmode) devmode->dmDriverExtra = 0;
3196
3197 return ChangeDisplaySettingsExA(NULL,devmode,NULL,flags,NULL);
3198 }
3199
3200
3201 /***********************************************************************
3202 * ChangeDisplaySettingsW (USER32.@)
3203 */
3204 LONG WINAPI ChangeDisplaySettingsW( LPDEVMODEW devmode, DWORD flags )
3205 {
3206 if (devmode) devmode->dmDriverExtra = 0;
3207
3208 return ChangeDisplaySettingsExW(NULL,devmode,NULL,flags,NULL);
3209 }
3210
3211
3212 /***********************************************************************
3213 * ChangeDisplaySettingsExA (USER32.@)
3214 */
3215 LONG WINAPI ChangeDisplaySettingsExA( LPCSTR devname, LPDEVMODEA devmode, HWND hwnd,
3216 DWORD flags, LPVOID lparam )
3217 {
3218 LONG ret;
3219 UNICODE_STRING nameW;
3220
3221 if (devname) RtlCreateUnicodeStringFromAsciiz(&nameW, devname);
3222 else nameW.Buffer = NULL;
3223
3224 if (devmode)
3225 {
3226 DEVMODEW *devmodeW;
3227
3228 devmodeW = GdiConvertToDevmodeW(devmode);
3229 if (devmodeW)
3230 {
3231 ret = ChangeDisplaySettingsExW(nameW.Buffer, devmodeW, hwnd, flags, lparam);
3232 HeapFree(GetProcessHeap(), 0, devmodeW);
3233 }
3234 else
3235 ret = DISP_CHANGE_SUCCESSFUL;
3236 }
3237 else
3238 {
3239 ret = ChangeDisplaySettingsExW(nameW.Buffer, NULL, hwnd, flags, lparam);
3240 }
3241
3242 if (devname) RtlFreeUnicodeString(&nameW);
3243 return ret;
3244 }
3245
3246
3247 /***********************************************************************
3248 * ChangeDisplaySettingsExW (USER32.@)
3249 */
3250 LONG WINAPI ChangeDisplaySettingsExW( LPCWSTR devname, LPDEVMODEW devmode, HWND hwnd,
3251 DWORD flags, LPVOID lparam )
3252 {
3253 /* make sure the desktop window is created before mode changing */
3254 GetDesktopWindow();
3255
3256 return USER_Driver->pChangeDisplaySettingsEx( devname, devmode, hwnd, flags, lparam );
3257 }
3258
3259
3260 /***********************************************************************
3261 * EnumDisplaySettingsW (USER32.@)
3262 *
3263 * RETURNS
3264 * TRUE if nth setting exists found (described in the LPDEVMODEW struct)
3265 * FALSE if we do not have the nth setting
3266 */
3267 BOOL WINAPI EnumDisplaySettingsW( LPCWSTR name, DWORD n, LPDEVMODEW devmode )
3268 {
3269 return EnumDisplaySettingsExW(name, n, devmode, 0);
3270 }
3271
3272
3273 /***********************************************************************
3274 * EnumDisplaySettingsA (USER32.@)
3275 */
3276 BOOL WINAPI EnumDisplaySettingsA(LPCSTR name,DWORD n,LPDEVMODEA devmode)
3277 {
3278 return EnumDisplaySettingsExA(name, n, devmode, 0);
3279 }
3280
3281
3282 /***********************************************************************
3283 * EnumDisplaySettingsExA (USER32.@)
3284 */
3285 BOOL WINAPI EnumDisplaySettingsExA(LPCSTR lpszDeviceName, DWORD iModeNum,
3286 LPDEVMODEA lpDevMode, DWORD dwFlags)
3287 {
3288 DEVMODEW devmodeW;
3289 BOOL ret;
3290 UNICODE_STRING nameW;
3291
3292 if (lpszDeviceName) RtlCreateUnicodeStringFromAsciiz(&nameW, lpszDeviceName);
3293 else nameW.Buffer = NULL;
3294
3295 ret = EnumDisplaySettingsExW(nameW.Buffer,iModeNum,&devmodeW,dwFlags);
3296 if (ret)
3297 {
3298 lpDevMode->dmSize = FIELD_OFFSET(DEVMODEA, dmICMMethod);
3299 lpDevMode->dmSpecVersion = devmodeW.dmSpecVersion;
3300 lpDevMode->dmDriverVersion = devmodeW.dmDriverVersion;
3301 WideCharToMultiByte(CP_ACP, 0, devmodeW.dmDeviceName, -1,
3302 (LPSTR)lpDevMode->dmDeviceName, CCHDEVICENAME, NULL, NULL);
3303 lpDevMode->dmDriverExtra = 0; /* FIXME */
3304 lpDevMode->dmBitsPerPel = devmodeW.dmBitsPerPel;
3305 lpDevMode->dmPelsHeight = devmodeW.dmPelsHeight;
3306 lpDevMode->dmPelsWidth = devmodeW.dmPelsWidth;
3307 lpDevMode->u2.dmDisplayFlags = devmodeW.u2.dmDisplayFlags;
3308 lpDevMode->dmDisplayFrequency = devmodeW.dmDisplayFrequency;
3309 lpDevMode->dmFields = devmodeW.dmFields;
3310
3311 lpDevMode->u1.s2.dmPosition.x = devmodeW.u1.s2.dmPosition.x;
3312 lpDevMode->u1.s2.dmPosition.y = devmodeW.u1.s2.dmPosition.y;
3313 lpDevMode->u1.s2.dmDisplayOrientation = devmodeW.u1.s2.dmDisplayOrientation;
3314 lpDevMode->u1.s2.dmDisplayFixedOutput = devmodeW.u1.s2.dmDisplayFixedOutput;
3315 }
3316 if (lpszDeviceName) RtlFreeUnicodeString(&nameW);
3317 return ret;
3318 }
3319
3320
3321 /***********************************************************************
3322 * EnumDisplaySettingsExW (USER32.@)
3323 */
3324 BOOL WINAPI EnumDisplaySettingsExW(LPCWSTR lpszDeviceName, DWORD iModeNum,
3325 LPDEVMODEW lpDevMode, DWORD dwFlags)
3326 {
3327 /* make sure the desktop window is created before mode enumeration */
3328 GetDesktopWindow();
3329
3330 return USER_Driver->pEnumDisplaySettingsEx(lpszDeviceName, iModeNum, lpDevMode, dwFlags);
3331 }
3332
3333 /***********************************************************************
3334 * SetProcessDPIAware (USER32.@)
3335 */
3336 BOOL WINAPI SetProcessDPIAware( VOID )
3337 {
3338 FIXME( "stub!\n");
3339
3340 return TRUE;
3341 }
useful hacks and other patches not (yet) suitable for mainline