svtools/source/control/reginfo.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: reginfo.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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34 #include "reginfo.hxx"
  35 #include <tools/debug.hxx>
  36 #include <osl/thread.h>
  37
  38 #define MAXREGVALUE 200
  39
  40 // *****************************************************************************
  41 #if defined(WIN) || defined(WNT)
  42
  43 #include <tools/svwin.h>
  44
  45 #define DBG_HDL DBG_ASSERT(pImp->bValidGroup, "Keine Gruppe gesetzt"); \
  46     if( !pImp->bValidGroup ) return
  47
  48 struct RegInfo_Impl
  49 {
  50     HKEY aGroupHdl;
  51     BOOL bValidGroup;
  52 };
  53
  54 RegInfo::RegInfo()
  55 {
  56     pImp=new RegInfo_Impl;
  57     pImp->bValidGroup = FALSE;
  58 }
  59
  60 RegInfo::~RegInfo()
  61 {
  62     if(pImp->bValidGroup)
  63         RegCloseKey( pImp->aGroupHdl );
  64     delete pImp;
  65 }
  66
  67 String RegInfo::GetKeyName( USHORT nKey ) const
  68 {
  69     DBG_HDL String::EmptyString();
  70     char aBuffer[MAXREGVALUE];
  71     RegEnumKey( pImp->aGroupHdl, nKey, aBuffer, MAXREGVALUE );
  72     return String( UniString::CreateFromAscii(aBuffer) );
  73 }
  74
  75 USHORT RegInfo::GetKeyCount() const
  76 {
  77     DBG_HDL 0;
  78 #ifdef WNT
  79     DWORD nKeys;
  80     DWORD Dum1=10, Dum2, Dum3, Dum4, Dum5, Dum6, Dum7;
  81     char s[10];
  82     FILETIME aDumFileTime;
  83     RegQueryInfoKey( pImp->aGroupHdl, s, &Dum1, 0, &nKeys, &Dum2, &Dum3,
  84                     &Dum4, &Dum5, &Dum6, &Dum7, &aDumFileTime );
  85     return (USHORT) nKeys;
  86 #else
  87     char aBuffer[MAXREGVALUE];
  88     USHORT n=0;
  89     while(RegEnumKey(
  90         pImp->aGroupHdl, n, aBuffer, MAXREGVALUE) == ERROR_SUCCESS)
  91         n++;
  92     return n;
  93 #endif
  94 }
  95
  96 inline String MakeAppGroupString_Impl( const String &rGroup )
  97 {
  98     String aGroup( UniString::CreateFromAscii("SvAppGroups\\") );
  99     aGroup+=rGroup;
 100     return aGroup;
 101 }
 102
 103 void RegInfo::SetAppGroup( const String& rGroup )
 104 {
 105     aCurrentGroup = MakeAppGroupString_Impl(rGroup);
 106     if( pImp->bValidGroup )
 107     {
 108         RegCloseKey( pImp->aGroupHdl );
 109         pImp->bValidGroup = FALSE;
 110     }
 111     ByteString aBStr( aCurrentGroup, osl_getThreadTextEncoding() );
 112     RegCreateKey( HKEY_CLASSES_ROOT, aBStr.GetBuffer(), &pImp->aGroupHdl );
 113     pImp->bValidGroup = TRUE;
 114 }
 115
 116 void RegInfo::DeleteAppGroup( const String &rGroup )
 117 {
 118     String aOldGroup = aCurrentGroup;
 119     SetAppGroup( rGroup );
 120     DBG_HDL;
 121     USHORT nMax = GetKeyCount();
 122     for( USHORT n = nMax; n--; )
 123     {
 124         String aKey( GetKeyName( n ));
 125         DeleteKey( aKey );
 126     }
 127     RegCloseKey( pImp->aGroupHdl );
 128
 129     ByteString aBStr( rGroup, osl_getThreadTextEncoding() );
 130     RegDeleteKey( HKEY_CLASSES_ROOT, aBStr.GetBuffer() );
 131     pImp->bValidGroup = FALSE;
 132     if( rGroup != aOldGroup )
 133         SetAppGroup( aOldGroup );
 134 }
 135
 136 BOOL ReadKey_Impl( const String& rKey,
 137                   HKEY aHdl, String& rResult )
 138 {
 139     char s[MAXREGVALUE];
 140     LONG aLen=MAXREGVALUE;
 141
 142     ByteString aBStr( rKey, osl_getThreadTextEncoding() );
 143     LONG nRes = RegQueryValue( aHdl, aBStr.GetBuffer(), s, &aLen);
 144     if(nRes == ERROR_SUCCESS)
 145     {
 146         rResult = UniString::CreateFromAscii(s);
 147         return TRUE;
 148     }
 149     else
 150         return FALSE;
 151 }
 152
 153 String  RegInfo::ReadKey( const String& rKey ) const
 154 {
 155     DBG_HDL String::EmptyString();
 156     String aRes;
 157     if(ReadKey_Impl( rKey, pImp->aGroupHdl, aRes))
 158         return aRes;
 159     else
 160         return String::EmptyString();
 161 }
 162
 163 String  RegInfo::ReadKey( const String& rKey, const String &rDefault ) const
 164 {
 165     DBG_HDL String::EmptyString();
 166     String aRes;
 167     if(ReadKey_Impl( rKey, pImp->aGroupHdl, aRes))
 168         return aRes;
 169     else
 170         return rDefault;
 171 }
 172
 173 void RegInfo::WriteKey( const String& rKey, const String& rValue )
 174 {
 175     DBG_HDL;
 176     ByteString aBStr( rKey, osl_getThreadTextEncoding() );
 177     ByteString aBStr1( rValue, osl_getThreadTextEncoding() );
 178     RegSetValue( pImp->aGroupHdl, aBStr.GetBuffer(), REG_SZ, aBStr1.GetBuffer(), 0);
 179 }
 180
 181
 182 void RegInfo::DeleteKey( const String& rKey )
 183 {
 184     DBG_HDL;
 185     ByteString aBStr( rKey, osl_getThreadTextEncoding() );
 186     RegDeleteKey( pImp->aGroupHdl, aBStr.GetBuffer() );
 187 }
 188
 189 // *****************************************************************************
 190 #elif defined(OS2)
 191
 192 #define INCL_WINSHELLDATA
 193 #include <svpm.h>
 194
 195 struct RegInfo_Impl
 196 {
 197     char *pKeyList;
 198     String aCurrentApp;
 199     void BuildKeyList( const String &rGroup );
 200 };
 201
 202 void RegInfo_Impl::BuildKeyList( const String &rGroup )
 203 {
 204     ByteString aBStr( rGroup, osl_getThreadTextEncoding() );
 205     USHORT nLen = 0;
 206     do
 207     {
 208         nLen+=1000;
 209         delete[] pKeyList;
 210         pKeyList = new char[nLen];
 211         *(int *)pKeyList = 0;
 212     }
 213     while( PrfQueryProfileString(
 214         HINI_USERPROFILE, (PCSZ)aBStr.GetBuffer(),
 215         0, 0, pKeyList, nLen) == nLen);
 216 }
 217
 218
 219 RegInfo::RegInfo()
 220 {
 221     pImp=new RegInfo_Impl;
 222     pImp->pKeyList = 0;
 223 }
 224
 225 RegInfo::~RegInfo()
 226 {
 227     delete[] pImp->pKeyList;
 228     delete pImp;
 229 }
 230
 231 inline String MakeAppGroupString_Impl( const String &rGroup )
 232 {
 233     String aGroup(UniString::CreateFromAscii("SvAppGroups:"));
 234     aGroup+=rGroup;
 235     return aGroup;
 236 }
 237
 238 String RegInfo::GetKeyName( USHORT nKey ) const
 239 {
 240     if( !pImp->pKeyList )
 241         pImp->BuildKeyList(pImp->aCurrentApp);
 242
 243     const char *pc=pImp->pKeyList;
 244     for( USHORT n=0; n<nKey; n++ )
 245         while(*pc++);
 246
 247     return String(UniString::CreateFromAscii(pc));
 248 }
 249
 250 USHORT RegInfo::GetKeyCount() const
 251 {
 252     if( !pImp->pKeyList )
 253         pImp->BuildKeyList( pImp->aCurrentApp);
 254
 255     const char *pc=pImp->pKeyList;
 256     USHORT nRet=0;
 257     while(*pc)
 258     {
 259         while(*pc++);
 260         nRet++;
 261     }
 262     return nRet;
 263 }
 264
 265 void RegInfo::SetAppGroup( const String& rGroup )
 266 {
 267     delete[] pImp->pKeyList;
 268     pImp->pKeyList = 0;
 269     aCurrentGroup = rGroup;
 270     pImp->aCurrentApp = MakeAppGroupString_Impl( rGroup );
 271 }
 272
 273 void RegInfo::DeleteAppGroup( const String &rGroup )
 274 {
 275     ByteString aBStr( MakeAppGroupString_Impl( rGroup ), osl_getThreadTextEncoding() );
 276     PrfWriteProfileString(
 277         HINI_USERPROFILE, (PCSZ)aBStr.GetBuffer(), 0, 0);
 278 }
 279
 280
 281 String  RegInfo::ReadKey( const String& rKey ) const
 282 {
 283     ULONG    ulBufferMax = MAXREGVALUE;
 284     char *pBuffer= new char[MAXREGVALUE];
 285     ByteString aBStr( pImp->aCurrentApp, osl_getThreadTextEncoding() );
 286     ByteString aBStr1( rKey, osl_getThreadTextEncoding() );
 287     *pBuffer=0;
 288     PrfQueryProfileData(
 289         HINI_USERPROFILE, (PCSZ)aBStr.GetBuffer(), (PCSZ)aBStr1.GetBuffer(), pBuffer, &ulBufferMax);
 290     String aRet(UniString::CreateFromAscii(pBuffer));
 291     delete[] pBuffer;
 292     return aRet;
 293 }
 294
 295
 296 String  RegInfo::ReadKey( const String& rKey, const String &rDefault ) const
 297 {
 298     String aResult = ReadKey(rKey);
 299     if (!aResult.Len())
 300         return rDefault;
 301     else
 302         return aResult;
 303 }
 304
 305
 306 void RegInfo::WriteKey( const String& rKey, const String& rValue )
 307 {
 308     ByteString aBStr( pImp->aCurrentApp, osl_getThreadTextEncoding() );
 309     ByteString aBStr1( rKey, osl_getThreadTextEncoding() );
 310     PrfWriteProfileData(
 311         HINI_USERPROFILE, (PCSZ)aBStr.GetBuffer(), (PCSZ)aBStr1.GetBuffer(), (PVOID)rValue.GetBuffer(), rValue.Len()*2);
 312 }
 313
 314 void RegInfo::DeleteKey( const String& rKey )
 315 {
 316     ByteString aBStr( pImp->aCurrentApp, osl_getThreadTextEncoding() );
 317     ByteString aBStr1( rKey, osl_getThreadTextEncoding() );
 318     PrfWriteProfileString(
 319         HINI_USERPROFILE, (PCSZ)aBStr.GetBuffer(), (PCSZ)rKey.GetBuffer(), 0);
 320 }
 321
 322 // *****************************************************************************
 323
 324 #else
 325
 326 RegInfo::RegInfo()
 327 {
 328 }
 329
 330
 331 RegInfo::~RegInfo()
 332 {
 333 }
 334
 335 String RegInfo::GetKeyName( USHORT ) const
 336 {
 337     return String::EmptyString();
 338 }
 339
 340 USHORT RegInfo::GetKeyCount() const
 341 {
 342     return 0;
 343 }
 344
 345 void RegInfo::SetAppGroup( const String& )
 346 {
 347     return ;
 348 }
 349
 350 void RegInfo::DeleteAppGroup( const String& )
 351 {
 352     return;
 353 }
 354
 355 String  RegInfo::ReadKey( const String& ) const
 356 {
 357     return String::EmptyString();
 358 }
 359
 360 String  RegInfo::ReadKey( const String&, const String& ) const
 361 {
 362     return String::EmptyString();
 363 }
 364
 365 void RegInfo::WriteKey( const String&, const String& )
 366 {
 367     return;
 368 }
 369
 370 void RegInfo::DeleteKey( const String& )
 371 {
 372     return;
 373 }
 374
 375 #endif