base/applications/msconfig_new/utils.c

   1 /*
   2  * PROJECT:     ReactOS Applications
   3  * LICENSE:     LGPL - See COPYING in the top level directory
   4  * FILE:        base/applications/msconfig_new/utils.c
   5  * PURPOSE:     Memory Management, Resources, ... Utility Functions
   6  * COPYRIGHT:   Copyright 2011-2012 Hermes BELUSCA - MAITO <hermes.belusca@sfr.fr>
   7  */
   8
   9 #include "precomp.h"
  10 #include "utils.h"
  11 #include "stringutils.h"
  12
  13 // HANDLE g_hHeap = GetProcessHeap();
  14 #define g_hHeap GetProcessHeap()
  15
  16 #if 0
  17 VOID
  18 MemInit(IN HANDLE Heap)
  19 {
  20     /* Save the heap handle */
  21     g_hHeap = Heap;
  22 }
  23 #endif
  24
  25 BOOL
  26 MemFree(IN PVOID lpMem)
  27 {
  28     /* Free memory back into the heap */
  29     return HeapFree(g_hHeap, 0, lpMem);
  30 }
  31
  32 PVOID
  33 MemAlloc(IN DWORD dwFlags,
  34          IN SIZE_T dwBytes)
  35 {
  36     /* Allocate memory from the heap */
  37     return HeapAlloc(g_hHeap, dwFlags, dwBytes);
  38 }
  39
  40 LPWSTR
  41 FormatDateTime(IN LPSYSTEMTIME pDateTime)
  42 {
  43     LPWSTR lpszDateTime = NULL;
  44     int iDateBufSize, iTimeBufSize;
  45
  46     if (pDateTime == NULL) return NULL;
  47
  48     iDateBufSize = GetDateFormatW(LOCALE_USER_DEFAULT,
  49                                   /* Only for Windows 7 : DATE_AUTOLAYOUT | */ DATE_SHORTDATE,
  50                                   pDateTime,
  51                                   NULL,
  52                                   NULL,
  53                                   0);
  54     iTimeBufSize = GetTimeFormatW(LOCALE_USER_DEFAULT,
  55                                   0,
  56                                   pDateTime,
  57                                   NULL,
  58                                   NULL,
  59                                   0);
  60
  61     if ( (iDateBufSize > 0) && (iTimeBufSize > 0) )
  62     {
  63         lpszDateTime = (LPWSTR)MemAlloc(0, (iDateBufSize + iTimeBufSize) * sizeof(WCHAR));
  64
  65         GetDateFormatW(LOCALE_USER_DEFAULT,
  66                        /* Only for Windows 7 : DATE_AUTOLAYOUT | */ DATE_SHORTDATE,
  67                        pDateTime,
  68                        NULL,
  69                        lpszDateTime,
  70                        iDateBufSize);
  71         if (iDateBufSize > 0) lpszDateTime[iDateBufSize-1] = L' ';
  72         GetTimeFormatW(LOCALE_USER_DEFAULT,
  73                        0,
  74                        pDateTime,
  75                        NULL,
  76                        lpszDateTime + iDateBufSize,
  77                        iTimeBufSize);
  78     }
  79
  80     return lpszDateTime;
  81 }
  82
  83 VOID
  84 FreeDateTime(IN LPWSTR lpszDateTime)
  85 {
  86     if (lpszDateTime)
  87         MemFree(lpszDateTime);
  88 }
  89
  90 LPWSTR
  91 LoadResourceStringEx(IN HINSTANCE hInstance,
  92                      IN UINT uID,
  93                      OUT size_t* pSize OPTIONAL)
  94 {
  95     LPWSTR lpszDestBuf = NULL, lpszResourceString = NULL;
  96     size_t iStrSize    = 0;
  97
  98     // When passing a zero-length buffer size, LoadString(...) returns a
  99     // read-only pointer buffer to the program's resource string.
 100     iStrSize = LoadStringW(hInstance, uID, (LPWSTR)&lpszResourceString, 0);
 101
 102     if ( lpszResourceString && ( (lpszDestBuf = (LPWSTR)MemAlloc(0, (iStrSize + 1) * sizeof(WCHAR))) != NULL ) )
 103     {
 104         wcsncpy(lpszDestBuf, lpszResourceString, iStrSize);
 105         lpszDestBuf[iStrSize] = L'\0'; // NULL-terminate the string
 106
 107         if (pSize)
 108             *pSize = iStrSize + 1;
 109     }
 110     else
 111     {
 112         if (pSize)
 113             *pSize = 0;
 114     }
 115
 116     return lpszDestBuf;
 117 }
 118
 119 LPWSTR
 120 LoadConditionalResourceStringEx(IN HINSTANCE hInstance,
 121                                 IN BOOL bCondition,
 122                                 IN UINT uIDifTrue,
 123                                 IN UINT uIDifFalse,
 124                                 IN size_t* pSize OPTIONAL)
 125 {
 126     return LoadResourceStringEx(hInstance,
 127                                 (bCondition ? uIDifTrue : uIDifFalse),
 128                                 pSize);
 129 }
 130
 131 DWORD
 132 RunCommand(IN LPCWSTR lpszCommand,
 133            IN LPCWSTR lpszParameters,
 134            IN INT nShowCmd)
 135 {
 136     DWORD dwRes;
 137
 138     DWORD dwNumOfChars;
 139     LPWSTR lpszExpandedCommand;
 140
 141     dwNumOfChars = ExpandEnvironmentStringsW(lpszCommand, NULL, 0);
 142     lpszExpandedCommand = (LPWSTR)MemAlloc(0, dwNumOfChars * sizeof(WCHAR));
 143     ExpandEnvironmentStringsW(lpszCommand, lpszExpandedCommand, dwNumOfChars);
 144
 145     dwRes = (DWORD_PTR)ShellExecuteW(NULL,
 146                                      NULL /* and not L"open" !! */,
 147                                      lpszExpandedCommand,
 148                                      lpszParameters,
 149                                      NULL,
 150                                      nShowCmd);
 151     MemFree(lpszExpandedCommand);
 152
 153     return dwRes;
 154 }
 155
 156
 157 ////////////////////  The following comes from MSDN samples  ///////////////////
 158 // https://msdn.microsoft.com/en-us/library/windows/desktop/dd162826(v=vs.85).aspx
 159 //
 160
 161 //
 162 //  ClipOrCenterRectToMonitor
 163 //
 164 //  The most common problem apps have when running on a
 165 //  multimonitor system is that they "clip" or "pin" windows
 166 //  based on the SM_CXSCREEN and SM_CYSCREEN system metrics.
 167 //  Because of app compatibility reasons these system metrics
 168 //  return the size of the primary monitor.
 169 //
 170 //  This shows how you use the multi-monitor functions
 171 //  to do the same thing.
 172 //
 173 VOID ClipOrCenterRectToMonitor(LPRECT prc, UINT flags)
 174 {
 175     HMONITOR    hMonitor;
 176     MONITORINFO mi;
 177     RECT        rc;
 178     int         w = prc->right  - prc->left;
 179     int         h = prc->bottom - prc->top;
 180
 181     //
 182     // Get the nearest monitor to the passed rect.
 183     //
 184     hMonitor = MonitorFromRect(prc, MONITOR_DEFAULTTONEAREST);
 185
 186     //
 187     // Get the work area or entire monitor rect.
 188     //
 189     mi.cbSize = sizeof(mi);
 190     GetMonitorInfo(hMonitor, &mi);
 191
 192     if (flags & MONITOR_WORKAREA)
 193         rc = mi.rcWork;
 194     else
 195         rc = mi.rcMonitor;
 196
 197     //
 198     // Center or clip the passed rect to the monitor rect.
 199     //
 200     if (flags & MONITOR_CENTER)
 201     {
 202         prc->left   = rc.left + (rc.right  - rc.left - w) / 2;
 203         prc->top    = rc.top  + (rc.bottom - rc.top  - h) / 2;
 204         prc->right  = prc->left + w;
 205         prc->bottom = prc->top  + h;
 206     }
 207     else
 208     {
 209         prc->left   = max(rc.left, min(rc.right-w,  prc->left));
 210         prc->top    = max(rc.top,  min(rc.bottom-h, prc->top));
 211         prc->right  = prc->left + w;
 212         prc->bottom = prc->top  + h;
 213     }
 214 }
 215
 216 VOID ClipOrCenterWindowToMonitor(HWND hWnd, UINT flags)
 217 {
 218     RECT rc;
 219     GetWindowRect(hWnd, &rc);
 220     ClipOrCenterRectToMonitor(&rc, flags);
 221     SetWindowPos(hWnd, NULL, rc.left, rc.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 222 }
 223 ////////////////////////////////////////////////////////////////////////////////
 224
 225
 226 BOOL IsWindowsOS(VOID)
 227 {
 228     BOOL bIsWindowsOS = FALSE;
 229
 230     OSVERSIONINFOW osvi = {0};
 231     osvi.dwOSVersionInfoSize = sizeof(osvi);
 232
 233     if (!GetVersionExW(&osvi))
 234         return FALSE;
 235
 236     if (osvi.dwPlatformId != VER_PLATFORM_WIN32_NT)
 237         return FALSE;
 238
 239     /* ReactOS reports as Windows NT 5.2 */
 240
 241     if ( (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion >= 2) ||
 242          (osvi.dwMajorVersion  > 5) )
 243     {
 244         HKEY hKey = NULL;
 245
 246         if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
 247                           L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
 248                           0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS)
 249         {
 250             LONG ret;
 251             DWORD dwType = 0, dwBufSize = 0;
 252
 253             ret = RegQueryValueExW(hKey, L"ProductName", NULL, &dwType, NULL, &dwBufSize);
 254             if (ret == ERROR_SUCCESS && dwType == REG_SZ)
 255             {
 256                 LPTSTR lpszProductName = (LPTSTR)MemAlloc(0, dwBufSize);
 257                 RegQueryValueExW(hKey, L"ProductName", NULL, &dwType, (LPBYTE)lpszProductName, &dwBufSize);
 258
 259                 bIsWindowsOS = (FindSubStrI(lpszProductName, _T("Windows")) != NULL);
 260
 261                 MemFree(lpszProductName);
 262             }
 263
 264             RegCloseKey(hKey);
 265         }
 266     }
 267     else
 268     {
 269         bIsWindowsOS = TRUE;
 270     }
 271
 272     return bIsWindowsOS;
 273 }
 274
 275 BOOL IsPreVistaOSVersion(VOID)
 276 {
 277     OSVERSIONINFOW osvi = {0};
 278     osvi.dwOSVersionInfoSize = sizeof(osvi);
 279
 280     if (!GetVersionExW(&osvi))
 281         return FALSE;
 282
 283     /* Vista+-class OSes are NT >= 6 */
 284     return ( (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) ? (osvi.dwMajorVersion < 6) : FALSE );
 285 }
 286
 287 LPWSTR
 288 GetExecutableVendor(IN LPCWSTR lpszFilename)
 289 {
 290     LPWSTR lpszVendor = NULL;
 291     DWORD dwHandle = 0;
 292     DWORD dwLen;
 293
 294     LPVOID lpData;
 295
 296     LPVOID pvData = NULL;
 297     UINT BufLen = 0;
 298     WORD wCodePage = 0, wLangID = 0;
 299     LPWSTR lpszStrFileInfo = NULL;
 300
 301     LPWSTR lpszData = NULL;
 302
 303     if (lpszFilename == NULL) return NULL;
 304
 305     dwLen = GetFileVersionInfoSizeW(lpszFilename, &dwHandle);
 306     if (dwLen == 0) return NULL;
 307
 308     lpData = MemAlloc(0, dwLen);
 309     if (!lpData) return NULL;
 310
 311     GetFileVersionInfoW(lpszFilename, dwHandle, dwLen, lpData);
 312
 313     if (VerQueryValueW(lpData, L"\\VarFileInfo\\Translation", &pvData, &BufLen))
 314     {
 315         wCodePage = LOWORD(*(DWORD*)pvData);
 316         wLangID   = HIWORD(*(DWORD*)pvData);
 317
 318         lpszStrFileInfo = FormatString(L"StringFileInfo\\%04X%04X\\CompanyName",
 319                                        wCodePage,
 320                                        wLangID);
 321     }
 322
 323     VerQueryValueW(lpData, lpszStrFileInfo, (LPVOID*)&lpszData, &BufLen);
 324     if (lpszData)
 325     {
 326         lpszVendor = (LPWSTR)MemAlloc(0, BufLen * sizeof(WCHAR));
 327         if (lpszVendor)
 328             wcscpy(lpszVendor, lpszData);
 329     }
 330     else
 331     {
 332         lpszVendor = NULL;
 333     }
 334
 335     MemFree(lpszStrFileInfo);
 336     MemFree(lpData);
 337
 338     return lpszVendor;
 339 }