Sync with trunk (48237)
[reactos.git] / base / applications / wordpad / registry.c
1 /*
2 * Wordpad implementation - Registry functions
3 *
4 * Copyright 2007 by Alexander N. Sørnes <alex@thehandofagony.com>
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 <windows.h>
22 #include <shlobj.h>
23 #include <richedit.h>
24
25 #include "wordpad.h"
26
27 static const WCHAR key_recentfiles[] = {'R','e','c','e','n','t',' ','f','i','l','e',
28 ' ','l','i','s','t',0};
29 static const WCHAR key_options[] = {'O','p','t','i','o','n','s',0};
30 static const WCHAR key_settings[] = {'S','e','t','t','i','n','g','s',0};
31 static const WCHAR key_rtf[] = {'R','T','F',0};
32 static const WCHAR key_text[] = {'T','e','x','t',0};
33
34 static const WCHAR var_file[] = {'F','i','l','e','%','d',0};
35 static const WCHAR var_framerect[] = {'F','r','a','m','e','R','e','c','t',0};
36 static const WCHAR var_barstate0[] = {'B','a','r','S','t','a','t','e','0',0};
37 static const WCHAR var_wrap[] = {'W','r','a','p',0};
38 static const WCHAR var_maximized[] = {'M','a','x','i','m','i','z','e','d',0};
39
40 static LRESULT registry_get_handle(HKEY *hKey, LPDWORD action, LPCWSTR subKey)
41 {
42 LONG ret;
43 static const WCHAR wszProgramKey[] = {'S','o','f','t','w','a','r','e','\\',
44 'M','i','c','r','o','s','o','f','t','\\',
45 'W','i','n','d','o','w','s','\\',
46 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
47 'A','p','p','l','e','t','s','\\',
48 'W','o','r','d','p','a','d',0};
49 LPWSTR key = (LPWSTR)wszProgramKey;
50
51 if(subKey)
52 {
53 WCHAR backslash[] = {'\\',0};
54 key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
55 (lstrlenW(wszProgramKey)+lstrlenW(subKey)+lstrlenW(backslash)+1)
56 *sizeof(WCHAR));
57
58 if(!key)
59 return 1;
60
61 lstrcpyW(key, wszProgramKey);
62 lstrcatW(key, backslash);
63 lstrcatW(key, subKey);
64 }
65
66 if(action)
67 {
68 ret = RegCreateKeyExW(HKEY_CURRENT_USER, key, 0, NULL, REG_OPTION_NON_VOLATILE,
69 KEY_READ | KEY_WRITE, NULL, hKey, action);
70 } else
71 {
72 ret = RegOpenKeyExW(HKEY_CURRENT_USER, key, 0, KEY_READ | KEY_WRITE, hKey);
73 }
74
75 if(subKey)
76 HeapFree(GetProcessHeap(), 0, key);
77
78 return ret;
79 }
80
81 void registry_set_options(HWND hMainWnd)
82 {
83 HKEY hKey = 0;
84 DWORD action;
85
86 if(registry_get_handle(&hKey, &action, key_options) == ERROR_SUCCESS)
87 {
88 WINDOWPLACEMENT wp;
89 DWORD isMaximized;
90
91 wp.length = sizeof(WINDOWPLACEMENT);
92 GetWindowPlacement(hMainWnd, &wp);
93 isMaximized = (wp.showCmd == SW_SHOWMAXIMIZED);
94
95 RegSetValueExW(hKey, var_framerect, 0, REG_BINARY, (LPBYTE)&wp.rcNormalPosition, sizeof(RECT));
96 RegSetValueExW(hKey, var_maximized, 0, REG_DWORD, (LPBYTE)&isMaximized, sizeof(DWORD));
97
98 registry_set_pagemargins(hKey);
99 RegCloseKey(hKey);
100 }
101
102 if(registry_get_handle(&hKey, &action, key_settings) == ERROR_SUCCESS)
103 {
104 registry_set_previewpages(hKey);
105 RegCloseKey(hKey);
106 }
107 }
108
109 void registry_read_winrect(RECT* rc)
110 {
111 HKEY hKey = 0;
112 DWORD size = sizeof(RECT);
113
114 if(registry_get_handle(&hKey, 0, key_options) != ERROR_SUCCESS ||
115 RegQueryValueExW(hKey, var_framerect, 0, NULL, (LPBYTE)rc, &size) !=
116 ERROR_SUCCESS || size != sizeof(RECT))
117 {
118 rc->top = 0;
119 rc->left = 0;
120 rc->bottom = 300;
121 rc->right = 600;
122 }
123
124 RegCloseKey(hKey);
125 }
126
127 void registry_read_maximized(DWORD *bMaximized)
128 {
129 HKEY hKey = 0;
130 DWORD size = sizeof(DWORD);
131
132 if(registry_get_handle(&hKey, 0, key_options) != ERROR_SUCCESS ||
133 RegQueryValueExW(hKey, var_maximized, 0, NULL, (LPBYTE)bMaximized, &size) !=
134 ERROR_SUCCESS || size != sizeof(DWORD))
135 {
136 *bMaximized = FALSE;
137 }
138
139 RegCloseKey(hKey);
140 }
141
142 static void truncate_path(LPWSTR file, LPWSTR out, LPWSTR pos1, LPWSTR pos2)
143 {
144 static const WCHAR dots[] = {'.','.','.',0};
145
146 *++pos1 = 0;
147
148 lstrcatW(out, file);
149 lstrcatW(out, dots);
150 lstrcatW(out, pos2);
151 }
152
153 static void format_filelist_filename(LPWSTR file, LPWSTR out)
154 {
155 LPWSTR pos_basename;
156 LPWSTR truncpos1, truncpos2;
157 WCHAR myDocs[MAX_STRING_LEN];
158
159 SHGetFolderPathW(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, (LPWSTR)&myDocs);
160 pos_basename = file_basename(file);
161 truncpos1 = NULL;
162 truncpos2 = NULL;
163
164 *(pos_basename-1) = 0;
165 if(!lstrcmpiW(file, myDocs) || (lstrlenW(pos_basename) > FILELIST_ENTRY_LENGTH))
166 {
167 truncpos1 = pos_basename;
168 *(pos_basename-1) = '\\';
169 } else
170 {
171 LPWSTR pos;
172 BOOL morespace = FALSE;
173
174 *(pos_basename-1) = '\\';
175
176 for(pos = file; pos < pos_basename; pos++)
177 {
178 if(*pos == '\\' || *pos == '/')
179 {
180 if(truncpos1)
181 {
182 if((pos - file + lstrlenW(pos_basename)) > FILELIST_ENTRY_LENGTH)
183 break;
184
185 truncpos1 = pos;
186 morespace = TRUE;
187 break;
188 }
189
190 if((pos - file + lstrlenW(pos_basename)) > FILELIST_ENTRY_LENGTH)
191 break;
192
193 truncpos1 = pos;
194 }
195 }
196
197 if(morespace)
198 {
199 for(pos = pos_basename; pos >= truncpos1; pos--)
200 {
201 if(*pos == '\\' || *pos == '/')
202 {
203 if((truncpos1 - file + lstrlenW(pos_basename) + pos_basename - pos) > FILELIST_ENTRY_LENGTH)
204 break;
205
206 truncpos2 = pos;
207 }
208 }
209 }
210 }
211
212 if(truncpos1 == pos_basename)
213 lstrcatW(out, pos_basename);
214 else if(truncpos1 == truncpos2 || !truncpos2)
215 lstrcatW(out, file);
216 else
217 truncate_path(file, out, truncpos1, truncpos2);
218 }
219
220 void registry_read_filelist(HWND hMainWnd)
221 {
222 HKEY hFileKey;
223
224 if(registry_get_handle(&hFileKey, 0, key_recentfiles) == ERROR_SUCCESS)
225 {
226 WCHAR itemText[MAX_PATH+3], buffer[MAX_PATH];
227 /* The menu item name is not the same as the file name, so we need to store
228 the file name here */
229 static WCHAR file1[MAX_PATH], file2[MAX_PATH], file3[MAX_PATH], file4[MAX_PATH];
230 WCHAR numFormat[] = {'&','%','d',' ',0};
231 LPWSTR pFile[] = {file1, file2, file3, file4};
232 DWORD pathSize = MAX_PATH*sizeof(WCHAR);
233 int i;
234 WCHAR key[6];
235 MENUITEMINFOW mi;
236 HMENU hMenu = GetMenu(hMainWnd);
237
238 mi.cbSize = sizeof(MENUITEMINFOW);
239 mi.fMask = MIIM_ID | MIIM_DATA | MIIM_STRING | MIIM_FTYPE;
240 mi.fType = MFT_STRING;
241 mi.dwTypeData = itemText;
242 mi.wID = ID_FILE_RECENT1;
243
244 RemoveMenu(hMenu, ID_FILE_RECENT_SEPARATOR, MF_BYCOMMAND);
245 for(i = 0; i < FILELIST_ENTRIES; i++)
246 {
247 wsprintfW(key, var_file, i+1);
248 RemoveMenu(hMenu, ID_FILE_RECENT1+i, MF_BYCOMMAND);
249 if(RegQueryValueExW(hFileKey, (LPWSTR)key, 0, NULL, (LPBYTE)pFile[i], &pathSize)
250 != ERROR_SUCCESS)
251 break;
252
253 mi.dwItemData = (ULONG_PTR)pFile[i];
254 wsprintfW(itemText, numFormat, i+1);
255
256 lstrcpyW(buffer, pFile[i]);
257
258 format_filelist_filename(buffer, itemText);
259
260 InsertMenuItemW(hMenu, ID_FILE_EXIT, FALSE, &mi);
261 mi.wID++;
262 pathSize = MAX_PATH*sizeof(WCHAR);
263 }
264 mi.fType = MFT_SEPARATOR;
265 mi.fMask = MIIM_FTYPE | MIIM_ID;
266 InsertMenuItemW(hMenu, ID_FILE_EXIT, FALSE, &mi);
267
268 RegCloseKey(hFileKey);
269 }
270 }
271
272 void registry_set_filelist(LPCWSTR newFile, HWND hMainWnd)
273 {
274 HKEY hKey;
275 DWORD action;
276
277 if(registry_get_handle(&hKey, &action, key_recentfiles) == ERROR_SUCCESS)
278 {
279 LPCWSTR pFiles[FILELIST_ENTRIES];
280 int i;
281 HMENU hMenu = GetMenu(hMainWnd);
282 MENUITEMINFOW mi;
283 WCHAR buffer[6];
284
285 mi.cbSize = sizeof(MENUITEMINFOW);
286 mi.fMask = MIIM_DATA;
287
288 for(i = 0; i < FILELIST_ENTRIES; i++)
289 pFiles[i] = NULL;
290
291 for(i = 0; GetMenuItemInfoW(hMenu, ID_FILE_RECENT1+i, FALSE, &mi); i++)
292 pFiles[i] = (LPWSTR)mi.dwItemData;
293
294 if(lstrcmpiW(newFile, pFiles[0]))
295 {
296 for(i = 0; pFiles[i] && i < FILELIST_ENTRIES; i++)
297 {
298 if(!lstrcmpiW(pFiles[i], newFile))
299 {
300 int j;
301 for(j = 0; pFiles[j] && j < i; j++)
302 {
303 pFiles[i-j] = pFiles[i-j-1];
304 }
305 pFiles[0] = NULL;
306 break;
307 }
308 }
309
310 if(!pFiles[0])
311 {
312 pFiles[0] = newFile;
313 } else
314 {
315 for(i = 0; i < FILELIST_ENTRIES-1; i++)
316 pFiles[FILELIST_ENTRIES-1-i] = pFiles[FILELIST_ENTRIES-2-i];
317
318 pFiles[0] = newFile;
319 }
320
321 for(i = 0; pFiles[i] && i < FILELIST_ENTRIES; i++)
322 {
323 wsprintfW(buffer, var_file, i+1);
324 RegSetValueExW(hKey, (LPWSTR)&buffer, 0, REG_SZ, (const BYTE*)pFiles[i],
325 (lstrlenW(pFiles[i])+1)*sizeof(WCHAR));
326 }
327 }
328 RegCloseKey(hKey);
329 }
330 registry_read_filelist(hMainWnd);
331 }
332
333 int reg_formatindex(WPARAM format)
334 {
335 return (format & SF_TEXT) ? 1 : 0;
336 }
337
338 void registry_read_options(void)
339 {
340 HKEY hKey;
341
342 if(registry_get_handle(&hKey, 0, key_options) != ERROR_SUCCESS)
343 registry_read_pagemargins(NULL);
344 else
345 {
346 registry_read_pagemargins(hKey);
347 RegCloseKey(hKey);
348 }
349
350 if(registry_get_handle(&hKey, 0, key_settings) != ERROR_SUCCESS) {
351 registry_read_previewpages(NULL);
352 } else {
353 registry_read_previewpages(hKey);
354 RegCloseKey(hKey);
355 }
356 }
357
358 static void registry_read_formatopts(int index, LPCWSTR key, DWORD barState[], DWORD wordWrap[])
359 {
360 HKEY hKey;
361 DWORD action = 0;
362 BOOL fetched = FALSE;
363 barState[index] = 0;
364 wordWrap[index] = 0;
365
366 if(registry_get_handle(&hKey, &action, key) != ERROR_SUCCESS)
367 return;
368
369 if(action == REG_OPENED_EXISTING_KEY)
370 {
371 DWORD size = sizeof(DWORD);
372
373 if(RegQueryValueExW(hKey, var_barstate0, 0, NULL, (LPBYTE)&barState[index],
374 &size) == ERROR_SUCCESS)
375 fetched = TRUE;
376 }
377
378 if(!fetched)
379 barState[index] = (1 << BANDID_TOOLBAR) | (1 << BANDID_FORMATBAR) | (1 << BANDID_RULER) | (1 << BANDID_STATUSBAR);
380
381 fetched = FALSE;
382 if(action == REG_OPENED_EXISTING_KEY)
383 {
384 DWORD size = sizeof(DWORD);
385 if(RegQueryValueExW(hKey, var_wrap, 0, NULL, (LPBYTE)&wordWrap[index],
386 &size) == ERROR_SUCCESS)
387 fetched = TRUE;
388 }
389
390 if (!fetched)
391 {
392 if(index == reg_formatindex(SF_RTF))
393 wordWrap[index] = ID_WORDWRAP_WINDOW;
394 else if(index == reg_formatindex(SF_TEXT))
395 wordWrap[index] = ID_WORDWRAP_NONE;
396 }
397
398 RegCloseKey(hKey);
399 }
400
401 void registry_read_formatopts_all(DWORD barState[], DWORD wordWrap[])
402 {
403 registry_read_formatopts(reg_formatindex(SF_RTF), key_rtf, barState, wordWrap);
404 registry_read_formatopts(reg_formatindex(SF_TEXT), key_text, barState, wordWrap);
405 }
406
407 static void registry_set_formatopts(int index, LPCWSTR key, DWORD barState[], DWORD wordWrap[])
408 {
409 HKEY hKey;
410 DWORD action = 0;
411
412 if(registry_get_handle(&hKey, &action, key) == ERROR_SUCCESS)
413 {
414 RegSetValueExW(hKey, var_barstate0, 0, REG_DWORD, (LPBYTE)&barState[index],
415 sizeof(DWORD));
416 RegSetValueExW(hKey, var_wrap, 0, REG_DWORD, (LPBYTE)&wordWrap[index],
417 sizeof(DWORD));
418 RegCloseKey(hKey);
419 }
420 }
421
422 void registry_set_formatopts_all(DWORD barState[], DWORD wordWrap[])
423 {
424 registry_set_formatopts(reg_formatindex(SF_RTF), key_rtf, barState, wordWrap);
425 registry_set_formatopts(reg_formatindex(SF_TEXT), key_text, barState, wordWrap);
426 }