home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 June / PCFJune.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / bpcreg.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  30.7 KB  |  866 lines
  1. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  2. #if _MSC_VER > 1000
  3. #pragma once
  4. #endif
  5.  
  6. #ifndef BPCREG_H
  7. #define BPCREG_H
  8.  
  9. #include <tchar.h>
  10.  
  11. //-----------------------------------------------------------------------------
  12. //
  13. // Registry usage:
  14. //
  15. // HKLM = HKEY_LOCAL_MACHINE
  16. // HKCU = HKEY_CURRENT_USER
  17. //
  18. // HKLM\Software\Microsoft\TV System Services
  19. //
  20. //     REG_SZ (Default)  - Not used.
  21. //     REG_SZ ProductDir - Root directory for BPC software
  22. //     REG_SZ DBFile     - Full path to tss.mdb
  23. //     REG_SZ DBReplacementFile     - Full path to the empty replacement tss.mdb
  24. //     REG_SZ EPGDBFile  - Full path to epg.mdb
  25. //     REG_SZ SystemDB   - Full path to tss.mdw
  26. //     REG_SZ AMFilter   - Full path to dss.grf
  27. //
  28. // HKLM\Software\Microsoft\TV System Services\Tuning Spaces
  29. //
  30. //     REG_SZ (Default)  - Not used.
  31. //
  32. // HKLM\Software\Microsoft\TV System Services\Tuning Spaces\<iTuningSpace>
  33. //
  34. //     REG_SZ (Default)   - Not used.
  35. //     REG_SZ Name        - UNDONE
  36. //     REG_SZ Description - UNDONE
  37. //     REG_SZ Loader      - UNDONE
  38. //     REG_SZ MinChannel  - UNDONE
  39. //     REG_SZ MaxChannel  - UNDONE
  40. //     REG_SZ Devices     - UNDONE
  41. //     REG_SZ MediaType   - UNDONE
  42. //
  43. // HKLM\Software\Microsoft\TV System Services\Tuning Spaces\1
  44. //
  45. //     REG_SZ Messages - UNDONE
  46. //     REG_SZ History  - UNDONE
  47. //
  48. // HKLM\Software\Microsoft\TV System Services\EPG Loaders
  49. //
  50. //     REG_SZ (Default)               - Not used.
  51. //     REG_SZ LastAttempt             - UNDONE
  52. //     REG_BINARY LastAttemptTime     - UNDONE
  53. //     REG_SZ LastCompletion          - UNDONE
  54. //     REG_BINARY LastCompletionTime  - UNDONE
  55. //     REG_DWORD LastCompletionResult - UNDONE
  56. //     REG_BINARY EngineeringByte         - UNDONE
  57. //
  58. // HKLM\Software\Microsoft\TV System Services\EPG Loaders\<guid>
  59. //
  60. //     REG_SZ (Default)               - Not used.
  61. //     REG_SZ Name                    - UNDONE
  62. //     REG_SZ TuningID                - UNDONE
  63. //     REG_BINARY LastAttemptTime     - UNDONE
  64. //     REG_BINARY LastCompletionTime  - UNDONE
  65. //     REG_DWORD LastCompletionResult - UNDONE
  66. //
  67. // HKCU\Software\Microsoft\TV System Services
  68. //
  69. //     REG_SZ (Default)  - Not used.
  70. //
  71. // HKCU\Software\Microsoft\Microsoft TVExplorer
  72. //
  73. //     REG_SZ (Default)  - Not used.
  74. //
  75. // HKCU\Software\Microsoft\Microsoft TVExplorer\RemoteKeys
  76. //
  77. //     REG_SZ (Default)  - Not used.
  78. //
  79. // HKCU\Software\Microsoft\Microsoft TVExplorer\RemoteKeys\CommandLines
  80. //
  81. //     REG_SZ (Default)  - Not used.
  82. //     REG_SZ Guide      - UNDONE
  83. //     REG_SZ TV         - UNDONE
  84. //
  85. // HKCU\Software\Microsoft\Microsoft TVExplorer\RemoteKeys\WakeupKeys
  86. //
  87. //     REG_SZ (Default)  - Not used.
  88. //     REG_SZ Guide      - UNDONE
  89. //     REG_SZ TV         - UNDONE
  90. //
  91. // HKCU\AppEvents\Schemes\Apps\TVExplorer
  92. //
  93. //     REG_SZ (Default)  - "TV Explorer"
  94. //
  95. //-----------------------------------------------------------------------------
  96.  
  97. extern const LPCTSTR g_strBaseRegKey;
  98. extern const LPCTSTR g_strProductDir;
  99. extern const LPCTSTR g_strDBFile;
  100. extern const LPCTSTR g_strDBReplacementFile;
  101. extern const LPCTSTR g_strEPGDBFile;
  102. extern const LPCTSTR g_strDefVBITS;
  103. extern const LPCTSTR g_strDefVBIChan;
  104. extern const LPCTSTR g_strSysFile;
  105. extern const LPCTSTR g_strAMFilter;
  106. extern const LPCTSTR g_strAMFClass;
  107. extern const LPCTSTR g_strAMFCategory;
  108. extern const LPCTSTR g_strAMFName;
  109. extern const LPCTSTR g_strTSInputType;
  110. extern const LPCTSTR g_strCountryCode;
  111. extern const LPCTSTR g_strVolume;
  112. extern const LPCTSTR g_strBalance;
  113. extern const LPCTSTR g_strAudioPin;
  114. extern const LPCTSTR g_strTVXRegKey;
  115. extern const LPCTSTR g_strNTSC;
  116. extern const LPCTSTR g_strDistanceViewing;
  117.  
  118. extern const LPCTSTR g_strConfigRegKey;
  119. extern const LPCTSTR g_strConfigLastPage;
  120.  
  121. extern const LPCTSTR g_strTuningSpaceRegKey;
  122. extern const LPCTSTR g_strTuningSpaceName;
  123. extern const LPCTSTR g_strTuningSpaceDescription;
  124. extern const LPCTSTR g_strMinChannel;
  125. extern const LPCTSTR g_strMaxChannel;
  126. extern const LPCTSTR g_strCurTVTuningSpace;
  127. extern const LPCTSTR g_strDSSTuningSpaceRegKey;
  128. extern const LPCTSTR g_strLCIDToSTYPE;
  129.  
  130. extern const LPCTSTR g_strCAProviderRegKey;
  131. extern const LPCTSTR g_strCAProviderName;
  132. extern const LPCTSTR g_strCAProviderDesc;
  133. extern const LPCTSTR g_strVenPrefix;
  134. extern const LPCTSTR g_strDevPrefix;
  135.  
  136. extern const LPCTSTR g_strEPGRegKey;
  137. extern const LPCTSTR g_strEPGLoadersRegKey;
  138. extern const LPCTSTR g_strEPGLoaderAttempt;
  139. extern const LPCTSTR g_strEPGLoaderAttemptTime;
  140. extern const LPCTSTR g_strEPGLoaderCompletion;
  141. extern const LPCTSTR g_strEPGLoaderCompletionTime;
  142. extern const LPCTSTR g_strEPGLoaderCompletionResult;
  143. extern const LPCTSTR g_strEPGLoaderName;
  144. extern const LPCTSTR g_strEPGLoaderTuningID;
  145. extern const LPCTSTR g_strLoaderPostalCode;
  146. extern const LPCTSTR g_strLoaderLastCompactSize;
  147.  
  148. extern const LPCTSTR g_strLoaderReadPrefix;
  149. extern const LPCTSTR g_strLoaderWritePrefix;
  150. extern const LPCTSTR g_strLoaderReadFile;
  151. extern const LPCTSTR g_strDTVLoaderCSSByte;
  152. extern const LPCTSTR g_strSSLoaderRegionID;
  153. extern const LPCTSTR g_strSSLoaderRegionIDValid;
  154. extern const LPCTSTR g_strSSLoaderPreviousRegionID;
  155. extern const LPCTSTR g_strSSLoaderChannel;
  156. extern const LPCTSTR g_strSSLoaderLine;
  157. extern const LPCTSTR g_strSSLoaderScanReturnCode;
  158. extern const LPCTSTR g_strSSLoaderScanPostalCode;
  159. extern const LPCTSTR g_strSSLoaderListenReturnCode;
  160. extern const LPCTSTR g_strSSLoaderListenReturnCodeCount;
  161.  
  162. #ifdef _DEBUG
  163. extern const LPCTSTR g_strDEBUG;
  164. extern const LPCTSTR g_strTrace;
  165. #endif
  166.  
  167.  
  168. //-----------------------------------------------------------------------------
  169. // OpenRegKey
  170. //
  171. // Opens a registry HKEY.  There are several overloads of this function
  172. // that basically just provide defaults for the arguments to this function.
  173. //
  174. // Please use the overload that defaults as much as possible.
  175. //
  176. // The registry key is a combination of the following four parts.
  177. //
  178. //   HKEY hkeyRoot       = Optional root hkey.
  179. //                         Default: HKEY_LOCAL_MACHINE
  180. //
  181. //   LPCTSTR szKey       = Optional key to be set.
  182. //                         Default: g_strBaseRegKey
  183. //
  184. //   LPCTSTR szSubKey1
  185. //   LPCTSTR szSubKey2   = Optional sub keys that are concatenated after
  186. //                         szKey to form the full key.
  187. //                         Backward slashes are added as necessary.
  188. //
  189. //                         Default: NULL
  190. //
  191. //   Note: if only one or two strings are specified they are assumed to be
  192. //         szSubKey1 and szSubKey2.
  193. //         i.e. szKey defaults to g_strBaseRegKey before szSubKey1 and
  194. //         szSubKey2 default to NULL.
  195. //
  196. //         If szKey, szSubKey1, and szSubKey2 are NULL then this will open
  197. //         a duplicate of hkeyRoot.
  198. //
  199. // The only required argument is the destination for the returned HKEY.
  200. //
  201. //   HKEY *pkey  = The returned HKEY.
  202. //                 Remember to use RegCloseKey(*pkey) when you are finished
  203. //                 with this registry key.
  204. //
  205. // The last two arguments are optional.
  206. //
  207. //   REGSAM sam  = Desired access mask.
  208. //                 Default: KEY_ALL_ACCESS
  209. //
  210. //   BOOL fCreate = TRUE if the key should be created.
  211. //                  Default: FALSE
  212. //
  213. // Returns:
  214. //     ERROR_SUCCESS or an error code.
  215. //-----------------------------------------------------------------------------
  216. long OpenRegKey(HKEY hkeyRoot, LPCTSTR szKey, LPCTSTR szSubKey1,
  217.         LPCTSTR szSubKey2, HKEY *pkey,
  218.         REGSAM sam = KEY_ALL_ACCESS, BOOL fCreate = FALSE);
  219.  
  220. inline long OpenRegKey(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  221.         HKEY *pkey, REGSAM sam = KEY_ALL_ACCESS, BOOL fCreate = FALSE)
  222. {
  223.      return OpenRegKey(HKEY_LOCAL_MACHINE, szKey, szSubKey1, szSubKey2, pkey,
  224.              sam, fCreate);
  225. }
  226.  
  227. inline long OpenRegKey(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  228.         HKEY *pkey, REGSAM sam = KEY_ALL_ACCESS, BOOL fCreate = FALSE)
  229. {
  230.      return OpenRegKey(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey1,
  231.              szSubKey2, pkey, sam, fCreate);
  232. }
  233.  
  234. inline long OpenRegKey(LPCTSTR szSubKey, HKEY *pkey,
  235.         REGSAM sam = KEY_ALL_ACCESS, BOOL fCreate = FALSE)
  236. {
  237.      return OpenRegKey(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey, NULL,
  238.              pkey, sam, fCreate);
  239. }
  240.  
  241. inline long OpenRegKey(HKEY *pkey, REGSAM sam = KEY_ALL_ACCESS,
  242.         BOOL fCreate = FALSE)
  243. {
  244.      return OpenRegKey(HKEY_LOCAL_MACHINE, g_strBaseRegKey, NULL, NULL,
  245.              pkey, sam, fCreate);
  246. }
  247.  
  248. //-----------------------------------------------------------------------------
  249. // OpenUserRegKey
  250. //
  251. // Same as OpenRegKey except hkeyRoot defaults to HKEY_CURRENT_USER.
  252. //-----------------------------------------------------------------------------
  253. inline long OpenUserRegKey(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  254.         HKEY *pkey, REGSAM sam = KEY_ALL_ACCESS, BOOL fCreate = FALSE)
  255. {
  256.      return OpenRegKey(HKEY_CURRENT_USER, szKey, szSubKey1, szSubKey2, pkey,
  257.              sam, fCreate);
  258. }
  259.  
  260. inline long OpenUserRegKey(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  261.         HKEY *pkey, REGSAM sam = KEY_ALL_ACCESS, BOOL fCreate = FALSE)
  262. {
  263.      return OpenRegKey(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey1,
  264.              szSubKey2, pkey, sam, fCreate);
  265. }
  266.  
  267. inline long OpenUserRegKey(LPCTSTR szSubKey, HKEY *pkey,
  268.         REGSAM sam = KEY_ALL_ACCESS, BOOL fCreate = FALSE)
  269. {
  270.      return OpenRegKey(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey, NULL,
  271.              pkey, sam, fCreate);
  272. }
  273.  
  274. inline long OpenUserRegKey(HKEY *pkey, REGSAM sam = KEY_ALL_ACCESS,
  275.         BOOL fCreate = FALSE)
  276. {
  277.      return OpenRegKey(HKEY_CURRENT_USER, g_strBaseRegKey, NULL, NULL,
  278.              pkey, sam, fCreate);
  279. }
  280.  
  281. //-----------------------------------------------------------------------------
  282. // GetRegValue
  283. //
  284. // Gets data from the registry.  There are numerous overloads of this function
  285. // that basically just provide defaults for the arguments to this function.
  286. //
  287. // Please use the overload that defaults as much as possible.
  288. //
  289. // The registry key/value is a combination of the following five parts.
  290. // The first four are the same as in OpenRegKey().
  291. //
  292. //   HKEY hkeyRoot
  293. //   LPCTSTR szKey
  294. //   LPCTSTR szSubKey1
  295. //   LPCTSTR szSubKey2
  296. //
  297. //   LPCTSTR szValueName = The name of the value to be set.
  298. //                         If it is NULL then the default value for the key
  299. //                         will be set.
  300. //
  301. //                         Default: none
  302. //
  303. // There are four ways to specify where the data to be returned
  304. // depending on the type of data in the registry.
  305. //
  306. // REG_BINARY
  307. //
  308. //   BYTE *pb      = Out: The data is copied to this location.
  309. //   DWORD *pcb    = In:  Maximum size of the returned data (in bytes).
  310. //                   Out: Actual size of the data (in bytes).
  311. //
  312. // REG_SZ
  313. //
  314. //   TCHAR *psz    = Out: The string is copied to this location.
  315. //   DWORD *pcb    = In:  Maximum size of the returned data (in bytes).
  316. //                   Out: Actual size of the data (in bytes).
  317. //                   Includes the null terminator.
  318. //
  319. // REG_DWORD
  320. //
  321. //   DWORD *pdw    = Out: The data is copied to this location.
  322. //                   The length is assumed to be sizeof(DWORD).
  323. //
  324. // All other types
  325. //
  326. //   DWORD dwType  = The data type.
  327. //   BYTE *pb      = Pointer to the data.
  328. //   DWORD *pcb    = In:  Maximum size of the returned data (in bytes).
  329. //                   Out: Actual size of the data (in bytes).
  330. //                   Includes the null terminator if the data is a string type.
  331. //
  332. // Returns:
  333. //     ERROR_SUCCESS or an error code.
  334. //-----------------------------------------------------------------------------
  335. long GetRegValue(HKEY hkeyRoot, LPCTSTR szKey, LPCTSTR szSubKey1,
  336.         LPCTSTR szSubKey2, LPCTSTR szValueName,
  337.         DWORD dwType, BYTE *pb, DWORD *pcb);
  338.  
  339. //-----------------------------------------------------------------------------
  340. // REG_BINARY variants
  341. //-----------------------------------------------------------------------------
  342. inline long GetRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  343.         LPCTSTR szValueName, BYTE *pb, DWORD *pcb)
  344. {
  345.     return GetRegValue(HKEY_LOCAL_MACHINE, szKey, szSubKey1, szSubKey2,
  346.             szValueName,
  347.             REG_BINARY, pb, pcb);
  348. }
  349.  
  350. inline long GetRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  351.         LPCTSTR szValueName, BYTE *pb, DWORD *pcb)
  352. {
  353.     return GetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey1,
  354.             szSubKey2, szValueName, REG_BINARY, pb, pcb);
  355. }
  356.  
  357. inline long GetRegValue(LPCTSTR szSubKey, LPCTSTR szValueName,
  358.         BYTE *pb, DWORD *pcb)
  359. {
  360.     return GetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey, NULL,
  361.             szValueName, REG_BINARY, pb, pcb);
  362. }
  363.  
  364. inline long GetRegValue(LPCTSTR szValueName, BYTE *pb, DWORD *pcb)
  365. {
  366.     return GetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, NULL, NULL,
  367.             szValueName, REG_BINARY, pb, pcb);
  368. }
  369.  
  370. //-----------------------------------------------------------------------------
  371. // REG_SZ variants
  372. //-----------------------------------------------------------------------------
  373. inline long GetRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  374.         LPCTSTR szValueName, TCHAR *psz, DWORD *pcb)
  375. {
  376.     return GetRegValue(HKEY_LOCAL_MACHINE, szKey, szSubKey1, szSubKey2,
  377.             szValueName, REG_SZ, (BYTE *) psz, pcb);
  378. }
  379. inline long GetRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  380.         LPCTSTR szValueName, TCHAR *psz, DWORD *pcb)
  381. {
  382.     return GetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey1,
  383.             szSubKey2, szValueName, REG_SZ, (BYTE *) psz, pcb);
  384. }
  385.  
  386. inline long GetRegValue(LPCTSTR szSubKey, LPCTSTR szValueName,
  387.         TCHAR *psz, DWORD *pcb)
  388. {
  389.     return GetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey, NULL,
  390.             szValueName, REG_SZ, (BYTE *)psz, pcb);
  391. }
  392.  
  393. #if 0
  394. inline long GetRegValue(HKEY hk, LPCTSTR szValueName,
  395.         TCHAR *psz, DWORD *pcb)
  396. {
  397.     return GetRegValue(hk, NULL, NULLy, NULL,
  398.             szValueName, REG_SZ, (BYTE *)psz, pcb);
  399. }
  400. #endif
  401.  
  402. inline long GetRegValue(LPCTSTR szValueName, TCHAR *psz, DWORD *pcb)
  403. {
  404.     return GetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, NULL, NULL,
  405.             szValueName, REG_SZ, (BYTE *) psz, pcb);
  406. }
  407.  
  408. //-----------------------------------------------------------------------------
  409. // REG_DWORD variants
  410. //-----------------------------------------------------------------------------
  411. inline long GetRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  412.         LPCTSTR szValueName, DWORD *pdw)
  413. {
  414.     DWORD cb = sizeof(DWORD);
  415.  
  416.     return GetRegValue(HKEY_LOCAL_MACHINE, szKey, szSubKey1, szSubKey2,
  417.             szValueName, REG_DWORD, (BYTE *) pdw, &cb);
  418. }
  419.  
  420. inline long GetRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  421.         LPCTSTR szValueName, DWORD *pdw)
  422. {
  423.     DWORD cb = sizeof(DWORD);
  424.  
  425.     return GetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey1,
  426.             szSubKey2, szValueName, REG_DWORD, (BYTE *) pdw, &cb);
  427. }
  428.  
  429.  
  430. inline long GetRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, DWORD *pdw)
  431. {
  432.     DWORD cb = sizeof(DWORD);
  433.  
  434.     return GetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey, NULL,
  435.             szValueName, REG_DWORD, (BYTE *) pdw, &cb);
  436. }
  437.  
  438. inline long GetRegValue(LPCTSTR szValueName, DWORD *pdw)
  439. {
  440.     DWORD cb = sizeof(DWORD);
  441.  
  442.     return GetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, NULL, NULL,
  443.             szValueName, REG_DWORD, (BYTE *) pdw, &cb);
  444. }
  445.  
  446. //-----------------------------------------------------------------------------
  447. // The following variants are for getting values from an already open key.
  448. //-----------------------------------------------------------------------------
  449. inline long GetRegValue(HKEY hkey, LPCTSTR szKey, LPCTSTR szSubKey,
  450.         LPCTSTR szValueName, TCHAR *psz, DWORD *pcb)
  451. {
  452.     return GetRegValue(hkey, szKey, szSubKey, NULL, szValueName,
  453.             REG_SZ, (BYTE *) psz, pcb);
  454. }
  455.  
  456. inline long GetRegValue(HKEY hkey, LPCTSTR szValueName, BYTE *pb, DWORD *pcb)
  457. {
  458.     return GetRegValue(hkey, NULL, NULL, NULL, szValueName,
  459.             REG_BINARY, pb, pcb);
  460. }
  461.  
  462. inline long GetRegValue(HKEY hkey, LPCTSTR szValueName, TCHAR *psz, DWORD *pcb)
  463. {
  464.     return GetRegValue(hkey, NULL, NULL, NULL, szValueName,
  465.             REG_SZ, (BYTE *) psz, pcb);
  466. }
  467.  
  468. inline long GetRegValue(HKEY hkey, LPCTSTR szValueName, DWORD *pdw)
  469. {
  470.     DWORD cb = sizeof(DWORD);
  471.  
  472.     return GetRegValue(hkey, NULL, NULL, NULL, szValueName,
  473.             REG_DWORD, (BYTE *) pdw, &cb);
  474. }
  475.  
  476. //-----------------------------------------------------------------------------
  477. // GetUserRegValue
  478. //
  479. // Same as GetRegValue except hkeyRoot defaults to HKEY_CURRENT_USER.
  480. //-----------------------------------------------------------------------------
  481. //-----------------------------------------------------------------------------
  482. // REG_BINARY variants
  483. //-----------------------------------------------------------------------------
  484. inline long GetUserRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  485.         LPCTSTR szValueName, BYTE *pb, DWORD *pcb)
  486. {
  487.     return GetRegValue(HKEY_CURRENT_USER, szKey, szSubKey1, szSubKey2,
  488.             szValueName,
  489.             REG_BINARY, pb, pcb);
  490. }
  491.  
  492. inline long GetUserRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  493.         LPCTSTR szValueName, BYTE *pb, DWORD *pcb)
  494. {
  495.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey1,
  496.             szSubKey2, szValueName, REG_BINARY, pb, pcb);
  497. }
  498.  
  499. inline long GetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName,
  500.         BYTE *pb, DWORD *pcb)
  501. {
  502.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey, NULL,
  503.             szValueName, REG_BINARY, pb, pcb);
  504. }
  505.  
  506. inline long GetUserRegValue(LPCTSTR szValueName, BYTE *pb, DWORD *pcb)
  507. {
  508.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, NULL, NULL,
  509.             szValueName, REG_BINARY, pb, pcb);
  510. }
  511.  
  512. //-----------------------------------------------------------------------------
  513. // REG_SZ variants
  514. //-----------------------------------------------------------------------------
  515. inline long GetUserRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  516.         LPCTSTR szValueName, TCHAR *psz, DWORD *pcb)
  517. {
  518.     return GetRegValue(HKEY_CURRENT_USER, szKey, szSubKey1, szSubKey2,
  519.             szValueName, REG_SZ, (BYTE *) psz, pcb);
  520. }
  521. inline long GetUserRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  522.         LPCTSTR szValueName, TCHAR *psz, DWORD *pcb)
  523. {
  524.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey1,
  525.             szSubKey2, szValueName, REG_SZ, (BYTE *) psz, pcb);
  526. }
  527.  
  528. inline long GetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName,
  529.         TCHAR *psz, DWORD *pcb)
  530. {
  531.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey, NULL,
  532.             szValueName, REG_SZ, (BYTE *)psz, pcb);
  533. }
  534.  
  535. inline long GetUserRegValue(LPCTSTR szValueName, TCHAR *psz, DWORD *pcb)
  536. {
  537.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, NULL, NULL,
  538.             szValueName, REG_SZ, (BYTE *) psz, pcb);
  539. }
  540.  
  541. //-----------------------------------------------------------------------------
  542. // REG_DWORD variants
  543. //-----------------------------------------------------------------------------
  544. inline long GetUserRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  545.         LPCTSTR szValueName, DWORD *pdw)
  546. {
  547.     DWORD cb = sizeof(DWORD);
  548.  
  549.     return GetRegValue(HKEY_CURRENT_USER, szKey, szSubKey1, szSubKey2,
  550.             szValueName, REG_DWORD, (BYTE *) pdw, &cb);
  551. }
  552.  
  553. inline long GetUserRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  554.         LPCTSTR szValueName, DWORD *pdw)
  555. {
  556.     DWORD cb = sizeof(DWORD);
  557.  
  558.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey1,
  559.             szSubKey2, szValueName, REG_DWORD, (BYTE *) pdw, &cb);
  560. }
  561.  
  562.  
  563. inline long GetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, DWORD *pdw)
  564. {
  565.     DWORD cb = sizeof(DWORD);
  566.  
  567.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey, NULL,
  568.             szValueName, REG_DWORD, (BYTE *) pdw, &cb);
  569. }
  570.  
  571. inline long GetUserRegValue(LPCTSTR szValueName, DWORD *pdw)
  572. {
  573.     DWORD cb = sizeof(DWORD);
  574.  
  575.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, NULL, NULL,
  576.             szValueName, REG_DWORD, (BYTE *) pdw, &cb);
  577. }
  578.  
  579. inline long GetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, DWORD &dw)
  580. {
  581.     DWORD cb = sizeof(DWORD);
  582.  
  583.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey, NULL,
  584.             szValueName, REG_DWORD, (BYTE *) &dw, &cb);
  585. }
  586.  
  587. inline long GetUserRegValue(LPCTSTR szValueName, DWORD &dw)
  588. {
  589.     DWORD cb = sizeof(DWORD);
  590.  
  591.     return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, NULL, NULL,
  592.             szValueName, REG_DWORD, (BYTE *) &dw, &cb);
  593. }
  594.  
  595. //-----------------------------------------------------------------------------
  596. // SetRegValue
  597. //
  598. // Sets data into the registry.  There are numerous overloads of this function
  599. // that basically just provide defaults for the arguments to this function.
  600. //
  601. // Please use the overload that defaults as much as possible.
  602. //
  603. // The registry key/value is a combination of the following five parts.
  604. // The first four are the same as in OpenRegKey().
  605. //
  606. //   HKEY hkeyRoot
  607. //   LPCTSTR szKey
  608. //   LPCTSTR szSubKey1
  609. //   LPCTSTR szSubKey2
  610. //
  611. //   LPCTSTR szValueName = The name of the value to be set.
  612. //                         If it is NULL then the default value for the key
  613. //                         will be set.
  614. //
  615. //                         Default: none
  616. //
  617. // There are four ways to specify the data to be set into the registry
  618. // depending on the type of data being stored.
  619. //
  620. // REG_BINARY
  621. //
  622. //   BYTE *pb      = Pointer to the data.
  623. //   DWORD cb      = Actual size of the data (in bytes).
  624. //
  625. // REG_SZ
  626. //
  627. //   TCHAR *psz    = The data is written as type REG_SZ.
  628. //                   The length is calculated as _tcsclen(psz) + sizeof(TCHAR).
  629. //
  630. // REG_DWORD
  631. //
  632. //   DWORD dw      = The data is written as type DWORD.
  633. //                   The length is calculated as sizeof(DWORD).
  634. //
  635. // All other types
  636. //
  637. //   DWORD dwType  = The data type.
  638. //   BYTE *pb      = Pointer to the data.
  639. //   DWORD cb      = Actual size of the data in bytes.
  640. //
  641. // Returns:
  642. //     ERROR_SUCCESS or an error code.
  643. //-----------------------------------------------------------------------------
  644. long SetRegValue(HKEY hkeyRoot, LPCTSTR szKey, LPCTSTR szSubKey1,
  645.         LPCTSTR szSubKey2, LPCTSTR szValueName,
  646.         DWORD dwType, const BYTE *pb, DWORD cb);
  647.  
  648. //-----------------------------------------------------------------------------
  649. // REG_BINARY variants
  650. //-----------------------------------------------------------------------------
  651. inline long SetRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  652.         LPCTSTR szValueName, const BYTE *pb, DWORD cb)
  653. {
  654.     return SetRegValue(HKEY_LOCAL_MACHINE, szKey, szSubKey1, szSubKey2,
  655.             szValueName, REG_BINARY, pb, cb);
  656. }
  657.  
  658. inline long SetRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  659.         LPCTSTR szValueName, const BYTE *pb, DWORD cb)
  660. {
  661.     return SetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey1,
  662.             szSubKey2, szValueName, REG_BINARY, pb, cb);
  663. }
  664.  
  665. inline long SetRegValue(LPCTSTR szSubKey, LPCTSTR szValueName,
  666.         const BYTE *pb, DWORD cb)
  667. {
  668.     return SetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey, NULL,
  669.             szValueName, REG_BINARY, pb, cb);
  670. }
  671.  
  672. inline long SetRegValue(LPCTSTR szValueName, const BYTE *pb, DWORD cb)
  673. {
  674.     return SetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, NULL, NULL,
  675.             szValueName, REG_BINARY, pb, cb);
  676. }
  677.  
  678. //-----------------------------------------------------------------------------
  679. // REG_SZ variants
  680. //-----------------------------------------------------------------------------
  681. inline long SetRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  682.         LPCTSTR szValueName, const TCHAR *psz)
  683. {
  684.     return SetRegValue(HKEY_LOCAL_MACHINE,
  685.             szKey, szSubKey1, szSubKey2, szValueName,
  686.             REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
  687. }
  688. inline long SetRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  689.         LPCTSTR szValueName, const TCHAR *psz)
  690. {
  691.     return SetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey,
  692.             szSubKey1, szSubKey2, szValueName,
  693.             REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
  694. }
  695.  
  696. inline long SetRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, const TCHAR *psz)
  697. {
  698.     return SetRegValue(HKEY_LOCAL_MACHINE,
  699.             g_strBaseRegKey, szSubKey, NULL, szValueName,
  700.             REG_SZ, (const BYTE *)psz, _tcsclen(psz) + sizeof(TCHAR));
  701. }
  702.  
  703. inline long SetRegValue(LPCTSTR szValueName, const TCHAR *psz)
  704. {
  705.     return SetRegValue(HKEY_LOCAL_MACHINE,
  706.             g_strBaseRegKey, NULL, NULL, szValueName,
  707.             REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
  708. }
  709.  
  710. //-----------------------------------------------------------------------------
  711. // REG_DWORD variants
  712. //-----------------------------------------------------------------------------
  713. inline long SetRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  714.         LPCTSTR szValueName, DWORD dw)
  715. {
  716.     return SetRegValue(HKEY_LOCAL_MACHINE,
  717.             szKey, szSubKey1, szSubKey2, szValueName,
  718.             REG_DWORD, (BYTE *) &dw, sizeof(DWORD));
  719. }
  720.  
  721. inline long SetRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  722.         LPCTSTR szValueName, DWORD dw)
  723. {
  724.     return SetRegValue(HKEY_LOCAL_MACHINE,
  725.             g_strBaseRegKey, szSubKey1, szSubKey2, szValueName,
  726.             REG_DWORD, (BYTE *) &dw, sizeof(DWORD));
  727. }
  728.  
  729. inline long SetRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, DWORD dw)
  730. {
  731.     return SetRegValue(HKEY_LOCAL_MACHINE,
  732.             g_strBaseRegKey, szSubKey, NULL, szValueName,
  733.             REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
  734. }
  735.  
  736. inline long SetRegValue(LPCTSTR szValueName, DWORD dw)
  737. {
  738.     return SetRegValue(HKEY_LOCAL_MACHINE,
  739.             g_strBaseRegKey, NULL, NULL, szValueName,
  740.             REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
  741. }
  742.  
  743. //-----------------------------------------------------------------------------
  744. // The following variants are for setting values in an already open key.
  745. //-----------------------------------------------------------------------------
  746. inline long SetRegValue(HKEY hkey, LPCTSTR szValueName, const BYTE *pb, DWORD cb)
  747. {
  748.     return SetRegValue(hkey, NULL, NULL, NULL, szValueName,
  749.             REG_BINARY, pb, cb);
  750. }
  751.  
  752. inline long SetRegValue(HKEY hkey, LPCTSTR szValueName, const TCHAR *psz)
  753. {
  754.     return SetRegValue(hkey, NULL, NULL, NULL, szValueName,
  755.             REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
  756. }
  757.  
  758. inline long SetRegValue(HKEY hkey, LPCTSTR szValueName, DWORD dw)
  759. {
  760.     return SetRegValue(hkey, NULL, NULL, NULL, szValueName,
  761.             REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
  762. }
  763.  
  764. //-----------------------------------------------------------------------------
  765. // SetUserRegValue
  766. //
  767. // Same as SetRegValue except hkeyRoot defaults to HKEY_CURRENT_USER.
  768. //-----------------------------------------------------------------------------
  769. //-----------------------------------------------------------------------------
  770. // REG_BINARY variants
  771. //-----------------------------------------------------------------------------
  772. inline long SetUserRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  773.         LPCTSTR szValueName, const BYTE *pb, DWORD cb)
  774. {
  775.     return SetRegValue(HKEY_CURRENT_USER, szKey, szSubKey1, szSubKey2,
  776.             szValueName, REG_BINARY, pb, cb);
  777. }
  778.  
  779. inline long SetUserRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  780.         LPCTSTR szValueName, const BYTE *pb, DWORD cb)
  781. {
  782.     return SetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey1,
  783.             szSubKey2, szValueName, REG_BINARY, pb, cb);
  784. }
  785.  
  786. inline long SetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName,
  787.         const BYTE *pb, DWORD cb)
  788. {
  789.     return SetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey, NULL,
  790.             szValueName, REG_BINARY, pb, cb);
  791. }
  792.  
  793. inline long SetUserRegValue(LPCTSTR szValueName, const BYTE *pb, DWORD cb)
  794. {
  795.     return SetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, NULL, NULL,
  796.             szValueName, REG_BINARY, pb, cb);
  797. }
  798.  
  799. //-----------------------------------------------------------------------------
  800. // REG_SZ variants
  801. //-----------------------------------------------------------------------------
  802. inline long SetUserRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  803.         LPCTSTR szValueName, const TCHAR *psz)
  804. {
  805.     return SetRegValue(HKEY_CURRENT_USER,
  806.             szKey, szSubKey1, szSubKey2, szValueName,
  807.             REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
  808. }
  809. inline long SetUserRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  810.         LPCTSTR szValueName, const TCHAR *psz)
  811. {
  812.     return SetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey,
  813.             szSubKey1, szSubKey2, szValueName,
  814.             REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
  815. }
  816.  
  817. inline long SetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, const TCHAR *psz)
  818. {
  819.     return SetRegValue(HKEY_CURRENT_USER,
  820.             g_strBaseRegKey, szSubKey, NULL, szValueName,
  821.             REG_SZ, (const BYTE *)psz, _tcsclen(psz) + sizeof(TCHAR));
  822. }
  823.  
  824. inline long SetUserRegValue(LPCTSTR szValueName, const TCHAR *psz)
  825. {
  826.     return SetRegValue(HKEY_CURRENT_USER,
  827.             g_strBaseRegKey, NULL, NULL, szValueName,
  828.             REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
  829. }
  830.  
  831. //-----------------------------------------------------------------------------
  832. // REG_DWORD variants
  833. //-----------------------------------------------------------------------------
  834. inline long SetUserRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  835.         LPCTSTR szValueName, DWORD dw)
  836. {
  837.     return SetRegValue(HKEY_CURRENT_USER,
  838.             szKey, szSubKey1, szSubKey2, szValueName,
  839.             REG_DWORD, (BYTE *) &dw, sizeof(DWORD));
  840. }
  841.  
  842. inline long SetUserRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
  843.         LPCTSTR szValueName, DWORD dw)
  844. {
  845.     return SetRegValue(HKEY_CURRENT_USER,
  846.             g_strBaseRegKey, szSubKey1, szSubKey2, szValueName,
  847.             REG_DWORD, (BYTE *) &dw, sizeof(DWORD));
  848. }
  849.  
  850. inline long SetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, DWORD dw)
  851. {
  852.     return SetRegValue(HKEY_CURRENT_USER,
  853.             g_strBaseRegKey, szSubKey, NULL, szValueName,
  854.             REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
  855. }
  856.  
  857. inline long SetUserRegValue(LPCTSTR szValueName, DWORD dw)
  858. {
  859.     return SetRegValue(HKEY_CURRENT_USER,
  860.             g_strBaseRegKey, NULL, NULL, szValueName,
  861.             REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
  862. }
  863.  
  864. #endif // BPCREG_H
  865. #pragma option pop /*P_O_Pop*/
  866.