home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 24 / AACD 24.iso / AACD / Sound / LAME / WarpOS / src / dshow / REG.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-04  |  5.1 KB  |  287 lines
  1. /*
  2.  *    MPEG Audio Encoder for DirectShow
  3.  *    Registry wrapper
  4.  *
  5.  *    Copyright (c) 2000 Marie Orlova, Peter Gubanov, Elecard Ltd.
  6.  *
  7.  * This library is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Library General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2 of the License, or (at your option) any later version.
  11.  *
  12.  * This library is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the GNU
  15.  * Library General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Library General Public
  18.  * License along with this library; if not, write to the
  19.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20.  * Boston, MA 02111-1307, USA.
  21.  */
  22.  
  23. #include <Windows.h>
  24.  
  25. #include "reg.h"
  26.  
  27.  
  28. CRegKey::CRegKey(void)
  29. {
  30.     m_hRootKey = NULL;
  31.     m_name[0] = 0;
  32.     m_hKey = NULL;
  33. }
  34.  
  35.  
  36. CRegKey::CRegKey(HKEY rt, PTSTR pName)
  37. {
  38.     m_hRootKey = rt;
  39.     m_hKey = NULL;
  40.     if(pName)
  41.     {
  42.         lstrcpy(m_name, pName);
  43.         Open(m_hRootKey, m_name);
  44.     }
  45.     else
  46.         m_name[0] = 0;
  47. }
  48.  
  49.  
  50. CRegKey::~CRegKey(void)
  51. {
  52.     Close();
  53. }
  54.  
  55.  
  56.  
  57. BOOL    CRegKey::Open(HKEY rootKey, PTSTR pName)
  58. {
  59.     if(m_hKey)
  60.         Close();
  61.  
  62.     m_hRootKey = rootKey;
  63.     if(pName) 
  64.     {
  65.         lstrcpy(m_name, pName);
  66.         if(RegOpenKeyEx(m_hRootKey, m_name, 0, KEY_ALL_ACCESS, &m_hKey) != ERROR_SUCCESS) 
  67.         {
  68.             m_hKey = NULL;
  69.             return FALSE;
  70.         }
  71.     }
  72.     else 
  73.     {
  74.         m_name[0] = 0;
  75.         m_hKey = m_hRootKey;
  76.     }
  77.  
  78.     return TRUE;
  79. }
  80.  
  81.  
  82. BOOL    CRegKey::Create(HKEY rootKey, PTSTR pName)
  83. {
  84.     if(m_hKey)
  85.         Close();
  86.  
  87.     m_hRootKey = rootKey;
  88.     if(pName) 
  89.     {
  90.         lstrcpy(m_name, pName);
  91.         if(RegCreateKeyEx(m_hRootKey, pName, NULL,
  92.                 TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
  93.                 &m_hKey, NULL) != ERROR_SUCCESS) 
  94.         {
  95.  
  96.             m_hKey = NULL;
  97.             return FALSE;
  98.         }
  99.     }
  100.     else 
  101.     {
  102.         m_name[0] = 0;
  103.     }
  104.     m_hRootKey = m_hKey;
  105.  
  106.     return TRUE;
  107. }
  108.  
  109.  
  110. BOOL    CRegKey::Open(PTSTR an)
  111. {
  112.     TCHAR achName[MAX_PATH];
  113.  
  114.     if(m_hKey)
  115.         Close();
  116.  
  117.     lstrcpy(achName, m_name);
  118.     if(an)
  119.         lstrcat(achName, an);
  120.  
  121.     if(RegOpenKeyEx(m_hRootKey, achName, 0, KEY_ALL_ACCESS, &m_hKey) != ERROR_SUCCESS) 
  122.     {
  123.         m_hKey = NULL;
  124.         return FALSE;
  125.     }
  126.  
  127.     return TRUE;
  128. }
  129.  
  130.  
  131. BOOL    CRegKey::Create(PTSTR an)
  132. {
  133.     TCHAR achName[MAX_PATH];
  134.  
  135.     if(m_hKey)
  136.         Close();
  137.  
  138.     lstrcpy(achName, m_name);
  139.     if(an)
  140.         lstrcat(achName, an);
  141.  
  142.     if(RegCreateKeyEx(m_hRootKey, achName, NULL,
  143.             TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
  144.             &m_hKey, NULL) != ERROR_SUCCESS) 
  145.     {
  146.  
  147.         m_hKey = NULL;
  148.         return FALSE;
  149.     }
  150.  
  151.     return TRUE;
  152. }
  153.  
  154.  
  155. BOOL    CRegKey::Close(void)
  156. {
  157.     if(m_hKey && m_hKey != m_hRootKey)
  158.         RegCloseKey(m_hKey);
  159.  
  160.     m_hKey = 0;
  161.     return TRUE;
  162. }
  163.  
  164. BOOL    CRegKey::getFlag(PTSTR valuename, BOOL bDefault)
  165. {
  166.     if(!m_hKey)
  167.         return bDefault;
  168.  
  169.     DWORD cbData;
  170.     DWORD    dwData;
  171.     DWORD    dwType;
  172.  
  173.     cbData = sizeof(dwData);
  174.     if(RegQueryValueEx(m_hKey, valuename, NULL, &dwType, (PBYTE)&dwData, &cbData) == ERROR_SUCCESS) 
  175.     {
  176.         if(dwType == REG_DWORD)
  177.             return (dwData) ? TRUE : FALSE;
  178.     }
  179.     return bDefault;
  180. }
  181.  
  182.  
  183. void    CRegKey::setFlag(PTSTR valuename, BOOL bValue, BOOL bDefault)
  184. {
  185.     if(getFlag(valuename, bDefault) == bValue )
  186.         return;
  187.  
  188.     RegSetValueEx(m_hKey, valuename, 0, REG_DWORD, (PBYTE)&bValue, sizeof(bValue));
  189. }
  190.  
  191.  
  192. void    CRegKey::setFlag(PTSTR valuename, BOOL bValue)
  193. {
  194.     RegSetValueEx(m_hKey, valuename, 0, REG_DWORD, (PBYTE)&bValue, sizeof(bValue));
  195. }
  196.  
  197.  
  198. DWORD    CRegKey::getDWORD(PTSTR valuename, DWORD bDefault)
  199. {
  200.     DWORD dwData;
  201.     DWORD cbData;
  202.     DWORD    dwType;
  203.  
  204.     if(!m_hKey)
  205.         return bDefault;
  206.  
  207.     cbData = sizeof(dwData);
  208.     if(RegQueryValueEx(m_hKey, valuename, NULL, &dwType, (PBYTE)&dwData, &cbData) == ERROR_SUCCESS) {
  209.         if(dwType == REG_DWORD) 
  210.         {
  211.             return (UINT)dwData;
  212.         }
  213.     }
  214.  
  215.     return bDefault;
  216. }
  217.  
  218.  
  219. void    CRegKey::setDWORD(PTSTR valuename, DWORD dwValue, DWORD dwDefault)
  220. {
  221.     DWORD dwData = dwValue;
  222.  
  223.     if(getDWORD(valuename, dwDefault) == dwValue)
  224.         return;
  225.  
  226.     RegSetValueEx(m_hKey, valuename, 0, REG_DWORD, (PBYTE)&dwData, sizeof(dwData));
  227. }
  228.  
  229.  
  230. void    CRegKey::setDWORD(PTSTR valuename, DWORD dwValue)
  231. {
  232.     DWORD dwData = dwValue;
  233.     RegSetValueEx(m_hKey, valuename, 0, REG_DWORD, (PBYTE)&dwData, sizeof(dwData));
  234. }
  235.  
  236.  
  237. DWORD CRegKey::getString(PTSTR valuename, PTSTR pDefault, PTSTR pResult, int cbSize)
  238. {
  239.     DWORD dwType;
  240.  
  241.     cbSize *= sizeof(TCHAR);    // for unicode strings
  242.  
  243.     if(m_hKey) 
  244.     {
  245.         if(RegQueryValueEx(m_hKey, valuename, NULL, &dwType, (LPBYTE)pResult, (LPDWORD)&cbSize) == ERROR_SUCCESS) 
  246.         {
  247.             if(dwType == REG_SZ) 
  248.             {
  249.                 return(cbSize - 1);
  250.             }
  251.         }
  252.     }
  253.     lstrcpy(pResult, pDefault);
  254.     return lstrlen(pDefault);
  255. }
  256.  
  257.  
  258. void    CRegKey::setString(PTSTR valuename, PTSTR pData)
  259. {
  260.     RegSetValueEx(m_hKey, valuename, 0, REG_SZ, (LPBYTE)pData, (lstrlen(pData) + 1)*sizeof(TCHAR));
  261. }
  262.  
  263.  
  264. DWORD CRegKey::getBinary(PTSTR valuename, PVOID pDefault, PVOID pResult, int cbSize)
  265. {
  266.     DWORD dwType;
  267.  
  268.     if(RegQueryValueEx(m_hKey, valuename, NULL, &dwType, (LPBYTE)pResult, (LPDWORD)&cbSize) == ERROR_SUCCESS) 
  269.     {
  270.         if(dwType == REG_BINARY) 
  271.         {
  272.             return cbSize;
  273.         }
  274.     }
  275.  
  276.     memmove(pResult, pDefault, cbSize);
  277.     return cbSize;
  278. }
  279.  
  280.  
  281. DWORD CRegKey::setBinary(PTSTR valuename, PVOID pData, int cbSize)
  282. {
  283.     RegSetValueEx(m_hKey, valuename, 0, REG_BINARY, (LPBYTE)pData, cbSize);
  284.     return cbSize;
  285. }
  286.  
  287.