src/Utils/Registry.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2006,2008-2010 - TortoiseSVN
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #include "stdafx.h"
  20 #include "registry.h"
  21
  22 //////////////////////////////////////////////////////////////////////////////////////////////
  23
  24 #ifdef __CSTRINGT_H__ || __ATLSTR_H__
  25 CRegBase::CRegBase()
  26 {
  27 }
  28
  29 CRegBase::CRegBase (const CString& key, bool force, HKEY base, REGSAM sam)
  30     : CRegBaseCommon<CString> (key, force, base, sam)
  31 {
  32     m_key.TrimLeft(_T("\\"));
  33     int backslashpos = m_key.ReverseFind('\\');
  34     m_path = m_key.Left(backslashpos);
  35     m_path.TrimRight(_T("\\"));
  36     m_key = m_key.Mid(backslashpos);
  37     m_key.Trim(_T("\\"));
  38 }
  39 #endif
  40
  41 //////////////////////////////////////////////////////////////////////////////////////////////
  42
  43 CRegStdBase::CRegStdBase()
  44 {
  45 }
  46
  47 CRegStdBase::CRegStdBase (const tstring& key, bool force, HKEY base, REGSAM sam)
  48     : CRegBaseCommon<tstring> (key, force, base, sam)
  49 {
  50     tstring::size_type pos = key.find_last_of(_T('\\'));
  51     m_path = key.substr(0, pos);
  52     m_key = key.substr(pos + 1);
  53 }
  54
  55 //////////////////////////////////////////////////////////////////////////////////////////////
  56
  57 #ifdef __ATLTYPES_H__   // defines CRect
  58 CRegRect::CRegRect(void)
  59     : CRegTypedBase<CRect, CRegBase>(CRect(0,0,0,0))
  60 {
  61 }
  62
  63 CRegRect::CRegRect(const CString& key, const CRect& def, bool force, HKEY base, REGSAM sam)
  64     : CRegTypedBase<CRect, CRegBase> (key, def, force, base, sam)
  65 {
  66     read();
  67 }
  68
  69 void CRegRect::InternalRead (HKEY hKey, CRect& value)
  70 {
  71     DWORD size = 0;
  72     DWORD type = 0;
  73     LastError = RegQueryValueEx(hKey, m_key, NULL, &type, NULL, (LPDWORD) &size);
  74
  75     if (LastError == ERROR_SUCCESS)
  76     {
  77         auto_buffer<char> buffer (size);
  78         if ((LastError = RegQueryValueEx(hKey, m_key, NULL, &type, (BYTE*) buffer.get(), &size))==ERROR_SUCCESS)
  79         {
  80             ASSERT(type==REG_BINARY);
  81             value = CRect((LPRECT)buffer.get());
  82         }
  83     }
  84 }
  85
  86 void CRegRect::InternalWrite (HKEY hKey, const CRect& value)
  87 {
  88     LastError = RegSetValueEx(hKey, m_key, 0, REG_BINARY, (BYTE *)(LPCRECT)value, sizeof(value));
  89 }
  90
  91 #endif
  92
  93 //////////////////////////////////////////////////////////////////////////////////////////////
  94
  95 #ifdef __ATLTYPES_H__   // defines CPoint
  96 CRegPoint::CRegPoint(void)
  97     : CRegTypedBase<CPoint, CRegBase>(CPoint(0,0))
  98 {
  99 }
 100
 101 CRegPoint::CRegPoint(const CString& key, const CPoint& def, bool force, HKEY base, REGSAM sam)
 102     : CRegTypedBase<CPoint, CRegBase> (key, def, force, base, sam)
 103 {
 104     read();
 105 }
 106
 107 void CRegPoint::InternalRead (HKEY hKey, CPoint& value)
 108 {
 109     DWORD size = 0;
 110     DWORD type = 0;
 111     LastError = RegQueryValueEx(hKey, m_key, NULL, &type, NULL, (LPDWORD) &size);
 112
 113     if (LastError == ERROR_SUCCESS)
 114     {
 115         auto_buffer<char> buffer(size);
 116         if ((LastError = RegQueryValueEx(hKey, m_key, NULL, &type, (BYTE*) buffer.get(), &size))==ERROR_SUCCESS)
 117         {
 118             ASSERT(type==REG_BINARY);
 119             value = CPoint(*(POINT*)buffer.get());
 120         }
 121     }
 122 }
 123
 124 void CRegPoint::InternalWrite (HKEY hKey, const CPoint& value)
 125 {
 126     LastError = RegSetValueEx(hKey, m_key, 0, REG_BINARY, (BYTE *)&value, sizeof(value));
 127 }
 128 #endif
 129
 130 /////////////////////////////////////////////////////////////////////
 131
 132 #ifdef __AFXCOLL_H__   // defines CStringList
 133 CRegistryKey::CRegistryKey(const CString& key, HKEY base, REGSAM sam)
 134 {
 135     m_base = base;
 136     m_hKey = NULL;
 137     m_sam = sam;
 138     m_path = key;
 139     m_path.TrimLeft(_T("\\"));
 140 }
 141
 142 CRegistryKey::~CRegistryKey()
 143 {
 144     if (m_hKey)
 145         RegCloseKey(m_hKey);
 146 }
 147
 148 DWORD CRegistryKey::createKey()
 149 {
 150     DWORD disp;
 151     DWORD rc = RegCreateKeyEx(m_base, m_path, 0, _T(""), REG_OPTION_NON_VOLATILE, KEY_WRITE|m_sam, NULL, &m_hKey, &disp);
 152     if (rc != ERROR_SUCCESS)
 153     {
 154         return rc;
 155     }
 156     return RegCloseKey(m_hKey);
 157 }
 158
 159 DWORD CRegistryKey::removeKey()
 160 {
 161     RegOpenKeyEx(m_base, m_path, 0, KEY_WRITE|m_sam, &m_hKey);
 162     return SHDeleteKey(m_base, (LPCTSTR)m_path);
 163 }
 164
 165 bool CRegistryKey::getValues(CStringList& values)
 166 {
 167     values.RemoveAll();
 168
 169     if (RegOpenKeyEx(m_base, m_path, 0, KEY_EXECUTE|m_sam, &m_hKey)==ERROR_SUCCESS)
 170     {
 171         for (int i = 0, rc = ERROR_SUCCESS; rc == ERROR_SUCCESS; i++)
 172         {
 173             TCHAR value[255];
 174             DWORD size = _countof(value);
 175             rc = RegEnumValue(m_hKey, i, value, &size, NULL, NULL, NULL, NULL);
 176             if (rc == ERROR_SUCCESS)
 177             {
 178                 values.AddTail(value);
 179             }
 180         }
 181     }
 182
 183     return values.GetCount() > 0;
 184 }
 185
 186 bool CRegistryKey::getSubKeys(CStringList& subkeys)
 187 {
 188     subkeys.RemoveAll();
 189
 190     if (RegOpenKeyEx(m_base, m_path, 0, KEY_EXECUTE|m_sam, &m_hKey)==ERROR_SUCCESS)
 191     {
 192         for (int i = 0, rc = ERROR_SUCCESS; rc == ERROR_SUCCESS; i++)
 193         {
 194             TCHAR value[1024];
 195             DWORD size = _countof(value);
 196             FILETIME last_write_time;
 197             rc = RegEnumKeyEx(m_hKey, i, value, &size, NULL, NULL, NULL, &last_write_time);
 198             if (rc == ERROR_SUCCESS)
 199             {
 200                 subkeys.AddTail(value);
 201             }
 202         }
 203     }
 204
 205     return subkeys.GetCount() > 0;
 206 }
 207 #endif
 208