a6b0d66a889dffd27749666b6edefb7c34fa0ae9
[vlc.git] / modules / gui / qt4 / util / registry.cpp
1 /*****************************************************************************
2  * registry.cpp: Windows Registry Manipulation
3  ****************************************************************************
4  * Copyright (C) 2008 the VideoLAN team
5  * $Id: input_slider.cpp 24525 2008-01-23 21:50:58Z courmisch $
6  *
7  * Authors: Andre Weber <WeberAndre # gmx - de>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #ifdef WIN32
29
30 #include "registry.hpp"
31
32 QVLCRegistry::QVLCRegistry( HKEY rootKey )
33 {
34     m_RootKey = rootKey;
35 }
36
37 QVLCRegistry::~QVLCRegistry( void )
38 {
39 }
40
41 bool QVLCRegistry::RegistryKeyExists( char *path )
42 {
43     HKEY keyHandle;
44     if(  RegOpenKeyEx( m_RootKey, path, 0, KEY_READ, &keyHandle ) == ERROR_SUCCESS )
45     {
46         RegCloseKey( keyHandle );
47         return true;
48     }
49     return false;
50 }
51
52 bool QVLCRegistry::RegistryValueExists( char *path, char *valueName )
53 {
54     HKEY keyHandle;
55     bool temp = false;
56     DWORD size1;
57     DWORD valueType;
58
59     if(  RegOpenKeyEx( m_RootKey, path, 0, KEY_READ, &keyHandle ) == ERROR_SUCCESS )
60     {
61         if( RegQueryValueEx( keyHandle, valueName, NULL,
62                              &valueType, NULL, &size1 ) == ERROR_SUCCESS )
63         {
64            temp = true;
65         }
66         RegCloseKey( keyHandle );
67     }
68     return temp;
69 }
70
71 void QVLCRegistry::WriteRegistryInt( char *path, char *valueName, int value )
72 {
73     HKEY keyHandle;
74
75     if(  RegCreateKeyEx( m_RootKey, path, 0, NULL, REG_OPTION_NON_VOLATILE,
76                          KEY_WRITE, NULL, &keyHandle, NULL )  == ERROR_SUCCESS )
77     {
78         RegSetValueEx( keyHandle, valueName, 0, REG_DWORD,
79                 (LPBYTE)&value, sizeof( int ) );
80         RegCloseKey( keyHandle );
81     }
82 }
83
84 void QVLCRegistry::WriteRegistryString( char *path, char *valueName, char *value )
85 {
86     HKEY keyHandle;
87
88     if(  RegCreateKeyEx( m_RootKey, path, 0, NULL, REG_OPTION_NON_VOLATILE,
89                          KEY_WRITE, NULL, &keyHandle, NULL )  == ERROR_SUCCESS )
90     {
91         RegSetValueEx( keyHandle, valueName, 0, REG_SZ, (LPBYTE)value,
92                 (DWORD)( strlen( value ) + 1 ) );
93         RegCloseKey( keyHandle );
94     }
95 }
96
97 void QVLCRegistry::WriteRegistryDouble( char *path, char *valueName, double value )
98 {
99     HKEY keyHandle;
100     if( RegCreateKeyEx( m_RootKey, path, 0, NULL, REG_OPTION_NON_VOLATILE,
101                        KEY_WRITE, NULL, &keyHandle, NULL ) == ERROR_SUCCESS )
102     {
103         RegSetValueEx( keyHandle, valueName, 0, REG_BINARY, (LPBYTE)&value, sizeof( double ) );
104         RegCloseKey( keyHandle );
105     }
106 }
107
108 int QVLCRegistry::ReadRegistryInt( char *path, char *valueName, int default_value ) {
109     HKEY keyHandle;
110     int tempValue;
111     DWORD size1;
112     DWORD valueType;
113
114     if(  RegOpenKeyEx( m_RootKey, path, 0, KEY_READ, &keyHandle ) == ERROR_SUCCESS )
115     {
116         if( RegQueryValueEx(  keyHandle, valueName, NULL, &valueType, NULL, &size1 ) == ERROR_SUCCESS )
117         {
118            if( valueType == REG_DWORD )
119            {
120                if( RegQueryValueEx(  keyHandle, valueName, NULL, &valueType, (LPBYTE)&tempValue, &size1 ) == ERROR_SUCCESS )
121                {
122                   default_value = tempValue;
123                };
124            }
125         }
126         RegCloseKey( keyHandle );
127     }
128     return default_value;
129 }
130
131 char * QVLCRegistry::ReadRegistryString( char *path, char *valueName, char *default_value )
132 {
133     HKEY keyHandle;
134     char *tempValue = NULL;
135     DWORD size1;
136     DWORD valueType;
137
138     if( RegOpenKeyEx( m_RootKey, path, 0, KEY_READ, &keyHandle ) == ERROR_SUCCESS )
139     {
140         if( RegQueryValueEx(  keyHandle, valueName, NULL, &valueType, NULL, &size1 ) == ERROR_SUCCESS )
141         {
142            if( valueType == REG_SZ )
143            {
144                // free
145                tempValue = ( char * )malloc( size1+1 ); // +1 für NullByte`?
146                if( RegQueryValueEx(  keyHandle, valueName, NULL, &valueType, (LPBYTE)tempValue, &size1 ) == ERROR_SUCCESS )
147                {
148                   default_value = tempValue;
149                };
150            }
151         }
152         RegCloseKey( keyHandle );
153     }
154     if( tempValue == NULL )
155     {
156         // wenn tempValue nicht aus registry gelesen wurde dafür sorgen das ein neuer String mit der Kopie von DefaultValue
157         // geliefert wird - das macht das Handling des Rückgabewertes der Funktion einfacher - immer schön mit free freigeben!
158         default_value = strdup( default_value );
159     }
160
161     return default_value;
162 }
163
164 double QVLCRegistry::ReadRegistryDouble( char *path, char *valueName, double default_value )
165 {
166     HKEY keyHandle;
167     double tempValue;
168     DWORD size1;
169     DWORD valueType;
170
171     if( RegOpenKeyEx( m_RootKey, path, 0, KEY_READ, &keyHandle ) == ERROR_SUCCESS )
172     {
173         if( RegQueryValueEx( keyHandle, valueName, NULL, &valueType,
174                              NULL, &size1 ) == ERROR_SUCCESS )
175         {
176            if( ( valueType == REG_BINARY ) && ( size1 == sizeof( double ) ) )
177            {
178                if( RegQueryValueEx(  keyHandle, valueName, NULL, &valueType,
179                            (LPBYTE)&tempValue, &size1 ) == ERROR_SUCCESS )
180                {
181                   default_value = tempValue;
182                };
183            }
184         }
185         RegCloseKey( keyHandle );
186     }
187     return default_value;
188 }
189
190 #endif /* WIN32 */