[RAPPS] Update check, license type
[reactos.git] / reactos / base / applications / rapps / misc.cpp
1 /*
2 * PROJECT: ReactOS Applications Manager
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: base/applications/rapps/misc.cpp
5 * PURPOSE: Misc functions
6 * PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
7 * Ismael Ferreras Morezuelas (swyterzone+ros@gmail.com)
8 */
9
10 #include "rapps.h"
11 #include <atlsimpcoll.h>
12 #include <atlstr.h>
13
14 /* SESSION Operation */
15 #define EXTRACT_FILLFILELIST 0x00000001
16 #define EXTRACT_EXTRACTFILES 0x00000002
17
18 static HANDLE hLog = NULL;
19 WCHAR szCachedINISectionLocale[MAX_PATH] = L"Section.";
20 WCHAR szCachedINISectionLocaleNeutral[MAX_PATH] = {0};
21 BYTE bCachedSectionStatus = FALSE;
22
23 #define STR_VERSION_CURRENT L"CURRENT"
24
25 typedef struct
26 {
27 int erfOper;
28 int erfType;
29 BOOL fError;
30 } ERF, *PERF;
31
32 struct FILELIST
33 {
34 LPSTR FileName;
35 struct FILELIST *next;
36 BOOL DoExtract;
37 };
38
39 typedef struct
40 {
41 INT FileSize;
42 ERF Error;
43 struct FILELIST *FileList;
44 INT FileCount;
45 INT Operation;
46 CHAR Destination[MAX_PATH];
47 CHAR CurrentFile[MAX_PATH];
48 CHAR Reserved[MAX_PATH];
49 struct FILELIST *FilterList;
50 } SESSION;
51
52 typedef HRESULT(WINAPI *fnExtract)(SESSION *dest, LPCSTR szCabName);
53 fnExtract pfnExtract;
54
55
56 INT
57 GetSystemColorDepth(VOID)
58 {
59 DEVMODE pDevMode;
60 INT ColorDepth;
61
62 pDevMode.dmSize = sizeof(pDevMode);
63 pDevMode.dmDriverExtra = 0;
64
65 if (!EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &pDevMode))
66 {
67 /* TODO: Error message */
68 return ILC_COLOR;
69 }
70
71 switch (pDevMode.dmBitsPerPel)
72 {
73 case 32: ColorDepth = ILC_COLOR32; break;
74 case 24: ColorDepth = ILC_COLOR24; break;
75 case 16: ColorDepth = ILC_COLOR16; break;
76 case 8: ColorDepth = ILC_COLOR8; break;
77 case 4: ColorDepth = ILC_COLOR4; break;
78 default: ColorDepth = ILC_COLOR; break;
79 }
80
81 return ColorDepth;
82 }
83
84 int
85 GetWindowWidth(HWND hwnd)
86 {
87 RECT Rect;
88
89 GetWindowRect(hwnd, &Rect);
90 return (Rect.right - Rect.left);
91 }
92
93 int
94 GetWindowHeight(HWND hwnd)
95 {
96 RECT Rect;
97
98 GetWindowRect(hwnd, &Rect);
99 return (Rect.bottom - Rect.top);
100 }
101
102 int
103 GetClientWindowWidth(HWND hwnd)
104 {
105 RECT Rect;
106
107 GetClientRect(hwnd, &Rect);
108 return (Rect.right - Rect.left);
109 }
110
111 int
112 GetClientWindowHeight(HWND hwnd)
113 {
114 RECT Rect;
115
116 GetClientRect(hwnd, &Rect);
117 return (Rect.bottom - Rect.top);
118 }
119
120 VOID
121 CopyTextToClipboard(LPCWSTR lpszText)
122 {
123 HRESULT hr;
124
125 if (OpenClipboard(NULL))
126 {
127 HGLOBAL ClipBuffer;
128 WCHAR *Buffer;
129 DWORD cchBuffer;
130
131 EmptyClipboard();
132 cchBuffer = wcslen(lpszText) + 1;
133 ClipBuffer = GlobalAlloc(GMEM_DDESHARE, cchBuffer * sizeof(WCHAR));
134 Buffer = (PWCHAR)GlobalLock(ClipBuffer);
135 hr = StringCchCopyW(Buffer, cchBuffer, lpszText);
136 GlobalUnlock(ClipBuffer);
137
138 if (SUCCEEDED(hr))
139 SetClipboardData(CF_UNICODETEXT, ClipBuffer);
140
141 CloseClipboard();
142 }
143 }
144
145 VOID
146 SetWelcomeText(VOID)
147 {
148 WCHAR szText[MAX_STR_LEN*3];
149
150 LoadStringW(hInst, IDS_WELCOME_TITLE, szText, _countof(szText));
151 NewRichEditText(szText, CFE_BOLD);
152
153 LoadStringW(hInst, IDS_WELCOME_TEXT, szText, _countof(szText));
154 InsertRichEditText(szText, 0);
155
156 LoadStringW(hInst, IDS_WELCOME_URL, szText, _countof(szText));
157 InsertRichEditText(szText, CFM_LINK);
158 }
159
160 VOID
161 ShowPopupMenu(HWND hwnd, UINT MenuID, UINT DefaultItem)
162 {
163 HMENU hMenu = NULL;
164 HMENU hPopupMenu;
165 MENUITEMINFO mii;
166 POINT pt;
167
168 if (MenuID)
169 {
170 hMenu = LoadMenuW(hInst, MAKEINTRESOURCEW(MenuID));
171 hPopupMenu = GetSubMenu(hMenu, 0);
172 }
173 else
174 hPopupMenu = GetMenu(hwnd);
175
176 ZeroMemory(&mii, sizeof(mii));
177 mii.cbSize = sizeof(mii);
178 mii.fMask = MIIM_STATE;
179 GetMenuItemInfo(hPopupMenu, DefaultItem, FALSE, &mii);
180
181 if (!(mii.fState & MFS_GRAYED))
182 SetMenuDefaultItem(hPopupMenu, DefaultItem, FALSE);
183
184 GetCursorPos(&pt);
185
186 SetForegroundWindow(hwnd);
187 TrackPopupMenu(hPopupMenu, 0, pt.x, pt.y, 0, hMainWnd, NULL);
188
189 if (hMenu)
190 DestroyMenu(hMenu);
191 }
192
193 BOOL
194 StartProcess(LPWSTR lpPath, BOOL Wait)
195 {
196 PROCESS_INFORMATION pi;
197 STARTUPINFOW si;
198 DWORD dwRet;
199 MSG msg;
200
201 ZeroMemory(&si, sizeof(si));
202 si.cb = sizeof(si);
203 si.dwFlags = STARTF_USESHOWWINDOW;
204 si.wShowWindow = SW_SHOW;
205
206 if (!CreateProcessW(NULL, lpPath, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
207 {
208 return FALSE;
209 }
210
211 CloseHandle(pi.hThread);
212 if (Wait) EnableWindow(hMainWnd, FALSE);
213
214 while (Wait)
215 {
216 dwRet = MsgWaitForMultipleObjects(1, &pi.hProcess, FALSE, INFINITE, QS_ALLEVENTS);
217 if (dwRet == WAIT_OBJECT_0 + 1)
218 {
219 while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
220 {
221 TranslateMessage(&msg);
222 DispatchMessage(&msg);
223 }
224 }
225 else
226 {
227 if (dwRet == WAIT_OBJECT_0 || dwRet == WAIT_FAILED)
228 break;
229 }
230 }
231
232 CloseHandle(pi.hProcess);
233
234 if (Wait)
235 {
236 EnableWindow(hMainWnd, TRUE);
237 SetForegroundWindow(hMainWnd);
238 SetFocus(hMainWnd);
239 }
240
241 return TRUE;
242 }
243
244 BOOL
245 GetStorageDirectory(PWCHAR lpDirectory, DWORD cch)
246 {
247 if (cch < MAX_PATH)
248 return FALSE;
249
250 if (!SHGetSpecialFolderPathW(NULL, lpDirectory, CSIDL_LOCAL_APPDATA, TRUE))
251 return FALSE;
252
253 if (FAILED(StringCchCatW(lpDirectory, cch, L"\\rapps")))
254 return FALSE;
255
256 if (!CreateDirectoryW(lpDirectory, NULL) &&
257 GetLastError() != ERROR_ALREADY_EXISTS)
258 {
259 return FALSE;
260 }
261
262 return TRUE;
263 }
264
265 BOOL
266 ExtractFilesFromCab(LPWSTR lpCabName, LPWSTR lpOutputPath)
267 {
268 HINSTANCE hCabinetDll;
269 CHAR szCabName[MAX_PATH];
270 SESSION Dest;
271 HRESULT Result;
272
273 hCabinetDll = LoadLibraryW(L"cabinet.dll");
274 if (hCabinetDll)
275 {
276 pfnExtract = (fnExtract) GetProcAddress(hCabinetDll, "Extract");
277 if (pfnExtract)
278 {
279 ZeroMemory(&Dest, sizeof(Dest));
280
281 WideCharToMultiByte(CP_ACP, 0, lpOutputPath, -1, Dest.Destination, MAX_PATH, NULL, NULL);
282 WideCharToMultiByte(CP_ACP, 0, lpCabName, -1, szCabName, MAX_PATH, NULL, NULL);
283 Dest.Operation = EXTRACT_FILLFILELIST;
284
285 Result = pfnExtract(&Dest, szCabName);
286 if (Result == S_OK)
287 {
288 Dest.Operation = EXTRACT_EXTRACTFILES;
289 Result = pfnExtract(&Dest, szCabName);
290 if (Result == S_OK)
291 {
292 FreeLibrary(hCabinetDll);
293 return TRUE;
294 }
295 }
296 }
297 FreeLibrary(hCabinetDll);
298 }
299
300 return FALSE;
301 }
302
303 VOID
304 InitLogs(VOID)
305 {
306 WCHAR szBuf[MAX_PATH] = L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\ReactOS Application Manager";
307 WCHAR szPath[MAX_PATH];
308 DWORD dwCategoryNum = 1;
309 DWORD dwDisp, dwData;
310 HKEY hKey;
311
312 if (!SettingsInfo.bLogEnabled) return;
313
314 if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,
315 szBuf, 0, NULL,
316 REG_OPTION_NON_VOLATILE,
317 KEY_WRITE, NULL, &hKey, &dwDisp) != ERROR_SUCCESS)
318 {
319 return;
320 }
321
322 if (!GetModuleFileNameW(NULL, szPath, _countof(szPath)))
323 return;
324
325 if (RegSetValueExW(hKey,
326 L"EventMessageFile",
327 0,
328 REG_EXPAND_SZ,
329 (LPBYTE)szPath,
330 (DWORD)(wcslen(szPath) + 1) * sizeof(WCHAR)) != ERROR_SUCCESS)
331 {
332 RegCloseKey(hKey);
333 return;
334 }
335
336 dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE |
337 EVENTLOG_INFORMATION_TYPE;
338
339 if (RegSetValueExW(hKey,
340 L"TypesSupported",
341 0,
342 REG_DWORD,
343 (LPBYTE)&dwData,
344 sizeof(DWORD)) != ERROR_SUCCESS)
345 {
346 RegCloseKey(hKey);
347 return;
348 }
349
350 if (RegSetValueExW(hKey,
351 L"CategoryMessageFile",
352 0,
353 REG_EXPAND_SZ,
354 (LPBYTE)szPath,
355 (DWORD)(wcslen(szPath) + 1) * sizeof(WCHAR)) != ERROR_SUCCESS)
356 {
357 RegCloseKey(hKey);
358 return;
359 }
360
361 if (RegSetValueExW(hKey,
362 L"CategoryCount",
363 0,
364 REG_DWORD,
365 (LPBYTE)&dwCategoryNum,
366 sizeof(DWORD)) != ERROR_SUCCESS)
367 {
368 RegCloseKey(hKey);
369 return;
370 }
371
372 RegCloseKey(hKey);
373
374 hLog = RegisterEventSourceW(NULL, L"ReactOS Application Manager");
375 }
376
377
378 VOID
379 FreeLogs(VOID)
380 {
381 if (hLog) DeregisterEventSource(hLog);
382 }
383
384
385 BOOL
386 WriteLogMessage(WORD wType, DWORD dwEventID, LPWSTR lpMsg)
387 {
388 if (!SettingsInfo.bLogEnabled) return TRUE;
389
390 if (!ReportEventW(hLog,
391 wType,
392 0,
393 dwEventID,
394 NULL,
395 1,
396 0,
397 (LPCWSTR*)&lpMsg,
398 NULL))
399 {
400 return FALSE;
401 }
402
403 return TRUE;
404 }
405
406
407 LPWSTR GetINIFullPath(LPCWSTR lpFileName)
408 {
409 WCHAR szDir[MAX_PATH];
410 static WCHAR szBuffer[MAX_PATH];
411
412 GetStorageDirectory(szDir, _countof(szDir));
413 StringCbPrintfW(szBuffer, sizeof(szBuffer), L"%ls\\rapps\\%ls", szDir, lpFileName);
414
415 return szBuffer;
416 }
417
418
419 UINT ParserGetString(LPCWSTR lpKeyName, LPWSTR lpReturnedString, UINT nSize, LPCWSTR lpFileName)
420 {
421 PWSTR lpFullFileName = GetINIFullPath(lpFileName);
422 DWORD dwResult;
423
424 /* we don't have cached section strings for the current system language, create them */
425 if(bCachedSectionStatus == FALSE)
426 {
427 WCHAR szLocale[4 + 1];
428 DWORD len;
429
430 /* find out what is the current system lang code (e.g. "0a") and append it to SectionLocale */
431 GetLocaleInfoW(GetUserDefaultLCID(), LOCALE_ILANGUAGE,
432 szLocale, _countof(szLocale));
433
434 StringCbCatW(szCachedINISectionLocale, sizeof(szCachedINISectionLocale), szLocale);
435
436 /* copy the locale-dependent string into the buffer of the future neutral one */
437 StringCbCopyW(szCachedINISectionLocaleNeutral,
438 sizeof(szCachedINISectionLocaleNeutral),
439 szCachedINISectionLocale);
440
441 /* turn "Section.0c0a" into "Section.0a", keeping just the neutral lang part */
442 len = wcslen(szCachedINISectionLocale);
443
444 memmove((szCachedINISectionLocaleNeutral + len) - 4,
445 (szCachedINISectionLocaleNeutral + len) - 2,
446 (2 * sizeof(WCHAR)) + sizeof(UNICODE_NULL));
447
448 /* finally, mark us as cache-friendly for the next time */
449 bCachedSectionStatus = TRUE;
450 }
451
452 /* 1st - find localized strings (e.g. "Section.0c0a") */
453 dwResult = GetPrivateProfileStringW(szCachedINISectionLocale,
454 lpKeyName,
455 NULL,
456 lpReturnedString,
457 nSize,
458 lpFullFileName);
459
460 if (dwResult != 0)
461 return TRUE;
462
463 /* 2nd - if they weren't present check for neutral sub-langs/ generic translations (e.g. "Section.0a") */
464 dwResult = GetPrivateProfileStringW(szCachedINISectionLocaleNeutral,
465 lpKeyName,
466 NULL,
467 lpReturnedString,
468 nSize,
469 lpFullFileName);
470
471 if (dwResult != 0)
472 return TRUE;
473
474 /* 3rd - if they weren't present fallback to standard english strings (just "Section") */
475 dwResult = GetPrivateProfileStringW(L"Section",
476 lpKeyName,
477 NULL,
478 lpReturnedString,
479 nSize,
480 lpFullFileName);
481
482 return (dwResult != 0 ? TRUE : FALSE);
483 }
484
485 UINT ParserGetInt(LPCWSTR lpKeyName, LPCWSTR lpFileName)
486 {
487 WCHAR Buffer[30];
488 UNICODE_STRING BufferW;
489 ULONG Result;
490
491 /* grab the text version of our entry */
492 if (!ParserGetString(lpKeyName, Buffer, _countof(Buffer), lpFileName))
493 return FALSE;
494
495 if (!Buffer[0])
496 return FALSE;
497
498 /* convert it to an actual integer */
499 RtlInitUnicodeString(&BufferW, Buffer);
500 RtlUnicodeStringToInteger(&BufferW, 0, &Result);
501
502 return (UINT)Result;
503 }
504
505 template<typename XCHAR>
506 inline BOOL IsCharNumeric(XCHAR ch)
507 {
508 return IsCharAlphaNumeric(ch) && !IsCharAlpha(ch);
509 }
510
511
512 //Parses version string that can be formatted as 1.2.3-4b (or CURRENT)
513 //Returns int buffer and it's size
514 BOOL
515 ParseVersion(_In_z_ LPCWSTR szVersion, _Outptr_ PVERSION_INFO Version)
516 {
517 ATL::CStringW szVersionSingleInt = L"";
518 BOOL bHasParsed = TRUE;
519 INT VersionCharCount = 0;
520 INT VersionLength = lstrlenW(szVersion);
521 StringCbCopyW(Version->szVersion, VersionLength * sizeof(szVersion), szVersion);
522 //CURRENT
523 if (!StrCmpW(szVersion, STR_VERSION_CURRENT))
524 {
525 Version->VersionSize = NULL;
526 return bHasParsed;
527 }
528
529 Version->VersionSize = 0;
530 //int expected every iteration, quit the loop if its not a number
531 while (Version->VersionSize < MAX_VERSION
532 && IsCharNumeric(szVersion[VersionCharCount])
533 && VersionCharCount < VersionLength)
534 {
535 for (; IsCharNumeric(szVersion[VersionCharCount]) && VersionCharCount < VersionLength; ++VersionCharCount)
536 {
537 szVersionSingleInt += szVersion[VersionCharCount];
538 }
539 if (szVersionSingleInt.IsEmpty())
540 {
541 bHasParsed = FALSE;
542 continue;
543 }
544 INT IntResult = StrToIntW(szVersionSingleInt.GetBuffer());
545 Version->arrVersion[Version->VersionSize] = IntResult;
546 ++Version->VersionSize;
547 szVersionSingleInt.Empty();
548 ++VersionCharCount;
549 }
550
551 if (IsCharAlphaW(szVersion[VersionCharCount]))
552 {
553 Version->cVersionSuffix = szVersion[VersionCharCount];
554 }
555 else
556 Version->cVersionSuffix = NULL;
557 return bHasParsed;
558 }
559
560 //Compares versions
561 //In: Zero terminated strings of versions
562 //Out: TRUE if first is bigger than second, FALSE if else
563 BOOL
564 CompareVersionsStrings(_In_z_ LPCWSTR sczVersionLeft, _In_z_ LPCWSTR sczVersionRight)
565 {
566 VERSION_INFO LeftVersion, RightVersion;
567
568 if (!ParseVersion(sczVersionLeft, &LeftVersion)
569 || !ParseVersion(sczVersionRight, &RightVersion))
570 {
571 return FALSE;
572 }
573
574 return CompareVersions(&LeftVersion, &RightVersion);
575 }
576
577 BOOL
578 CompareVersions(_In_ PVERSION_INFO LeftVersion, _In_ PVERSION_INFO RightVersion)
579 {
580 //CURRENT
581 if (!LeftVersion->VersionSize || !RightVersion->VersionSize)
582 {
583 return FALSE;
584 }
585 //1.2.3 > 1.2
586 INT SizeDiff = LeftVersion->VersionSize - RightVersion->VersionSize;
587 if (SizeDiff > 0)
588 {
589 return TRUE;
590 }
591 if (SizeDiff < 0)
592 {
593 return FALSE;
594 }
595 //2.0.0 > 1.9.9
596 for (INT i = 0; i < LeftVersion->VersionSize && i < RightVersion->VersionSize && i < MAX_VERSION; ++i)
597 {
598 if (LeftVersion->arrVersion[i] > RightVersion->arrVersion[i])
599 {
600 return TRUE;
601 }
602 if (LeftVersion->arrVersion[i] < RightVersion->arrVersion[i])
603 {
604 return FALSE;
605 }
606 }
607 //1.2.3b > 1.2.3
608 if (LeftVersion->cVersionSuffix > RightVersion->cVersionSuffix)
609 {
610 return TRUE;
611 }
612
613 return FALSE;
614 }