1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski #ifndef _REGISTRY_REGISTRY_HXX_
25*b1cdbd2cSJim Jagielski #define _REGISTRY_REGISTRY_HXX_
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski #include <registry/regtype.h>
28*b1cdbd2cSJim Jagielski #include <rtl/ustring.hxx>
29*b1cdbd2cSJim Jagielski
30*b1cdbd2cSJim Jagielski #ifdef __cplusplus
31*b1cdbd2cSJim Jagielski extern "C" {
32*b1cdbd2cSJim Jagielski #endif
33*b1cdbd2cSJim Jagielski
34*b1cdbd2cSJim Jagielski /** specifies a collection of function pointers which represents the complete registry C-API.
35*b1cdbd2cSJim Jagielski
36*b1cdbd2cSJim Jagielski This funtions pointers are used by the C++ wrapper to call the C-API.
37*b1cdbd2cSJim Jagielski */
38*b1cdbd2cSJim Jagielski struct Registry_Api
39*b1cdbd2cSJim Jagielski {
40*b1cdbd2cSJim Jagielski void (REGISTRY_CALLTYPE *acquire) (RegHandle);
41*b1cdbd2cSJim Jagielski void (REGISTRY_CALLTYPE *release) (RegHandle);
42*b1cdbd2cSJim Jagielski sal_Bool (REGISTRY_CALLTYPE *isReadOnly) (RegHandle);
43*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *openRootKey) (RegHandle, RegKeyHandle*);
44*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getName) (RegHandle, rtl_uString**);
45*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *createRegistry) (rtl_uString*, RegHandle*);
46*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *openRegistry) (rtl_uString*, RegHandle*, RegAccessMode);
47*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *closeRegistry) (RegHandle);
48*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *destroyRegistry) (RegHandle, rtl_uString*);
49*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *loadKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*);
50*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *saveKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*);
51*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *mergeKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*, sal_Bool, sal_Bool);
52*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *dumpRegistry) (RegHandle, RegKeyHandle);
53*b1cdbd2cSJim Jagielski void (REGISTRY_CALLTYPE *acquireKey) (RegKeyHandle);
54*b1cdbd2cSJim Jagielski void (REGISTRY_CALLTYPE *releaseKey) (RegKeyHandle);
55*b1cdbd2cSJim Jagielski sal_Bool (REGISTRY_CALLTYPE *isKeyReadOnly) (RegKeyHandle);
56*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getKeyName) (RegKeyHandle, rtl_uString**);
57*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *createKey) (RegKeyHandle, rtl_uString*, RegKeyHandle*);
58*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *openKey) (RegKeyHandle, rtl_uString*, RegKeyHandle*);
59*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *openSubKeys) (RegKeyHandle, rtl_uString*, RegKeyHandle**, sal_uInt32*);
60*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *closeSubKeys) (RegKeyHandle*, sal_uInt32);
61*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *deleteKey) (RegKeyHandle, rtl_uString*);
62*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *closeKey) (RegKeyHandle);
63*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *setValue) (RegKeyHandle, rtl_uString*, RegValueType, RegValue, sal_uInt32);
64*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *setLongListValue) (RegKeyHandle, rtl_uString*, sal_Int32*, sal_uInt32);
65*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *setStringListValue) (RegKeyHandle, rtl_uString*, sal_Char**, sal_uInt32);
66*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *setUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode**, sal_uInt32);
67*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getValueInfo) (RegKeyHandle, rtl_uString*, RegValueType*, sal_uInt32*);
68*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getValue) (RegKeyHandle, rtl_uString*, RegValue);
69*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getLongListValue) (RegKeyHandle, rtl_uString*, sal_Int32**, sal_uInt32*);
70*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getStringListValue) (RegKeyHandle, rtl_uString*, sal_Char***, sal_uInt32*);
71*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode***, sal_uInt32*);
72*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *freeValueList) (RegValueType, RegValue, sal_uInt32);
73*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *createLink) (RegKeyHandle, rtl_uString*, rtl_uString*);
74*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *deleteLink) (RegKeyHandle, rtl_uString*);
75*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getKeyType) (RegKeyHandle, rtl_uString*, RegKeyType*);
76*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getLinkTarget) (RegKeyHandle, rtl_uString*, rtl_uString**);
77*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getResolvedKeyName) (RegKeyHandle, rtl_uString*, sal_Bool, rtl_uString**);
78*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *getKeyNames) (RegKeyHandle, rtl_uString*, rtl_uString***, sal_uInt32*);
79*b1cdbd2cSJim Jagielski RegError (REGISTRY_CALLTYPE *freeKeyNames) (rtl_uString**, sal_uInt32);
80*b1cdbd2cSJim Jagielski };
81*b1cdbd2cSJim Jagielski
82*b1cdbd2cSJim Jagielski /** the API initialization function.
83*b1cdbd2cSJim Jagielski */
84*b1cdbd2cSJim Jagielski Registry_Api* REGISTRY_CALLTYPE initRegistry_Api(void);
85*b1cdbd2cSJim Jagielski
86*b1cdbd2cSJim Jagielski #ifdef __cplusplus
87*b1cdbd2cSJim Jagielski }
88*b1cdbd2cSJim Jagielski #endif
89*b1cdbd2cSJim Jagielski
90*b1cdbd2cSJim Jagielski
91*b1cdbd2cSJim Jagielski class RegistryKey;
92*b1cdbd2cSJim Jagielski
93*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------------
94*b1cdbd2cSJim Jagielski
95*b1cdbd2cSJim Jagielski /** The Registry provides the functionality to read and write information in a registry file.
96*b1cdbd2cSJim Jagielski
97*b1cdbd2cSJim Jagielski The class is implemented inline and use a C-Api.
98*b1cdbd2cSJim Jagielski */
99*b1cdbd2cSJim Jagielski class Registry
100*b1cdbd2cSJim Jagielski {
101*b1cdbd2cSJim Jagielski public:
102*b1cdbd2cSJim Jagielski /** Default constructor.
103*b1cdbd2cSJim Jagielski */
104*b1cdbd2cSJim Jagielski inline Registry();
105*b1cdbd2cSJim Jagielski
106*b1cdbd2cSJim Jagielski /// Copy constructcor
107*b1cdbd2cSJim Jagielski inline Registry(const Registry& toCopy);
108*b1cdbd2cSJim Jagielski
109*b1cdbd2cSJim Jagielski /// Destructor. The Destructor close the registry if it is open.
110*b1cdbd2cSJim Jagielski inline ~Registry();
111*b1cdbd2cSJim Jagielski
112*b1cdbd2cSJim Jagielski /// Assign operator
113*b1cdbd2cSJim Jagielski inline Registry& operator = (const Registry& toAssign);
114*b1cdbd2cSJim Jagielski
115*b1cdbd2cSJim Jagielski /// checks if the registry points to a valid registry data file.
116*b1cdbd2cSJim Jagielski inline sal_Bool isValid() const;
117*b1cdbd2cSJim Jagielski
118*b1cdbd2cSJim Jagielski /** returns the access mode of the registry.
119*b1cdbd2cSJim Jagielski
120*b1cdbd2cSJim Jagielski @return TRUE if the access mode is readonly else FALSE.
121*b1cdbd2cSJim Jagielski */
122*b1cdbd2cSJim Jagielski inline sal_Bool isReadOnly() const;
123*b1cdbd2cSJim Jagielski
124*b1cdbd2cSJim Jagielski /** opens the root key of the registry.
125*b1cdbd2cSJim Jagielski
126*b1cdbd2cSJim Jagielski @param rRootKey reference to a RegistryKey which is filled with the rootkey.
127*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
128*b1cdbd2cSJim Jagielski */
129*b1cdbd2cSJim Jagielski inline RegError openRootKey(RegistryKey& rRootKey);
130*b1cdbd2cSJim Jagielski
131*b1cdbd2cSJim Jagielski /// returns the name of the current registry data file.
132*b1cdbd2cSJim Jagielski inline ::rtl::OUString getName();
133*b1cdbd2cSJim Jagielski
134*b1cdbd2cSJim Jagielski /** creates a new registry with the specified name and creates a root key.
135*b1cdbd2cSJim Jagielski
136*b1cdbd2cSJim Jagielski @param registryName specifies the name of the new registry.
137*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
138*b1cdbd2cSJim Jagielski */
139*b1cdbd2cSJim Jagielski inline RegError create(const ::rtl::OUString& registryName);
140*b1cdbd2cSJim Jagielski
141*b1cdbd2cSJim Jagielski /** opens a registry with the specified name.
142*b1cdbd2cSJim Jagielski
143*b1cdbd2cSJim Jagielski If the registry already points to a valid registry, the old registry will be closed.
144*b1cdbd2cSJim Jagielski @param registryName specifies a registry name.
145*b1cdbd2cSJim Jagielski @param accessMode specifies the access mode for the registry, REG_READONLY or REG_READWRITE.
146*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
147*b1cdbd2cSJim Jagielski */
148*b1cdbd2cSJim Jagielski inline RegError open(const ::rtl::OUString& registryName,
149*b1cdbd2cSJim Jagielski RegAccessMode accessMode);
150*b1cdbd2cSJim Jagielski
151*b1cdbd2cSJim Jagielski /// closes explicitly the current registry data file.
152*b1cdbd2cSJim Jagielski inline RegError close();
153*b1cdbd2cSJim Jagielski
154*b1cdbd2cSJim Jagielski /** destroys a registry.
155*b1cdbd2cSJim Jagielski
156*b1cdbd2cSJim Jagielski @param registryName specifies a registry name, if the name is an empty string the registry
157*b1cdbd2cSJim Jagielski itselfs will be destroyed.
158*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
159*b1cdbd2cSJim Jagielski */
160*b1cdbd2cSJim Jagielski inline RegError destroy(const ::rtl::OUString& registryName);
161*b1cdbd2cSJim Jagielski
162*b1cdbd2cSJim Jagielski /** loads registry information from a specified file and save it under the
163*b1cdbd2cSJim Jagielski specified keyName.
164*b1cdbd2cSJim Jagielski
165*b1cdbd2cSJim Jagielski @param rKey references a currently open key. The key which should store the registry information
166*b1cdbd2cSJim Jagielski is a subkey of this key.
167*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which stores the registry information. If keyName is
168*b1cdbd2cSJim Jagielski is an empty string the registry information will be saved under the key specified
169*b1cdbd2cSJim Jagielski by rKey.
170*b1cdbd2cSJim Jagielski @param regFileName specifies the file containing the registry information.
171*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
172*b1cdbd2cSJim Jagielski */
173*b1cdbd2cSJim Jagielski inline RegError loadKey(RegistryKey& rKey,
174*b1cdbd2cSJim Jagielski const ::rtl::OUString& keyName,
175*b1cdbd2cSJim Jagielski const ::rtl::OUString& regFileName);
176*b1cdbd2cSJim Jagielski
177*b1cdbd2cSJim Jagielski /** saves the registry information of the specified key and all subkeys and save
178*b1cdbd2cSJim Jagielski it in the specified file.
179*b1cdbd2cSJim Jagielski
180*b1cdbd2cSJim Jagielski @param rKey references a currently open key. The key which information is saved by this
181*b1cdbd2cSJim Jagielski function is a subkey of this key.
182*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which information should be stored.
183*b1cdbd2cSJim Jagielski If keyName is an empty string the registry information under the key specified
184*b1cdbd2cSJim Jagielski by rKey is saved in the specified file.
185*b1cdbd2cSJim Jagielski @param regFileName specifies the file containing the registry information.
186*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
187*b1cdbd2cSJim Jagielski */
188*b1cdbd2cSJim Jagielski inline RegError saveKey(RegistryKey& rKey,
189*b1cdbd2cSJim Jagielski const ::rtl::OUString& keyName,
190*b1cdbd2cSJim Jagielski const ::rtl::OUString& regFileName);
191*b1cdbd2cSJim Jagielski
192*b1cdbd2cSJim Jagielski /** merges the registry information of the specified key with the registry
193*b1cdbd2cSJim Jagielski information of the specified file.
194*b1cdbd2cSJim Jagielski
195*b1cdbd2cSJim Jagielski All existing keys will be extended and existing key values will be overwritten.
196*b1cdbd2cSJim Jagielski @param rKey references a currently open key. The key which information is merged by this
197*b1cdbd2cSJim Jagielski function is a subkey of this key
198*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which will be merged.
199*b1cdbd2cSJim Jagielski If keyName is an empty string the registry information under the key specified
200*b1cdbd2cSJim Jagielski by rKey is merged with the information from the specified file.
201*b1cdbd2cSJim Jagielski @param regFileName specifies the file containing the registry information.
202*b1cdbd2cSJim Jagielski @param bWarnings if TRUE the function returns an error if a key already exists.
203*b1cdbd2cSJim Jagielski @param bReport if TRUE the function reports warnings on stdout if a key already exists.
204*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code. If it returns an error the registry will
205*b1cdbd2cSJim Jagielski restore the state before merging.
206*b1cdbd2cSJim Jagielski */
207*b1cdbd2cSJim Jagielski inline RegError mergeKey(RegistryKey& rKey,
208*b1cdbd2cSJim Jagielski const ::rtl::OUString& keyName,
209*b1cdbd2cSJim Jagielski const ::rtl::OUString& regFileName,
210*b1cdbd2cSJim Jagielski sal_Bool bWarnings = sal_False,
211*b1cdbd2cSJim Jagielski sal_Bool bReport = sal_False);
212*b1cdbd2cSJim Jagielski
213*b1cdbd2cSJim Jagielski /** This function reports the complete registry information of a key and all of its subkeys.
214*b1cdbd2cSJim Jagielski
215*b1cdbd2cSJim Jagielski All information which are available (keynames, value types, values, ...)
216*b1cdbd2cSJim Jagielski will be printed to stdout for report issues only.
217*b1cdbd2cSJim Jagielski @param rKey references a currently open key which content will be reported.
218*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
219*b1cdbd2cSJim Jagielski */
220*b1cdbd2cSJim Jagielski inline RegError dumpRegistry(RegistryKey& rKey);
221*b1cdbd2cSJim Jagielski
222*b1cdbd2cSJim Jagielski friend class RegistryKey;
223*b1cdbd2cSJim Jagielski friend class RegistryKeyArray;
224*b1cdbd2cSJim Jagielski friend class RegistryKeyNames;
225*b1cdbd2cSJim Jagielski
226*b1cdbd2cSJim Jagielski /// returns the used registry Api.
getApi()227*b1cdbd2cSJim Jagielski const Registry_Api* getApi() { return m_pApi; }
228*b1cdbd2cSJim Jagielski protected:
229*b1cdbd2cSJim Jagielski
230*b1cdbd2cSJim Jagielski /// stores the used and initialized registry Api.
231*b1cdbd2cSJim Jagielski const Registry_Api* m_pApi;
232*b1cdbd2cSJim Jagielski /// stores the handle of the underlying registry file on which most of the functions work.
233*b1cdbd2cSJim Jagielski RegHandle m_hImpl;
234*b1cdbd2cSJim Jagielski };
235*b1cdbd2cSJim Jagielski
236*b1cdbd2cSJim Jagielski
237*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------------
238*b1cdbd2cSJim Jagielski
239*b1cdbd2cSJim Jagielski /** RegistryKeyArray represents an array of open keys.
240*b1cdbd2cSJim Jagielski
241*b1cdbd2cSJim Jagielski RegistryKeyArray is a helper class to work with an array of keys.
242*b1cdbd2cSJim Jagielski */
243*b1cdbd2cSJim Jagielski class RegistryKeyArray
244*b1cdbd2cSJim Jagielski {
245*b1cdbd2cSJim Jagielski public:
246*b1cdbd2cSJim Jagielski /// Default constructor
247*b1cdbd2cSJim Jagielski inline RegistryKeyArray();
248*b1cdbd2cSJim Jagielski
249*b1cdbd2cSJim Jagielski /// Destructor, all subkeys will be closed.
250*b1cdbd2cSJim Jagielski inline ~RegistryKeyArray();
251*b1cdbd2cSJim Jagielski
252*b1cdbd2cSJim Jagielski /// returns the open key specified by index.
253*b1cdbd2cSJim Jagielski inline RegistryKey getElement(sal_uInt32 index);
254*b1cdbd2cSJim Jagielski
255*b1cdbd2cSJim Jagielski /// returns the length of the array.
256*b1cdbd2cSJim Jagielski inline sal_uInt32 getLength();
257*b1cdbd2cSJim Jagielski
258*b1cdbd2cSJim Jagielski friend class RegistryKey;
259*b1cdbd2cSJim Jagielski protected:
260*b1cdbd2cSJim Jagielski /** sets the data of the key array.
261*b1cdbd2cSJim Jagielski
262*b1cdbd2cSJim Jagielski @param registry specifies the registry files where the keys are located.
263*b1cdbd2cSJim Jagielski @param phKeys points to an array of open keys.
264*b1cdbd2cSJim Jagielski @param length specifies the length of the array specified by phKeys.
265*b1cdbd2cSJim Jagielski */
266*b1cdbd2cSJim Jagielski inline void setKeyHandles(Registry& registry, RegKeyHandle* phKeys, sal_uInt32 length);
267*b1cdbd2cSJim Jagielski /// close all subkeys
268*b1cdbd2cSJim Jagielski inline RegError closeKeyHandles();
269*b1cdbd2cSJim Jagielski
270*b1cdbd2cSJim Jagielski /// stores the number of open subkeys, the number of elements.
271*b1cdbd2cSJim Jagielski sal_uInt32 m_length;
272*b1cdbd2cSJim Jagielski /// stores an array of open subkeys.
273*b1cdbd2cSJim Jagielski RegKeyHandle* m_phKeys;
274*b1cdbd2cSJim Jagielski /// stores the handle to the registry file where the appropriate keys are located.
275*b1cdbd2cSJim Jagielski Registry m_registry;
276*b1cdbd2cSJim Jagielski };
277*b1cdbd2cSJim Jagielski
278*b1cdbd2cSJim Jagielski
279*b1cdbd2cSJim Jagielski /** RegistryKeyNames represents an array of key names.
280*b1cdbd2cSJim Jagielski
281*b1cdbd2cSJim Jagielski RegistryKeyNames is a helper class to work with an array of key names.
282*b1cdbd2cSJim Jagielski */
283*b1cdbd2cSJim Jagielski class RegistryKeyNames
284*b1cdbd2cSJim Jagielski {
285*b1cdbd2cSJim Jagielski public:
286*b1cdbd2cSJim Jagielski /// Default constructor
287*b1cdbd2cSJim Jagielski inline RegistryKeyNames();
288*b1cdbd2cSJim Jagielski
289*b1cdbd2cSJim Jagielski /// Destructor, the internal array with key names will be deleted.
290*b1cdbd2cSJim Jagielski inline ~RegistryKeyNames();
291*b1cdbd2cSJim Jagielski
292*b1cdbd2cSJim Jagielski /// returns the name of the key sepecified by index.
293*b1cdbd2cSJim Jagielski inline ::rtl::OUString getElement(sal_uInt32 index);
294*b1cdbd2cSJim Jagielski
295*b1cdbd2cSJim Jagielski /// returns the length of the array.
296*b1cdbd2cSJim Jagielski inline sal_uInt32 getLength();
297*b1cdbd2cSJim Jagielski
298*b1cdbd2cSJim Jagielski friend class RegistryKey;
299*b1cdbd2cSJim Jagielski protected:
300*b1cdbd2cSJim Jagielski /** sets the data of the array.
301*b1cdbd2cSJim Jagielski
302*b1cdbd2cSJim Jagielski @param registry specifies the registry files where the keys are located.
303*b1cdbd2cSJim Jagielski @param pKeyNames points to an array of key names.
304*b1cdbd2cSJim Jagielski @param length specifies the length of the array specified by pKeyNames.
305*b1cdbd2cSJim Jagielski */
306*b1cdbd2cSJim Jagielski inline void setKeyNames(Registry& registry, rtl_uString** pKeyNames, sal_uInt32 length);
307*b1cdbd2cSJim Jagielski /// delete the array of key names.
308*b1cdbd2cSJim Jagielski inline RegError freeKeyNames();
309*b1cdbd2cSJim Jagielski
310*b1cdbd2cSJim Jagielski /// stores the number of key names, the number of elements.
311*b1cdbd2cSJim Jagielski sal_uInt32 m_length;
312*b1cdbd2cSJim Jagielski /// stores an array of key names.
313*b1cdbd2cSJim Jagielski rtl_uString** m_pKeyNames;
314*b1cdbd2cSJim Jagielski /// stores the handle to the registry file where the appropriate keys are located.
315*b1cdbd2cSJim Jagielski Registry m_registry;
316*b1cdbd2cSJim Jagielski };
317*b1cdbd2cSJim Jagielski
318*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------------
319*b1cdbd2cSJim Jagielski
320*b1cdbd2cSJim Jagielski /** RegistryValueList represents a value list of the specified type.
321*b1cdbd2cSJim Jagielski
322*b1cdbd2cSJim Jagielski RegistryValueList is a helper class to work with a list value.
323*b1cdbd2cSJim Jagielski */
324*b1cdbd2cSJim Jagielski template<class ValueType>
325*b1cdbd2cSJim Jagielski class RegistryValueList
326*b1cdbd2cSJim Jagielski {
327*b1cdbd2cSJim Jagielski public:
328*b1cdbd2cSJim Jagielski /// Default constructor
RegistryValueList()329*b1cdbd2cSJim Jagielski RegistryValueList()
330*b1cdbd2cSJim Jagielski : m_length(0)
331*b1cdbd2cSJim Jagielski , m_pValueList(NULL)
332*b1cdbd2cSJim Jagielski , m_valueType(RG_VALUETYPE_NOT_DEFINED)
333*b1cdbd2cSJim Jagielski {}
334*b1cdbd2cSJim Jagielski
335*b1cdbd2cSJim Jagielski /// Destructor, the internal value list will be freed.
~RegistryValueList()336*b1cdbd2cSJim Jagielski ~RegistryValueList()
337*b1cdbd2cSJim Jagielski {
338*b1cdbd2cSJim Jagielski if (m_pValueList)
339*b1cdbd2cSJim Jagielski {
340*b1cdbd2cSJim Jagielski m_registry.getApi()->freeValueList(m_valueType, m_pValueList, m_length);
341*b1cdbd2cSJim Jagielski }
342*b1cdbd2cSJim Jagielski }
343*b1cdbd2cSJim Jagielski
344*b1cdbd2cSJim Jagielski /// returns the value of the list specified by index.
getElement(sal_uInt32 index)345*b1cdbd2cSJim Jagielski ValueType getElement(sal_uInt32 index)
346*b1cdbd2cSJim Jagielski {
347*b1cdbd2cSJim Jagielski if (m_registry.isValid() && index < m_length)
348*b1cdbd2cSJim Jagielski {
349*b1cdbd2cSJim Jagielski return m_pValueList[index];
350*b1cdbd2cSJim Jagielski } else
351*b1cdbd2cSJim Jagielski {
352*b1cdbd2cSJim Jagielski return 0;
353*b1cdbd2cSJim Jagielski }
354*b1cdbd2cSJim Jagielski }
355*b1cdbd2cSJim Jagielski
356*b1cdbd2cSJim Jagielski /// returns the length of the list.
getLength()357*b1cdbd2cSJim Jagielski sal_uInt32 getLength()
358*b1cdbd2cSJim Jagielski {
359*b1cdbd2cSJim Jagielski return m_length;
360*b1cdbd2cSJim Jagielski }
361*b1cdbd2cSJim Jagielski
362*b1cdbd2cSJim Jagielski friend class RegistryKey;
363*b1cdbd2cSJim Jagielski protected:
364*b1cdbd2cSJim Jagielski /** sets the data of the value list.
365*b1cdbd2cSJim Jagielski
366*b1cdbd2cSJim Jagielski @param registry specifies the registry files where the appropriate key is located.
367*b1cdbd2cSJim Jagielski @param valueType specifies the type of the list values.
368*b1cdbd2cSJim Jagielski @param pValueList points to a value list.
369*b1cdbd2cSJim Jagielski @param length specifies the length of the list.
370*b1cdbd2cSJim Jagielski */
setValueList(Registry & registry,RegValueType valueType,ValueType * pValueList,sal_uInt32 length)371*b1cdbd2cSJim Jagielski void setValueList(Registry& registry, RegValueType valueType,
372*b1cdbd2cSJim Jagielski ValueType* pValueList, sal_uInt32 length)
373*b1cdbd2cSJim Jagielski {
374*b1cdbd2cSJim Jagielski m_length = length;
375*b1cdbd2cSJim Jagielski m_pValueList = pValueList;
376*b1cdbd2cSJim Jagielski m_valueType = valueType;
377*b1cdbd2cSJim Jagielski m_registry = registry;
378*b1cdbd2cSJim Jagielski }
379*b1cdbd2cSJim Jagielski
380*b1cdbd2cSJim Jagielski /// stores the length of the list, the number of elements.
381*b1cdbd2cSJim Jagielski sal_uInt32 m_length;
382*b1cdbd2cSJim Jagielski /// stores the value list.
383*b1cdbd2cSJim Jagielski ValueType* m_pValueList;
384*b1cdbd2cSJim Jagielski /// stores the type of the list elements
385*b1cdbd2cSJim Jagielski RegValueType m_valueType;
386*b1cdbd2cSJim Jagielski /** stores the handle to the registry file where the appropriate key to this
387*b1cdbd2cSJim Jagielski value is located.
388*b1cdbd2cSJim Jagielski */
389*b1cdbd2cSJim Jagielski Registry m_registry;
390*b1cdbd2cSJim Jagielski };
391*b1cdbd2cSJim Jagielski
392*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------------
393*b1cdbd2cSJim Jagielski
394*b1cdbd2cSJim Jagielski /** RegistryKey reads or writes information of the underlying key in a registry.
395*b1cdbd2cSJim Jagielski
396*b1cdbd2cSJim Jagielski Class is inline and use a load on call C-Api.
397*b1cdbd2cSJim Jagielski */
398*b1cdbd2cSJim Jagielski class RegistryKey
399*b1cdbd2cSJim Jagielski {
400*b1cdbd2cSJim Jagielski public:
401*b1cdbd2cSJim Jagielski /// Default constructor
402*b1cdbd2cSJim Jagielski inline RegistryKey();
403*b1cdbd2cSJim Jagielski
404*b1cdbd2cSJim Jagielski /// Copy constructor
405*b1cdbd2cSJim Jagielski inline RegistryKey(const RegistryKey& toCopy);
406*b1cdbd2cSJim Jagielski
407*b1cdbd2cSJim Jagielski /// Destructor, close the key if it references an open one.
408*b1cdbd2cSJim Jagielski inline ~RegistryKey();
409*b1cdbd2cSJim Jagielski
410*b1cdbd2cSJim Jagielski /// Assign operator
411*b1cdbd2cSJim Jagielski inline RegistryKey& operator = (const RegistryKey& toAssign);
412*b1cdbd2cSJim Jagielski
413*b1cdbd2cSJim Jagielski /// checks if the key points to a valid registry key.
414*b1cdbd2cSJim Jagielski inline sal_Bool isValid() const;
415*b1cdbd2cSJim Jagielski
416*b1cdbd2cSJim Jagielski /** returns the access mode of the key.
417*b1cdbd2cSJim Jagielski
418*b1cdbd2cSJim Jagielski @return TRUE if access mode is read only else FALSE.
419*b1cdbd2cSJim Jagielski */
420*b1cdbd2cSJim Jagielski inline sal_Bool isReadOnly() const;
421*b1cdbd2cSJim Jagielski
422*b1cdbd2cSJim Jagielski /// returns the full qualified name of the key beginning with the rootkey.
423*b1cdbd2cSJim Jagielski inline ::rtl::OUString getName();
424*b1cdbd2cSJim Jagielski
425*b1cdbd2cSJim Jagielski /** creates a new key or opens a key if the specified key already exists.
426*b1cdbd2cSJim Jagielski
427*b1cdbd2cSJim Jagielski The specified keyname is relativ to this key.
428*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which will be opened or created.
429*b1cdbd2cSJim Jagielski @param rNewKey references a RegistryKey which will be filled with the new or open key.
430*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
431*b1cdbd2cSJim Jagielski */
432*b1cdbd2cSJim Jagielski inline RegError createKey(const ::rtl::OUString& keyName,
433*b1cdbd2cSJim Jagielski RegistryKey& rNewKey);
434*b1cdbd2cSJim Jagielski
435*b1cdbd2cSJim Jagielski /** opens the specified key.
436*b1cdbd2cSJim Jagielski
437*b1cdbd2cSJim Jagielski The specified keyname is relativ to this key.
438*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which will be opened.
439*b1cdbd2cSJim Jagielski @param rOpenKey references a RegistryKey which will be filled with the open key.
440*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
441*b1cdbd2cSJim Jagielski */
442*b1cdbd2cSJim Jagielski inline RegError openKey(const ::rtl::OUString& keyName,
443*b1cdbd2cSJim Jagielski RegistryKey& rOpenKey);
444*b1cdbd2cSJim Jagielski
445*b1cdbd2cSJim Jagielski /** opens all subkeys of the specified key.
446*b1cdbd2cSJim Jagielski
447*b1cdbd2cSJim Jagielski The specified keyname is relativ to this key.
448*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which subkeys will be opened.
449*b1cdbd2cSJim Jagielski @param rSubKeys reference a RegistryKeyArray which will be filled with the open subkeys.
450*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
451*b1cdbd2cSJim Jagielski */
452*b1cdbd2cSJim Jagielski inline RegError openSubKeys(const ::rtl::OUString& keyName,
453*b1cdbd2cSJim Jagielski RegistryKeyArray& rSubKeys);
454*b1cdbd2cSJim Jagielski
455*b1cdbd2cSJim Jagielski /** returns an array with the names of all subkeys of the specified key.
456*b1cdbd2cSJim Jagielski
457*b1cdbd2cSJim Jagielski The specified keyname is relativ to this key.
458*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which subkey names will be returned.
459*b1cdbd2cSJim Jagielski @param rSubKeyNames reference a RegistryKeyNames array which will be filled with the subkey names.
460*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
461*b1cdbd2cSJim Jagielski */
462*b1cdbd2cSJim Jagielski inline RegError getKeyNames(const ::rtl::OUString& keyName,
463*b1cdbd2cSJim Jagielski RegistryKeyNames& rSubKeyNames);
464*b1cdbd2cSJim Jagielski
465*b1cdbd2cSJim Jagielski /** closes all keys specified in the array.
466*b1cdbd2cSJim Jagielski
467*b1cdbd2cSJim Jagielski @param rSubKeys reference a RegistryKeyArray which contains the open keys.
468*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
469*b1cdbd2cSJim Jagielski */
470*b1cdbd2cSJim Jagielski inline RegError closeSubKeys(RegistryKeyArray& rSubKeys);
471*b1cdbd2cSJim Jagielski
472*b1cdbd2cSJim Jagielski /** deletes the specified key.
473*b1cdbd2cSJim Jagielski
474*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which will be deleted.
475*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
476*b1cdbd2cSJim Jagielski */
477*b1cdbd2cSJim Jagielski inline RegError deleteKey(const ::rtl::OUString& keyName);
478*b1cdbd2cSJim Jagielski
479*b1cdbd2cSJim Jagielski /// closes explicitly the current key
480*b1cdbd2cSJim Jagielski inline RegError closeKey();
481*b1cdbd2cSJim Jagielski
482*b1cdbd2cSJim Jagielski /// releases the current key
483*b1cdbd2cSJim Jagielski inline void releaseKey();
484*b1cdbd2cSJim Jagielski
485*b1cdbd2cSJim Jagielski /** sets a value of a key.
486*b1cdbd2cSJim Jagielski
487*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which value will be set.
488*b1cdbd2cSJim Jagielski If keyName is an empty string, the value will be set for the key
489*b1cdbd2cSJim Jagielski specified by hKey.
490*b1cdbd2cSJim Jagielski @param valueType specifies the type of the value.
491*b1cdbd2cSJim Jagielski @param pData points to a memory block containing the data for the value.
492*b1cdbd2cSJim Jagielski @param valueSize specifies the size of pData in bytes
493*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
494*b1cdbd2cSJim Jagielski */
495*b1cdbd2cSJim Jagielski inline RegError setValue(const ::rtl::OUString& keyName,
496*b1cdbd2cSJim Jagielski RegValueType valueType,
497*b1cdbd2cSJim Jagielski RegValue pValue,
498*b1cdbd2cSJim Jagielski sal_uInt32 valueSize);
499*b1cdbd2cSJim Jagielski
500*b1cdbd2cSJim Jagielski /** sets a long list value of a key.
501*b1cdbd2cSJim Jagielski
502*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which value will be set.
503*b1cdbd2cSJim Jagielski If keyName is an empty string, the value will be set for the key
504*b1cdbd2cSJim Jagielski specified by hKey.
505*b1cdbd2cSJim Jagielski @param pValueList points to an array of longs containing the data for the value.
506*b1cdbd2cSJim Jagielski @param len specifies the length of the list (the array referenced by pValueList).
507*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
508*b1cdbd2cSJim Jagielski */
509*b1cdbd2cSJim Jagielski inline RegError setLongListValue(const ::rtl::OUString& keyName,
510*b1cdbd2cSJim Jagielski sal_Int32* pValueList,
511*b1cdbd2cSJim Jagielski sal_uInt32 len);
512*b1cdbd2cSJim Jagielski
513*b1cdbd2cSJim Jagielski /** sets an ascii list value of a key.
514*b1cdbd2cSJim Jagielski
515*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which value will be set.
516*b1cdbd2cSJim Jagielski If keyName is an empty string, the value will be set for the key
517*b1cdbd2cSJim Jagielski specified by hKey.
518*b1cdbd2cSJim Jagielski @param pValueList points to an array of sal_Char* containing the data for the value.
519*b1cdbd2cSJim Jagielski @param len specifies the length of the list (the array referenced by pValueList).
520*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
521*b1cdbd2cSJim Jagielski */
522*b1cdbd2cSJim Jagielski inline RegError setStringListValue(const ::rtl::OUString& keyName,
523*b1cdbd2cSJim Jagielski sal_Char** pValueList,
524*b1cdbd2cSJim Jagielski sal_uInt32 len);
525*b1cdbd2cSJim Jagielski
526*b1cdbd2cSJim Jagielski /** sets an unicode string list value of a key.
527*b1cdbd2cSJim Jagielski
528*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which value will be set.
529*b1cdbd2cSJim Jagielski If keyName is an empty string, the value will be set for the key
530*b1cdbd2cSJim Jagielski specified by hKey.
531*b1cdbd2cSJim Jagielski @param pValueList points to an array of sal_Unicode* containing the data for the value.
532*b1cdbd2cSJim Jagielski @param len specifies the length of the list (the array referenced by pValueList).
533*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
534*b1cdbd2cSJim Jagielski */
535*b1cdbd2cSJim Jagielski inline RegError setUnicodeListValue(const ::rtl::OUString& keyName,
536*b1cdbd2cSJim Jagielski sal_Unicode** pValueList,
537*b1cdbd2cSJim Jagielski sal_uInt32 len);
538*b1cdbd2cSJim Jagielski
539*b1cdbd2cSJim Jagielski /** gets info about type and size of a value.
540*b1cdbd2cSJim Jagielski
541*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which value info will be returned.
542*b1cdbd2cSJim Jagielski If keyName is an empty string, the value info of the key
543*b1cdbd2cSJim Jagielski specified by hKey will be returned.
544*b1cdbd2cSJim Jagielski @param pValueType returns the type of the value.
545*b1cdbd2cSJim Jagielski @param pValueSize returns the size of the value in bytes or the length of a list value.
546*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
547*b1cdbd2cSJim Jagielski */
548*b1cdbd2cSJim Jagielski inline RegError getValueInfo(const ::rtl::OUString& keyName,
549*b1cdbd2cSJim Jagielski RegValueType* pValueType,
550*b1cdbd2cSJim Jagielski sal_uInt32* pValueSize);
551*b1cdbd2cSJim Jagielski
552*b1cdbd2cSJim Jagielski /** gets the value of a key.
553*b1cdbd2cSJim Jagielski
554*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which value will be returned.
555*b1cdbd2cSJim Jagielski If keyName is an empty string, the value is get from the key
556*b1cdbd2cSJim Jagielski specified by hKey.
557*b1cdbd2cSJim Jagielski @param pValue points to an allocated memory block receiving the data of the value.
558*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
559*b1cdbd2cSJim Jagielski */
560*b1cdbd2cSJim Jagielski inline RegError getValue(const ::rtl::OUString& keyName,
561*b1cdbd2cSJim Jagielski RegValue pValue);
562*b1cdbd2cSJim Jagielski
563*b1cdbd2cSJim Jagielski /** gets a long list value of a key.
564*b1cdbd2cSJim Jagielski
565*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which value will be returned.
566*b1cdbd2cSJim Jagielski If keyName is an empty string, the value is get from the key
567*b1cdbd2cSJim Jagielski specified by hKey.
568*b1cdbd2cSJim Jagielski @param rValueList references a RegistryValueList which will be filled with the long values.
569*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
570*b1cdbd2cSJim Jagielski */
571*b1cdbd2cSJim Jagielski inline RegError getLongListValue(const ::rtl::OUString& keyName,
572*b1cdbd2cSJim Jagielski RegistryValueList<sal_Int32>& rValueList);
573*b1cdbd2cSJim Jagielski
574*b1cdbd2cSJim Jagielski /** gets an ascii list value of a key.
575*b1cdbd2cSJim Jagielski
576*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which value will be returned.
577*b1cdbd2cSJim Jagielski If keyName is an empty string, the value is get from the key
578*b1cdbd2cSJim Jagielski specified by hKey.
579*b1cdbd2cSJim Jagielski @param rValueList references a RegistryValueList which will be filled with the ascii values.
580*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
581*b1cdbd2cSJim Jagielski */
582*b1cdbd2cSJim Jagielski inline RegError getStringListValue(const ::rtl::OUString& keyName,
583*b1cdbd2cSJim Jagielski RegistryValueList<sal_Char*>& rValueList);
584*b1cdbd2cSJim Jagielski
585*b1cdbd2cSJim Jagielski /** gets a unicode value of a key.
586*b1cdbd2cSJim Jagielski
587*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which value will be returned.
588*b1cdbd2cSJim Jagielski If keyName is an empty string, the value is get from the key
589*b1cdbd2cSJim Jagielski specified by hKey.
590*b1cdbd2cSJim Jagielski @param rValueList reference a RegistryValueList which will be filled with the unicode values.
591*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
592*b1cdbd2cSJim Jagielski */
593*b1cdbd2cSJim Jagielski inline RegError getUnicodeListValue(const ::rtl::OUString& keyName,
594*b1cdbd2cSJim Jagielski RegistryValueList<sal_Unicode*>& rValueList);
595*b1cdbd2cSJim Jagielski
596*b1cdbd2cSJim Jagielski /** used to create a link.
597*b1cdbd2cSJim Jagielski
598*b1cdbd2cSJim Jagielski @obsolete Links are no longer supported.
599*b1cdbd2cSJim Jagielski
600*b1cdbd2cSJim Jagielski @return REG_INVALID_LINK
601*b1cdbd2cSJim Jagielski */
602*b1cdbd2cSJim Jagielski inline RegError createLink(const ::rtl::OUString& linkName,
603*b1cdbd2cSJim Jagielski const ::rtl::OUString& linkTarget);
604*b1cdbd2cSJim Jagielski
605*b1cdbd2cSJim Jagielski /** used to delete a link.
606*b1cdbd2cSJim Jagielski
607*b1cdbd2cSJim Jagielski @obsolete Links are no longer supported.
608*b1cdbd2cSJim Jagielski
609*b1cdbd2cSJim Jagielski @return REG_INVALID_LINK
610*b1cdbd2cSJim Jagielski */
611*b1cdbd2cSJim Jagielski inline RegError deleteLink(const ::rtl::OUString& linkName);
612*b1cdbd2cSJim Jagielski
613*b1cdbd2cSJim Jagielski /** returns the type of the specified key.
614*b1cdbd2cSJim Jagielski
615*b1cdbd2cSJim Jagielski @param name specifies the name of the key or link.
616*b1cdbd2cSJim Jagielski @param pKeyType returns the type of the key (always RG_KEYTYPE).
617*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
618*b1cdbd2cSJim Jagielski */
619*b1cdbd2cSJim Jagielski inline RegError getKeyType(const ::rtl::OUString& name,
620*b1cdbd2cSJim Jagielski RegKeyType* pKeyType) const;
621*b1cdbd2cSJim Jagielski
622*b1cdbd2cSJim Jagielski /** used to return the target of a link.
623*b1cdbd2cSJim Jagielski
624*b1cdbd2cSJim Jagielski @obsolete Links are no longer supported.
625*b1cdbd2cSJim Jagielski
626*b1cdbd2cSJim Jagielski @return REG_INVALID_LINK
627*b1cdbd2cSJim Jagielski */
628*b1cdbd2cSJim Jagielski inline RegError getLinkTarget(const ::rtl::OUString& linkName,
629*b1cdbd2cSJim Jagielski ::rtl::OUString& rLinkTarget) const;
630*b1cdbd2cSJim Jagielski
631*b1cdbd2cSJim Jagielski /** resolves a keyname.
632*b1cdbd2cSJim Jagielski
633*b1cdbd2cSJim Jagielski @param keyName specifies the name of the key which will be resolved relativ to this key.
634*b1cdbd2cSJim Jagielski The resolved name will be prefixed with the name of this key.
635*b1cdbd2cSJim Jagielski @param firstLinkOnly ignored
636*b1cdbd2cSJim Jagielski @return REG_NO_ERROR if succeeds else an error code.
637*b1cdbd2cSJim Jagielski */
638*b1cdbd2cSJim Jagielski inline RegError getResolvedKeyName(const ::rtl::OUString& keyName,
639*b1cdbd2cSJim Jagielski sal_Bool firstLinkOnly,
640*b1cdbd2cSJim Jagielski ::rtl::OUString& rResolvedName) const;
641*b1cdbd2cSJim Jagielski
642*b1cdbd2cSJim Jagielski /// returns the name of the registry in which the key is defined.
643*b1cdbd2cSJim Jagielski inline ::rtl::OUString getRegistryName();
644*b1cdbd2cSJim Jagielski
645*b1cdbd2cSJim Jagielski /// returns the registry in which the key is defined.
getRegistry() const646*b1cdbd2cSJim Jagielski Registry getRegistry() const { return m_registry; }
647*b1cdbd2cSJim Jagielski
648*b1cdbd2cSJim Jagielski friend class Registry;
649*b1cdbd2cSJim Jagielski public:
650*b1cdbd2cSJim Jagielski /** Constructor, which initialize a RegistryKey with registry and an valid key handle.
651*b1cdbd2cSJim Jagielski
652*b1cdbd2cSJim Jagielski This constructor is internal only.
653*b1cdbd2cSJim Jagielski @internal
654*b1cdbd2cSJim Jagielski */
655*b1cdbd2cSJim Jagielski inline RegistryKey(Registry& registry,
656*b1cdbd2cSJim Jagielski RegKeyHandle hKey);
657*b1cdbd2cSJim Jagielski
658*b1cdbd2cSJim Jagielski /** returns the internal key handle.
659*b1cdbd2cSJim Jagielski
660*b1cdbd2cSJim Jagielski @internal
661*b1cdbd2cSJim Jagielski */
getKeyHandle() const662*b1cdbd2cSJim Jagielski RegKeyHandle getKeyHandle() const { return m_hImpl; }
663*b1cdbd2cSJim Jagielski
664*b1cdbd2cSJim Jagielski protected:
665*b1cdbd2cSJim Jagielski /** sets the internal registry on which this key should work.
666*b1cdbd2cSJim Jagielski
667*b1cdbd2cSJim Jagielski @internal
668*b1cdbd2cSJim Jagielski */
669*b1cdbd2cSJim Jagielski inline void setRegistry(Registry& registry);
670*b1cdbd2cSJim Jagielski
671*b1cdbd2cSJim Jagielski /// stores the registry on which this key works
672*b1cdbd2cSJim Jagielski Registry m_registry;
673*b1cdbd2cSJim Jagielski /// stores the current key handle of this key
674*b1cdbd2cSJim Jagielski RegKeyHandle m_hImpl;
675*b1cdbd2cSJim Jagielski };
676*b1cdbd2cSJim Jagielski
677*b1cdbd2cSJim Jagielski
678*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------------
679*b1cdbd2cSJim Jagielski
RegistryKeyArray()680*b1cdbd2cSJim Jagielski inline RegistryKeyArray::RegistryKeyArray()
681*b1cdbd2cSJim Jagielski : m_length(0)
682*b1cdbd2cSJim Jagielski , m_phKeys(NULL)
683*b1cdbd2cSJim Jagielski {
684*b1cdbd2cSJim Jagielski }
685*b1cdbd2cSJim Jagielski
~RegistryKeyArray()686*b1cdbd2cSJim Jagielski inline RegistryKeyArray::~RegistryKeyArray()
687*b1cdbd2cSJim Jagielski {
688*b1cdbd2cSJim Jagielski if (m_phKeys)
689*b1cdbd2cSJim Jagielski m_registry.m_pApi->closeSubKeys(m_phKeys, m_length);
690*b1cdbd2cSJim Jagielski }
691*b1cdbd2cSJim Jagielski
getElement(sal_uInt32 index)692*b1cdbd2cSJim Jagielski inline RegistryKey RegistryKeyArray::getElement(sal_uInt32 index)
693*b1cdbd2cSJim Jagielski {
694*b1cdbd2cSJim Jagielski if (m_registry.isValid() && index < m_length)
695*b1cdbd2cSJim Jagielski return RegistryKey(m_registry, m_phKeys[index]);
696*b1cdbd2cSJim Jagielski else
697*b1cdbd2cSJim Jagielski return RegistryKey();
698*b1cdbd2cSJim Jagielski }
699*b1cdbd2cSJim Jagielski
getLength()700*b1cdbd2cSJim Jagielski inline sal_uInt32 RegistryKeyArray::getLength()
701*b1cdbd2cSJim Jagielski {
702*b1cdbd2cSJim Jagielski return m_length;
703*b1cdbd2cSJim Jagielski }
704*b1cdbd2cSJim Jagielski
setKeyHandles(Registry & registry,RegKeyHandle * phKeys,sal_uInt32 length)705*b1cdbd2cSJim Jagielski inline void RegistryKeyArray::setKeyHandles(Registry& registry,
706*b1cdbd2cSJim Jagielski RegKeyHandle* phKeys,
707*b1cdbd2cSJim Jagielski sal_uInt32 length)
708*b1cdbd2cSJim Jagielski {
709*b1cdbd2cSJim Jagielski m_phKeys = phKeys;
710*b1cdbd2cSJim Jagielski m_length = length;
711*b1cdbd2cSJim Jagielski m_registry = registry;
712*b1cdbd2cSJim Jagielski }
713*b1cdbd2cSJim Jagielski
closeKeyHandles()714*b1cdbd2cSJim Jagielski inline RegError RegistryKeyArray::closeKeyHandles()
715*b1cdbd2cSJim Jagielski {
716*b1cdbd2cSJim Jagielski if (m_registry.isValid() && m_phKeys)
717*b1cdbd2cSJim Jagielski {
718*b1cdbd2cSJim Jagielski RegError ret;
719*b1cdbd2cSJim Jagielski ret = m_registry.m_pApi->closeSubKeys(m_phKeys, m_length);
720*b1cdbd2cSJim Jagielski m_registry = Registry();
721*b1cdbd2cSJim Jagielski m_length = 0;
722*b1cdbd2cSJim Jagielski m_phKeys = NULL;
723*b1cdbd2cSJim Jagielski return ret;
724*b1cdbd2cSJim Jagielski } else
725*b1cdbd2cSJim Jagielski return(REG_INVALID_KEY);
726*b1cdbd2cSJim Jagielski }
727*b1cdbd2cSJim Jagielski
728*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------------
729*b1cdbd2cSJim Jagielski
RegistryKeyNames()730*b1cdbd2cSJim Jagielski inline RegistryKeyNames::RegistryKeyNames()
731*b1cdbd2cSJim Jagielski : m_length(0)
732*b1cdbd2cSJim Jagielski , m_pKeyNames(NULL)
733*b1cdbd2cSJim Jagielski {
734*b1cdbd2cSJim Jagielski }
735*b1cdbd2cSJim Jagielski
~RegistryKeyNames()736*b1cdbd2cSJim Jagielski inline RegistryKeyNames::~RegistryKeyNames()
737*b1cdbd2cSJim Jagielski {
738*b1cdbd2cSJim Jagielski if (m_pKeyNames)
739*b1cdbd2cSJim Jagielski m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length);
740*b1cdbd2cSJim Jagielski }
741*b1cdbd2cSJim Jagielski
getElement(sal_uInt32 index)742*b1cdbd2cSJim Jagielski inline ::rtl::OUString RegistryKeyNames::getElement(sal_uInt32 index)
743*b1cdbd2cSJim Jagielski {
744*b1cdbd2cSJim Jagielski
745*b1cdbd2cSJim Jagielski if (m_pKeyNames && index < m_length)
746*b1cdbd2cSJim Jagielski return m_pKeyNames[index];
747*b1cdbd2cSJim Jagielski else
748*b1cdbd2cSJim Jagielski return ::rtl::OUString();
749*b1cdbd2cSJim Jagielski }
750*b1cdbd2cSJim Jagielski
getLength()751*b1cdbd2cSJim Jagielski inline sal_uInt32 RegistryKeyNames::getLength()
752*b1cdbd2cSJim Jagielski {
753*b1cdbd2cSJim Jagielski return m_length;
754*b1cdbd2cSJim Jagielski }
755*b1cdbd2cSJim Jagielski
setKeyNames(Registry & registry,rtl_uString ** pKeyNames,sal_uInt32 length)756*b1cdbd2cSJim Jagielski inline void RegistryKeyNames::setKeyNames(Registry& registry,
757*b1cdbd2cSJim Jagielski rtl_uString** pKeyNames,
758*b1cdbd2cSJim Jagielski sal_uInt32 length)
759*b1cdbd2cSJim Jagielski {
760*b1cdbd2cSJim Jagielski m_pKeyNames = pKeyNames;
761*b1cdbd2cSJim Jagielski m_length = length;
762*b1cdbd2cSJim Jagielski m_registry = registry;
763*b1cdbd2cSJim Jagielski }
764*b1cdbd2cSJim Jagielski
freeKeyNames()765*b1cdbd2cSJim Jagielski inline RegError RegistryKeyNames::freeKeyNames()
766*b1cdbd2cSJim Jagielski {
767*b1cdbd2cSJim Jagielski if (m_registry.isValid() && m_pKeyNames)
768*b1cdbd2cSJim Jagielski {
769*b1cdbd2cSJim Jagielski RegError ret = REG_NO_ERROR;
770*b1cdbd2cSJim Jagielski ret = m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length);
771*b1cdbd2cSJim Jagielski m_registry = Registry();
772*b1cdbd2cSJim Jagielski m_length = 0;
773*b1cdbd2cSJim Jagielski m_pKeyNames = NULL;
774*b1cdbd2cSJim Jagielski return ret;
775*b1cdbd2cSJim Jagielski } else
776*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
777*b1cdbd2cSJim Jagielski }
778*b1cdbd2cSJim Jagielski
779*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------------
780*b1cdbd2cSJim Jagielski
RegistryKey()781*b1cdbd2cSJim Jagielski inline RegistryKey::RegistryKey()
782*b1cdbd2cSJim Jagielski : m_hImpl(NULL)
783*b1cdbd2cSJim Jagielski { }
784*b1cdbd2cSJim Jagielski
RegistryKey(Registry & registry,RegKeyHandle hKey)785*b1cdbd2cSJim Jagielski inline RegistryKey::RegistryKey(Registry& registry, RegKeyHandle hKey)
786*b1cdbd2cSJim Jagielski : m_registry(registry)
787*b1cdbd2cSJim Jagielski , m_hImpl(hKey)
788*b1cdbd2cSJim Jagielski {
789*b1cdbd2cSJim Jagielski if (m_hImpl)
790*b1cdbd2cSJim Jagielski m_registry.m_pApi->acquireKey(m_hImpl);
791*b1cdbd2cSJim Jagielski }
792*b1cdbd2cSJim Jagielski
RegistryKey(const RegistryKey & toCopy)793*b1cdbd2cSJim Jagielski inline RegistryKey::RegistryKey(const RegistryKey& toCopy)
794*b1cdbd2cSJim Jagielski : m_registry(toCopy.m_registry)
795*b1cdbd2cSJim Jagielski , m_hImpl(toCopy.m_hImpl)
796*b1cdbd2cSJim Jagielski {
797*b1cdbd2cSJim Jagielski if (m_hImpl)
798*b1cdbd2cSJim Jagielski m_registry.m_pApi->acquireKey(m_hImpl);
799*b1cdbd2cSJim Jagielski }
800*b1cdbd2cSJim Jagielski
setRegistry(Registry & registry)801*b1cdbd2cSJim Jagielski inline void RegistryKey::setRegistry(Registry& registry)
802*b1cdbd2cSJim Jagielski {
803*b1cdbd2cSJim Jagielski m_registry = registry;
804*b1cdbd2cSJim Jagielski }
805*b1cdbd2cSJim Jagielski
~RegistryKey()806*b1cdbd2cSJim Jagielski inline RegistryKey::~RegistryKey()
807*b1cdbd2cSJim Jagielski {
808*b1cdbd2cSJim Jagielski if (m_hImpl)
809*b1cdbd2cSJim Jagielski m_registry.m_pApi->releaseKey(m_hImpl);
810*b1cdbd2cSJim Jagielski }
811*b1cdbd2cSJim Jagielski
operator =(const RegistryKey & toAssign)812*b1cdbd2cSJim Jagielski inline RegistryKey& RegistryKey::operator = (const RegistryKey& toAssign)
813*b1cdbd2cSJim Jagielski {
814*b1cdbd2cSJim Jagielski m_registry = toAssign.m_registry;
815*b1cdbd2cSJim Jagielski
816*b1cdbd2cSJim Jagielski if (toAssign.m_hImpl)
817*b1cdbd2cSJim Jagielski m_registry.m_pApi->acquireKey(toAssign.m_hImpl);
818*b1cdbd2cSJim Jagielski if (m_hImpl)
819*b1cdbd2cSJim Jagielski m_registry.m_pApi->releaseKey(m_hImpl);
820*b1cdbd2cSJim Jagielski m_hImpl = toAssign.m_hImpl;
821*b1cdbd2cSJim Jagielski
822*b1cdbd2cSJim Jagielski return *this;
823*b1cdbd2cSJim Jagielski }
824*b1cdbd2cSJim Jagielski
isValid() const825*b1cdbd2cSJim Jagielski inline sal_Bool RegistryKey::isValid() const
826*b1cdbd2cSJim Jagielski { return (m_hImpl != NULL); }
827*b1cdbd2cSJim Jagielski
isReadOnly() const828*b1cdbd2cSJim Jagielski inline sal_Bool RegistryKey::isReadOnly() const
829*b1cdbd2cSJim Jagielski {
830*b1cdbd2cSJim Jagielski if (m_registry.isValid())
831*b1cdbd2cSJim Jagielski return (m_registry.m_pApi)->isKeyReadOnly(m_hImpl);
832*b1cdbd2cSJim Jagielski else
833*b1cdbd2cSJim Jagielski return sal_False;
834*b1cdbd2cSJim Jagielski }
835*b1cdbd2cSJim Jagielski
getName()836*b1cdbd2cSJim Jagielski inline ::rtl::OUString RegistryKey::getName()
837*b1cdbd2cSJim Jagielski {
838*b1cdbd2cSJim Jagielski ::rtl::OUString sRet;
839*b1cdbd2cSJim Jagielski if (m_registry.isValid())
840*b1cdbd2cSJim Jagielski m_registry.m_pApi->getKeyName(m_hImpl, &sRet.pData);
841*b1cdbd2cSJim Jagielski return sRet;;
842*b1cdbd2cSJim Jagielski }
843*b1cdbd2cSJim Jagielski
createKey(const::rtl::OUString & keyName,RegistryKey & rNewKey)844*b1cdbd2cSJim Jagielski inline RegError RegistryKey::createKey(const ::rtl::OUString& keyName,
845*b1cdbd2cSJim Jagielski RegistryKey& rNewKey)
846*b1cdbd2cSJim Jagielski {
847*b1cdbd2cSJim Jagielski if (rNewKey.isValid()) rNewKey.closeKey();
848*b1cdbd2cSJim Jagielski if (m_registry.isValid())
849*b1cdbd2cSJim Jagielski {
850*b1cdbd2cSJim Jagielski RegError ret = m_registry.m_pApi->createKey(m_hImpl, keyName.pData, &rNewKey.m_hImpl);
851*b1cdbd2cSJim Jagielski if (!ret) rNewKey.setRegistry(m_registry);
852*b1cdbd2cSJim Jagielski return ret;
853*b1cdbd2cSJim Jagielski } else
854*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
855*b1cdbd2cSJim Jagielski }
856*b1cdbd2cSJim Jagielski
openKey(const::rtl::OUString & keyName,RegistryKey & rOpenKey)857*b1cdbd2cSJim Jagielski inline RegError RegistryKey::openKey(const ::rtl::OUString& keyName,
858*b1cdbd2cSJim Jagielski RegistryKey& rOpenKey)
859*b1cdbd2cSJim Jagielski {
860*b1cdbd2cSJim Jagielski if (rOpenKey.isValid()) rOpenKey.closeKey();
861*b1cdbd2cSJim Jagielski if (m_registry.isValid())
862*b1cdbd2cSJim Jagielski {
863*b1cdbd2cSJim Jagielski RegError ret = m_registry.m_pApi->openKey(m_hImpl, keyName.pData,
864*b1cdbd2cSJim Jagielski &rOpenKey.m_hImpl);
865*b1cdbd2cSJim Jagielski if (!ret) rOpenKey.setRegistry(m_registry);
866*b1cdbd2cSJim Jagielski return ret;
867*b1cdbd2cSJim Jagielski } else
868*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
869*b1cdbd2cSJim Jagielski }
870*b1cdbd2cSJim Jagielski
openSubKeys(const::rtl::OUString & keyName,RegistryKeyArray & rSubKeys)871*b1cdbd2cSJim Jagielski inline RegError RegistryKey::openSubKeys(const ::rtl::OUString& keyName,
872*b1cdbd2cSJim Jagielski RegistryKeyArray& rSubKeys)
873*b1cdbd2cSJim Jagielski {
874*b1cdbd2cSJim Jagielski if (m_registry.isValid())
875*b1cdbd2cSJim Jagielski {
876*b1cdbd2cSJim Jagielski RegError ret = REG_NO_ERROR;
877*b1cdbd2cSJim Jagielski RegKeyHandle* pSubKeys;
878*b1cdbd2cSJim Jagielski sal_uInt32 nSubKeys;
879*b1cdbd2cSJim Jagielski ret = m_registry.m_pApi->openSubKeys(m_hImpl, keyName.pData,
880*b1cdbd2cSJim Jagielski &pSubKeys, &nSubKeys);
881*b1cdbd2cSJim Jagielski if ( ret )
882*b1cdbd2cSJim Jagielski {
883*b1cdbd2cSJim Jagielski return ret;
884*b1cdbd2cSJim Jagielski } else
885*b1cdbd2cSJim Jagielski {
886*b1cdbd2cSJim Jagielski rSubKeys.setKeyHandles(m_registry, pSubKeys, nSubKeys);
887*b1cdbd2cSJim Jagielski return ret;
888*b1cdbd2cSJim Jagielski }
889*b1cdbd2cSJim Jagielski } else
890*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
891*b1cdbd2cSJim Jagielski }
892*b1cdbd2cSJim Jagielski
getKeyNames(const::rtl::OUString & keyName,RegistryKeyNames & rSubKeyNames)893*b1cdbd2cSJim Jagielski inline RegError RegistryKey::getKeyNames(const ::rtl::OUString& keyName,
894*b1cdbd2cSJim Jagielski RegistryKeyNames& rSubKeyNames)
895*b1cdbd2cSJim Jagielski {
896*b1cdbd2cSJim Jagielski if (m_registry.isValid())
897*b1cdbd2cSJim Jagielski {
898*b1cdbd2cSJim Jagielski RegError ret = REG_NO_ERROR;
899*b1cdbd2cSJim Jagielski rtl_uString** pSubKeyNames;
900*b1cdbd2cSJim Jagielski sal_uInt32 nSubKeys;
901*b1cdbd2cSJim Jagielski ret = m_registry.m_pApi->getKeyNames(m_hImpl, keyName.pData,
902*b1cdbd2cSJim Jagielski &pSubKeyNames, &nSubKeys);
903*b1cdbd2cSJim Jagielski if ( ret )
904*b1cdbd2cSJim Jagielski {
905*b1cdbd2cSJim Jagielski return ret;
906*b1cdbd2cSJim Jagielski } else
907*b1cdbd2cSJim Jagielski {
908*b1cdbd2cSJim Jagielski rSubKeyNames.setKeyNames(m_registry, pSubKeyNames, nSubKeys);
909*b1cdbd2cSJim Jagielski return ret;
910*b1cdbd2cSJim Jagielski }
911*b1cdbd2cSJim Jagielski } else
912*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
913*b1cdbd2cSJim Jagielski }
914*b1cdbd2cSJim Jagielski
closeSubKeys(RegistryKeyArray & rSubKeys)915*b1cdbd2cSJim Jagielski inline RegError RegistryKey::closeSubKeys(RegistryKeyArray& rSubKeys)
916*b1cdbd2cSJim Jagielski {
917*b1cdbd2cSJim Jagielski if (m_registry.isValid())
918*b1cdbd2cSJim Jagielski return rSubKeys.closeKeyHandles();
919*b1cdbd2cSJim Jagielski else
920*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
921*b1cdbd2cSJim Jagielski }
922*b1cdbd2cSJim Jagielski
deleteKey(const::rtl::OUString & keyName)923*b1cdbd2cSJim Jagielski inline RegError RegistryKey::deleteKey(const ::rtl::OUString& keyName)
924*b1cdbd2cSJim Jagielski {
925*b1cdbd2cSJim Jagielski if (m_registry.isValid())
926*b1cdbd2cSJim Jagielski return m_registry.m_pApi->deleteKey(m_hImpl, keyName.pData);
927*b1cdbd2cSJim Jagielski else
928*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
929*b1cdbd2cSJim Jagielski }
930*b1cdbd2cSJim Jagielski
closeKey()931*b1cdbd2cSJim Jagielski inline RegError RegistryKey::closeKey()
932*b1cdbd2cSJim Jagielski {
933*b1cdbd2cSJim Jagielski if (m_registry.isValid())
934*b1cdbd2cSJim Jagielski {
935*b1cdbd2cSJim Jagielski RegError ret = m_registry.m_pApi->closeKey(m_hImpl);
936*b1cdbd2cSJim Jagielski if (!ret)
937*b1cdbd2cSJim Jagielski {
938*b1cdbd2cSJim Jagielski m_hImpl = NULL;
939*b1cdbd2cSJim Jagielski m_registry = Registry();
940*b1cdbd2cSJim Jagielski }
941*b1cdbd2cSJim Jagielski return ret;
942*b1cdbd2cSJim Jagielski } else
943*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
944*b1cdbd2cSJim Jagielski }
945*b1cdbd2cSJim Jagielski
releaseKey()946*b1cdbd2cSJim Jagielski inline void RegistryKey::releaseKey()
947*b1cdbd2cSJim Jagielski {
948*b1cdbd2cSJim Jagielski if (m_registry.isValid() && (m_hImpl != 0))
949*b1cdbd2cSJim Jagielski {
950*b1cdbd2cSJim Jagielski m_registry.m_pApi->releaseKey(m_hImpl), m_hImpl = 0;
951*b1cdbd2cSJim Jagielski }
952*b1cdbd2cSJim Jagielski }
953*b1cdbd2cSJim Jagielski
setValue(const::rtl::OUString & keyName,RegValueType valueType,RegValue pValue,sal_uInt32 valueSize)954*b1cdbd2cSJim Jagielski inline RegError RegistryKey::setValue(const ::rtl::OUString& keyName,
955*b1cdbd2cSJim Jagielski RegValueType valueType,
956*b1cdbd2cSJim Jagielski RegValue pValue,
957*b1cdbd2cSJim Jagielski sal_uInt32 valueSize)
958*b1cdbd2cSJim Jagielski {
959*b1cdbd2cSJim Jagielski if (m_registry.isValid())
960*b1cdbd2cSJim Jagielski return m_registry.m_pApi->setValue(m_hImpl, keyName.pData, valueType,
961*b1cdbd2cSJim Jagielski pValue, valueSize);
962*b1cdbd2cSJim Jagielski else
963*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
964*b1cdbd2cSJim Jagielski }
965*b1cdbd2cSJim Jagielski
setLongListValue(const::rtl::OUString & keyName,sal_Int32 * pValueList,sal_uInt32 len)966*b1cdbd2cSJim Jagielski inline RegError RegistryKey::setLongListValue(const ::rtl::OUString& keyName,
967*b1cdbd2cSJim Jagielski sal_Int32* pValueList,
968*b1cdbd2cSJim Jagielski sal_uInt32 len)
969*b1cdbd2cSJim Jagielski {
970*b1cdbd2cSJim Jagielski if (m_registry.isValid())
971*b1cdbd2cSJim Jagielski return m_registry.m_pApi->setLongListValue(m_hImpl, keyName.pData,
972*b1cdbd2cSJim Jagielski pValueList, len);
973*b1cdbd2cSJim Jagielski else
974*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
975*b1cdbd2cSJim Jagielski }
976*b1cdbd2cSJim Jagielski
setStringListValue(const::rtl::OUString & keyName,sal_Char ** pValueList,sal_uInt32 len)977*b1cdbd2cSJim Jagielski inline RegError RegistryKey::setStringListValue(const ::rtl::OUString& keyName,
978*b1cdbd2cSJim Jagielski sal_Char** pValueList,
979*b1cdbd2cSJim Jagielski sal_uInt32 len)
980*b1cdbd2cSJim Jagielski {
981*b1cdbd2cSJim Jagielski if (m_registry.isValid())
982*b1cdbd2cSJim Jagielski return m_registry.m_pApi->setStringListValue(m_hImpl, keyName.pData,
983*b1cdbd2cSJim Jagielski pValueList, len);
984*b1cdbd2cSJim Jagielski else
985*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
986*b1cdbd2cSJim Jagielski }
987*b1cdbd2cSJim Jagielski
setUnicodeListValue(const::rtl::OUString & keyName,sal_Unicode ** pValueList,sal_uInt32 len)988*b1cdbd2cSJim Jagielski inline RegError RegistryKey::setUnicodeListValue(const ::rtl::OUString& keyName,
989*b1cdbd2cSJim Jagielski sal_Unicode** pValueList,
990*b1cdbd2cSJim Jagielski sal_uInt32 len)
991*b1cdbd2cSJim Jagielski {
992*b1cdbd2cSJim Jagielski if (m_registry.isValid())
993*b1cdbd2cSJim Jagielski return m_registry.m_pApi->setUnicodeListValue(m_hImpl, keyName.pData,
994*b1cdbd2cSJim Jagielski pValueList, len);
995*b1cdbd2cSJim Jagielski else
996*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
997*b1cdbd2cSJim Jagielski }
998*b1cdbd2cSJim Jagielski
getValueInfo(const::rtl::OUString & keyName,RegValueType * pValueType,sal_uInt32 * pValueSize)999*b1cdbd2cSJim Jagielski inline RegError RegistryKey::getValueInfo(const ::rtl::OUString& keyName,
1000*b1cdbd2cSJim Jagielski RegValueType* pValueType,
1001*b1cdbd2cSJim Jagielski sal_uInt32* pValueSize)
1002*b1cdbd2cSJim Jagielski {
1003*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1004*b1cdbd2cSJim Jagielski return m_registry.m_pApi->getValueInfo(m_hImpl, keyName.pData, pValueType, pValueSize);
1005*b1cdbd2cSJim Jagielski else
1006*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1007*b1cdbd2cSJim Jagielski }
1008*b1cdbd2cSJim Jagielski
getValue(const::rtl::OUString & keyName,RegValue pValue)1009*b1cdbd2cSJim Jagielski inline RegError RegistryKey::getValue(const ::rtl::OUString& keyName,
1010*b1cdbd2cSJim Jagielski RegValue pValue)
1011*b1cdbd2cSJim Jagielski {
1012*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1013*b1cdbd2cSJim Jagielski return m_registry.m_pApi->getValue(m_hImpl, keyName.pData, pValue);
1014*b1cdbd2cSJim Jagielski else
1015*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1016*b1cdbd2cSJim Jagielski }
1017*b1cdbd2cSJim Jagielski
getLongListValue(const::rtl::OUString & keyName,RegistryValueList<sal_Int32> & rValueList)1018*b1cdbd2cSJim Jagielski inline RegError RegistryKey::getLongListValue(const ::rtl::OUString& keyName,
1019*b1cdbd2cSJim Jagielski RegistryValueList<sal_Int32>& rValueList)
1020*b1cdbd2cSJim Jagielski {
1021*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1022*b1cdbd2cSJim Jagielski {
1023*b1cdbd2cSJim Jagielski RegError ret = REG_NO_ERROR;
1024*b1cdbd2cSJim Jagielski sal_Int32* pValueList;
1025*b1cdbd2cSJim Jagielski sal_uInt32 length;
1026*b1cdbd2cSJim Jagielski ret = m_registry.m_pApi->getLongListValue(m_hImpl, keyName.pData,
1027*b1cdbd2cSJim Jagielski &pValueList, &length);
1028*b1cdbd2cSJim Jagielski if ( ret )
1029*b1cdbd2cSJim Jagielski {
1030*b1cdbd2cSJim Jagielski return ret;
1031*b1cdbd2cSJim Jagielski } else
1032*b1cdbd2cSJim Jagielski {
1033*b1cdbd2cSJim Jagielski rValueList.setValueList(m_registry, RG_VALUETYPE_LONGLIST,
1034*b1cdbd2cSJim Jagielski pValueList, length);
1035*b1cdbd2cSJim Jagielski return ret;
1036*b1cdbd2cSJim Jagielski }
1037*b1cdbd2cSJim Jagielski } else
1038*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1039*b1cdbd2cSJim Jagielski }
1040*b1cdbd2cSJim Jagielski
getStringListValue(const::rtl::OUString & keyName,RegistryValueList<sal_Char * > & rValueList)1041*b1cdbd2cSJim Jagielski inline RegError RegistryKey::getStringListValue(const ::rtl::OUString& keyName,
1042*b1cdbd2cSJim Jagielski RegistryValueList<sal_Char*>& rValueList)
1043*b1cdbd2cSJim Jagielski {
1044*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1045*b1cdbd2cSJim Jagielski {
1046*b1cdbd2cSJim Jagielski RegError ret = REG_NO_ERROR;
1047*b1cdbd2cSJim Jagielski sal_Char** pValueList;
1048*b1cdbd2cSJim Jagielski sal_uInt32 length;
1049*b1cdbd2cSJim Jagielski ret = m_registry.m_pApi->getStringListValue(m_hImpl, keyName.pData,
1050*b1cdbd2cSJim Jagielski &pValueList, &length);
1051*b1cdbd2cSJim Jagielski if ( ret )
1052*b1cdbd2cSJim Jagielski {
1053*b1cdbd2cSJim Jagielski return ret;
1054*b1cdbd2cSJim Jagielski } else
1055*b1cdbd2cSJim Jagielski {
1056*b1cdbd2cSJim Jagielski rValueList.setValueList(m_registry, RG_VALUETYPE_STRINGLIST,
1057*b1cdbd2cSJim Jagielski pValueList, length);
1058*b1cdbd2cSJim Jagielski return ret;
1059*b1cdbd2cSJim Jagielski }
1060*b1cdbd2cSJim Jagielski } else
1061*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1062*b1cdbd2cSJim Jagielski }
1063*b1cdbd2cSJim Jagielski
getUnicodeListValue(const::rtl::OUString & keyName,RegistryValueList<sal_Unicode * > & rValueList)1064*b1cdbd2cSJim Jagielski inline RegError RegistryKey::getUnicodeListValue(const ::rtl::OUString& keyName,
1065*b1cdbd2cSJim Jagielski RegistryValueList<sal_Unicode*>& rValueList)
1066*b1cdbd2cSJim Jagielski {
1067*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1068*b1cdbd2cSJim Jagielski {
1069*b1cdbd2cSJim Jagielski RegError ret = REG_NO_ERROR;
1070*b1cdbd2cSJim Jagielski sal_Unicode** pValueList;
1071*b1cdbd2cSJim Jagielski sal_uInt32 length;
1072*b1cdbd2cSJim Jagielski ret = m_registry.m_pApi->getUnicodeListValue(m_hImpl, keyName.pData,
1073*b1cdbd2cSJim Jagielski &pValueList, &length);
1074*b1cdbd2cSJim Jagielski if ( ret )
1075*b1cdbd2cSJim Jagielski {
1076*b1cdbd2cSJim Jagielski return ret;
1077*b1cdbd2cSJim Jagielski } else
1078*b1cdbd2cSJim Jagielski {
1079*b1cdbd2cSJim Jagielski rValueList.setValueList(m_registry, RG_VALUETYPE_UNICODELIST,
1080*b1cdbd2cSJim Jagielski pValueList, length);
1081*b1cdbd2cSJim Jagielski return ret;
1082*b1cdbd2cSJim Jagielski }
1083*b1cdbd2cSJim Jagielski } else
1084*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1085*b1cdbd2cSJim Jagielski }
1086*b1cdbd2cSJim Jagielski
createLink(const::rtl::OUString & linkName,const::rtl::OUString & linkTarget)1087*b1cdbd2cSJim Jagielski inline RegError RegistryKey::createLink(const ::rtl::OUString& linkName,
1088*b1cdbd2cSJim Jagielski const ::rtl::OUString& linkTarget)
1089*b1cdbd2cSJim Jagielski {
1090*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1091*b1cdbd2cSJim Jagielski return m_registry.m_pApi->createLink(m_hImpl, linkName.pData, linkTarget.pData);
1092*b1cdbd2cSJim Jagielski else
1093*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1094*b1cdbd2cSJim Jagielski }
1095*b1cdbd2cSJim Jagielski
deleteLink(const::rtl::OUString & linkName)1096*b1cdbd2cSJim Jagielski inline RegError RegistryKey::deleteLink(const ::rtl::OUString& linkName)
1097*b1cdbd2cSJim Jagielski {
1098*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1099*b1cdbd2cSJim Jagielski return m_registry.m_pApi->deleteLink(m_hImpl, linkName.pData);
1100*b1cdbd2cSJim Jagielski else
1101*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1102*b1cdbd2cSJim Jagielski }
1103*b1cdbd2cSJim Jagielski
getKeyType(const::rtl::OUString & keyName,RegKeyType * pKeyType) const1104*b1cdbd2cSJim Jagielski inline RegError RegistryKey::getKeyType(const ::rtl::OUString& keyName,
1105*b1cdbd2cSJim Jagielski RegKeyType* pKeyType) const
1106*b1cdbd2cSJim Jagielski {
1107*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1108*b1cdbd2cSJim Jagielski return m_registry.m_pApi->getKeyType(m_hImpl, keyName.pData, pKeyType);
1109*b1cdbd2cSJim Jagielski else
1110*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1111*b1cdbd2cSJim Jagielski }
1112*b1cdbd2cSJim Jagielski
getLinkTarget(const::rtl::OUString & linkName,::rtl::OUString & rLinkTarget) const1113*b1cdbd2cSJim Jagielski inline RegError RegistryKey::getLinkTarget(const ::rtl::OUString& linkName,
1114*b1cdbd2cSJim Jagielski ::rtl::OUString& rLinkTarget) const
1115*b1cdbd2cSJim Jagielski {
1116*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1117*b1cdbd2cSJim Jagielski {
1118*b1cdbd2cSJim Jagielski return m_registry.m_pApi->getLinkTarget(m_hImpl,
1119*b1cdbd2cSJim Jagielski linkName.pData,
1120*b1cdbd2cSJim Jagielski &rLinkTarget.pData);
1121*b1cdbd2cSJim Jagielski } else
1122*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1123*b1cdbd2cSJim Jagielski }
1124*b1cdbd2cSJim Jagielski
1125*b1cdbd2cSJim Jagielski
getResolvedKeyName(const::rtl::OUString & keyName,sal_Bool firstLinkOnly,::rtl::OUString & rResolvedName) const1126*b1cdbd2cSJim Jagielski inline RegError RegistryKey::getResolvedKeyName(const ::rtl::OUString& keyName,
1127*b1cdbd2cSJim Jagielski sal_Bool firstLinkOnly,
1128*b1cdbd2cSJim Jagielski ::rtl::OUString& rResolvedName) const
1129*b1cdbd2cSJim Jagielski {
1130*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1131*b1cdbd2cSJim Jagielski return m_registry.m_pApi->getResolvedKeyName(m_hImpl,
1132*b1cdbd2cSJim Jagielski keyName.pData,
1133*b1cdbd2cSJim Jagielski firstLinkOnly,
1134*b1cdbd2cSJim Jagielski &rResolvedName.pData);
1135*b1cdbd2cSJim Jagielski else
1136*b1cdbd2cSJim Jagielski return REG_INVALID_KEY;
1137*b1cdbd2cSJim Jagielski }
1138*b1cdbd2cSJim Jagielski
getRegistryName()1139*b1cdbd2cSJim Jagielski inline ::rtl::OUString RegistryKey::getRegistryName()
1140*b1cdbd2cSJim Jagielski {
1141*b1cdbd2cSJim Jagielski if (m_registry.isValid())
1142*b1cdbd2cSJim Jagielski {
1143*b1cdbd2cSJim Jagielski return m_registry.getName();
1144*b1cdbd2cSJim Jagielski } else
1145*b1cdbd2cSJim Jagielski return ::rtl::OUString();
1146*b1cdbd2cSJim Jagielski }
1147*b1cdbd2cSJim Jagielski
1148*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------------
1149*b1cdbd2cSJim Jagielski
Registry()1150*b1cdbd2cSJim Jagielski inline Registry::Registry()
1151*b1cdbd2cSJim Jagielski : m_pApi(initRegistry_Api())
1152*b1cdbd2cSJim Jagielski , m_hImpl(NULL)
1153*b1cdbd2cSJim Jagielski { }
1154*b1cdbd2cSJim Jagielski
Registry(const Registry & toCopy)1155*b1cdbd2cSJim Jagielski inline Registry::Registry(const Registry& toCopy)
1156*b1cdbd2cSJim Jagielski : m_pApi(toCopy.m_pApi)
1157*b1cdbd2cSJim Jagielski , m_hImpl(toCopy.m_hImpl)
1158*b1cdbd2cSJim Jagielski {
1159*b1cdbd2cSJim Jagielski if (m_hImpl)
1160*b1cdbd2cSJim Jagielski m_pApi->acquire(m_hImpl);
1161*b1cdbd2cSJim Jagielski }
1162*b1cdbd2cSJim Jagielski
1163*b1cdbd2cSJim Jagielski
~Registry()1164*b1cdbd2cSJim Jagielski inline Registry::~Registry()
1165*b1cdbd2cSJim Jagielski {
1166*b1cdbd2cSJim Jagielski if (m_hImpl)
1167*b1cdbd2cSJim Jagielski m_pApi->release(m_hImpl);
1168*b1cdbd2cSJim Jagielski }
1169*b1cdbd2cSJim Jagielski
operator =(const Registry & toAssign)1170*b1cdbd2cSJim Jagielski inline Registry& Registry::operator = (const Registry& toAssign)
1171*b1cdbd2cSJim Jagielski {
1172*b1cdbd2cSJim Jagielski if (toAssign.m_hImpl)
1173*b1cdbd2cSJim Jagielski toAssign.m_pApi->acquire(toAssign.m_hImpl);
1174*b1cdbd2cSJim Jagielski if (m_hImpl)
1175*b1cdbd2cSJim Jagielski m_pApi->release(m_hImpl);
1176*b1cdbd2cSJim Jagielski
1177*b1cdbd2cSJim Jagielski m_pApi = toAssign.m_pApi;
1178*b1cdbd2cSJim Jagielski m_hImpl = toAssign.m_hImpl;
1179*b1cdbd2cSJim Jagielski
1180*b1cdbd2cSJim Jagielski return *this;
1181*b1cdbd2cSJim Jagielski }
1182*b1cdbd2cSJim Jagielski
isValid() const1183*b1cdbd2cSJim Jagielski inline sal_Bool Registry::isValid() const
1184*b1cdbd2cSJim Jagielski { return ( m_hImpl != NULL ); }
1185*b1cdbd2cSJim Jagielski
isReadOnly() const1186*b1cdbd2cSJim Jagielski inline sal_Bool Registry::isReadOnly() const
1187*b1cdbd2cSJim Jagielski { return m_pApi->isReadOnly(m_hImpl); }
1188*b1cdbd2cSJim Jagielski
openRootKey(RegistryKey & rRootKey)1189*b1cdbd2cSJim Jagielski inline RegError Registry::openRootKey(RegistryKey& rRootKey)
1190*b1cdbd2cSJim Jagielski {
1191*b1cdbd2cSJim Jagielski rRootKey.setRegistry(*this);
1192*b1cdbd2cSJim Jagielski return m_pApi->openRootKey(m_hImpl, &rRootKey.m_hImpl);
1193*b1cdbd2cSJim Jagielski }
1194*b1cdbd2cSJim Jagielski
getName()1195*b1cdbd2cSJim Jagielski inline ::rtl::OUString Registry::getName()
1196*b1cdbd2cSJim Jagielski {
1197*b1cdbd2cSJim Jagielski ::rtl::OUString sRet;
1198*b1cdbd2cSJim Jagielski m_pApi->getName(m_hImpl, &sRet.pData);
1199*b1cdbd2cSJim Jagielski return sRet;
1200*b1cdbd2cSJim Jagielski }
1201*b1cdbd2cSJim Jagielski
create(const::rtl::OUString & registryName)1202*b1cdbd2cSJim Jagielski inline RegError Registry::create(const ::rtl::OUString& registryName)
1203*b1cdbd2cSJim Jagielski {
1204*b1cdbd2cSJim Jagielski if (m_hImpl)
1205*b1cdbd2cSJim Jagielski m_pApi->release(m_hImpl);
1206*b1cdbd2cSJim Jagielski return m_pApi->createRegistry(registryName.pData, &m_hImpl);
1207*b1cdbd2cSJim Jagielski }
1208*b1cdbd2cSJim Jagielski
open(const::rtl::OUString & registryName,RegAccessMode accessMode)1209*b1cdbd2cSJim Jagielski inline RegError Registry::open(const ::rtl::OUString& registryName,
1210*b1cdbd2cSJim Jagielski RegAccessMode accessMode)
1211*b1cdbd2cSJim Jagielski {
1212*b1cdbd2cSJim Jagielski if (m_hImpl)
1213*b1cdbd2cSJim Jagielski m_pApi->release(m_hImpl);
1214*b1cdbd2cSJim Jagielski return m_pApi->openRegistry(registryName.pData, &m_hImpl, accessMode);
1215*b1cdbd2cSJim Jagielski }
1216*b1cdbd2cSJim Jagielski
close()1217*b1cdbd2cSJim Jagielski inline RegError Registry::close()
1218*b1cdbd2cSJim Jagielski {
1219*b1cdbd2cSJim Jagielski RegError ret = m_pApi->closeRegistry(m_hImpl);
1220*b1cdbd2cSJim Jagielski if (!ret)
1221*b1cdbd2cSJim Jagielski m_hImpl = NULL;
1222*b1cdbd2cSJim Jagielski return ret;
1223*b1cdbd2cSJim Jagielski }
1224*b1cdbd2cSJim Jagielski
destroy(const::rtl::OUString & registryName)1225*b1cdbd2cSJim Jagielski inline RegError Registry::destroy(const ::rtl::OUString& registryName)
1226*b1cdbd2cSJim Jagielski {
1227*b1cdbd2cSJim Jagielski RegError ret = m_pApi->destroyRegistry(m_hImpl, registryName.pData);
1228*b1cdbd2cSJim Jagielski if ( !ret && (registryName.getLength() == 0) )
1229*b1cdbd2cSJim Jagielski m_hImpl = NULL;
1230*b1cdbd2cSJim Jagielski return ret;
1231*b1cdbd2cSJim Jagielski }
1232*b1cdbd2cSJim Jagielski
loadKey(RegistryKey & rKey,const::rtl::OUString & keyName,const::rtl::OUString & regFileName)1233*b1cdbd2cSJim Jagielski inline RegError Registry::loadKey(RegistryKey& rKey,
1234*b1cdbd2cSJim Jagielski const ::rtl::OUString& keyName,
1235*b1cdbd2cSJim Jagielski const ::rtl::OUString& regFileName)
1236*b1cdbd2cSJim Jagielski { return m_pApi->loadKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); }
1237*b1cdbd2cSJim Jagielski
saveKey(RegistryKey & rKey,const::rtl::OUString & keyName,const::rtl::OUString & regFileName)1238*b1cdbd2cSJim Jagielski inline RegError Registry::saveKey(RegistryKey& rKey,
1239*b1cdbd2cSJim Jagielski const ::rtl::OUString& keyName,
1240*b1cdbd2cSJim Jagielski const ::rtl::OUString& regFileName)
1241*b1cdbd2cSJim Jagielski { return m_pApi->saveKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); }
1242*b1cdbd2cSJim Jagielski
mergeKey(RegistryKey & rKey,const::rtl::OUString & keyName,const::rtl::OUString & regFileName,sal_Bool bWarnings,sal_Bool bReport)1243*b1cdbd2cSJim Jagielski inline RegError Registry::mergeKey(RegistryKey& rKey,
1244*b1cdbd2cSJim Jagielski const ::rtl::OUString& keyName,
1245*b1cdbd2cSJim Jagielski const ::rtl::OUString& regFileName,
1246*b1cdbd2cSJim Jagielski sal_Bool bWarnings,
1247*b1cdbd2cSJim Jagielski sal_Bool bReport)
1248*b1cdbd2cSJim Jagielski { return m_pApi->mergeKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData, bWarnings, bReport); }
1249*b1cdbd2cSJim Jagielski
dumpRegistry(RegistryKey & rKey)1250*b1cdbd2cSJim Jagielski inline RegError Registry::dumpRegistry(RegistryKey& rKey)
1251*b1cdbd2cSJim Jagielski { return m_pApi->dumpRegistry(m_hImpl, rKey.m_hImpl); }
1252*b1cdbd2cSJim Jagielski
1253*b1cdbd2cSJim Jagielski
1254*b1cdbd2cSJim Jagielski #endif
1255