setup_native/source/win32/customactions/reg4msdoc/registry.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: registry.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "registry.hxx"
  32
  33 #include <Shlwapi.h>
  34 #include <assert.h>
  35 #include <algorithm>
  36
  37 #ifdef _MSC_VER
  38 #pragma warning(disable : 4786 4350)
  39 #endif
  40
  41 //-----------------------------------------------------
  42 /** Create instance and open the specified Registry key
  43
  44     @throws  RegistryWriteAccessDenyException
  45              RegistryAccessDenyException
  46              RegistryKeyNotFoundException
  47 */
  48 RegistryKeyImpl::RegistryKeyImpl(HKEY RootKey, const std::wstring& KeyName) :
  49     m_hRootKey(RootKey),
  50     m_hSubKey(0),
  51     m_KeyName(KeyName),
  52     m_IsWriteable(false)
  53 {
  54 }
  55
  56 //-----------------------------------------------------
  57 /** Create instance and open the specified Registry key
  58
  59     @throws  RegistryWriteAccessDenyException
  60              RegistryAccessDenyException
  61              RegistryKeyNotFoundException
  62 */
  63 RegistryKeyImpl::RegistryKeyImpl(HKEY RootKey) :
  64     m_hRootKey(RootKey),
  65     m_hSubKey(0),
  66     m_IsWriteable(false)
  67 {
  68 }
  69
  70 //-----------------------------------------------------
  71 /** Create an instances of the specified Registry key,
  72     the key is assumed to be already opened.
  73 */
  74 RegistryKeyImpl::RegistryKeyImpl(HKEY RootKey, HKEY SubKey, const std::wstring& KeyName, bool Writeable) :
  75     m_hRootKey(RootKey),
  76     m_hSubKey(SubKey),
  77     m_KeyName(KeyName),
  78     m_IsWriteable(Writeable)
  79 {
  80 }
  81
  82 //-----------------------------------------------------
  83 /**
  84 */
  85 RegistryKeyImpl::~RegistryKeyImpl()
  86 {
  87     if (IsOpen())
  88         Close();
  89 }
  90
  91
  92 //############################################
  93 // Queries
  94 //############################################
  95
  96
  97 //-----------------------------------------------------
  98 /** The name of the key at hand, maybe empty
  99     if this is any of the root keys
 100 */
 101 std::wstring RegistryKeyImpl::GetName() const
 102 {
 103     return m_KeyName;
 104 }
 105
 106 //-----------------------------------------------------
 107 /**
 108 */
 109 bool RegistryKeyImpl::IsOpen() const
 110 {
 111     return m_hSubKey != 0;
 112 }
 113
 114 //-----------------------------------------------------
 115 /** Is this one of the root keys
 116     HKEY_CLASSES_ROOT
 117     HKEY_CURRENT_USER
 118     etc.
 119 */
 120 bool RegistryKeyImpl::IsRootKey() const
 121 {
 122     return (0 == m_KeyName.length());
 123 }
 124
 125 //-----------------------------------------------------
 126 /** Do we have write access on the key at hand
 127 */
 128 bool RegistryKeyImpl::IsWriteable() const
 129 {
 130     return m_IsWriteable;
 131 }
 132
 133 //-----------------------------------------------------
 134 /** Convenience function to determine if the
 135     Registry key at hand has the specified
 136     value
 137
 138     @precond IsOpen = true
 139
 140     throws RegistryAccessDenyException
 141 */
 142 bool RegistryKeyImpl::HasValue(const std::wstring& Name) const
 143 {
 144     StringListPtr names = GetSubValueNames();
 145
 146     StringList::iterator iter_end = names->end();
 147     StringList::iterator iter = std::find(names->begin(), iter_end, Name);
 148
 149     return (iter != iter_end);
 150 }
 151
 152 struct CompareNamesCaseInsensitive
 153 {
 154     CompareNamesCaseInsensitive(const std::wstring& Name) :
 155         name_(Name)
 156     {}
 157
 158     bool operator() (const std::wstring& value)
 159     {
 160         return (0 == StrCmpI(value.c_str(), name_.c_str()));
 161     }
 162
 163     std::wstring name_;
 164 };
 165
 166 //-----------------------------------------------------
 167 /** Convenience function to determine if the
 168     Registry key at hand has the specified
 169     sub-key
 170
 171     @precond IsOpen = true
 172
 173     throws RegistryAccessDenyException
 174 */
 175 bool RegistryKeyImpl::HasSubKey(const std::wstring& Name) const
 176 {
 177     StringListPtr names = GetSubKeyNames();
 178
 179     StringList::iterator iter_end = names->end();
 180     StringList::iterator iter = std::find_if(names->begin(), iter_end, CompareNamesCaseInsensitive(Name));
 181
 182     return (iter != iter_end);
 183 }
 184
 185 //-----------------------------------------------------
 186 /**
 187 */
 188 void RegistryKeyImpl::Close()
 189 {
 190     if (RegCloseKey(m_hSubKey) != ERROR_SUCCESS) {
 191         assert(false);
 192     }
 193
 194     m_hSubKey = 0;
 195     m_IsWriteable = false;
 196 }
 197
 198 //-----------------------------------------------------
 199 /** Copies the specified value from RegistryKey to
 200     the registry key at hand, if a value with this
 201     name already exist under the registry key at hand
 202     it will be overwritten
 203
 204     @precond IsOpen = true
 205              IsWriteable = true
 206              RegistryKey.HasSubValue(Name) = true
 207
 208     @throws RegistryIOException
 209             RegistryWriteAccessDeniedException
 210             RegistryValueNotFoundException
 211 */
 212 void RegistryKeyImpl::CopyValue(const RegistryKey& RegistryKey, const std::wstring& Name)
 213 {
 214     assert(RegistryKey->HasValue(Name));
 215 #ifdef __MINGW32__
 216     SetValue((const RegistryValue&)(RegistryKey->GetValue(Name)));
 217 #else
 218     SetValue(RegistryKey->GetValue(Name));
 219 #endif
 220     assert(HasValue(Name));
 221 }
 222
 223 /** Copies the specified value from RegistryKey to
 224     the registry key at hand under a new name,
 225     if a value with this name already exist there
 226     it will be overwritten
 227
 228     @precond IsOpen = true
 229              IsWriteable = true
 230              RegistryKey.HasSubValue(Name) = true
 231
 232     @throws RegistryIOException
 233             RegistryWriteAccessDeniedException
 234             RegistryValueNotFoundException
 235 */
 236 void RegistryKeyImpl::CopyValue(const RegistryKey& RegistryKey, const std::wstring& Name, const std::wstring& NewName)
 237 {
 238     assert(RegistryKey->HasValue(Name));
 239
 240     RegistryValue RegVal = RegistryKey->GetValue(Name);
 241     RegVal->SetName(NewName);
 242     SetValue(RegVal);
 243
 244     assert(HasValue(NewName));
 245 }