← Back to branch summary

~cairo-dock-team/ubuntu/oneiric/cairo-dock/2.3.0-3

« back to all changes in this revision

Viewing changes to src/cairo-dock-keyfile-utilities.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2010-08-09 23:26:12 UTC
  • mto: This revision was merged to the branch mainline in revision 13.
  • Revision ID: james.westby@ubuntu.com-20100809232612-pocdxliaxjdetm37
Tags: upstream-2.2.0~0beta4
Import upstream version 2.2.0~0beta4

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-dock-keyfile-utilities.c
1
 
/**
2
 
* This file is a part of the Cairo-Dock project
3
 
*
4
 
* Copyright : (C) see the 'copyright' file.
5
 
* E-mail    : see the 'copyright' file.
6
 
*
7
 
* This program is free software; you can redistribute it and/or
8
 
* modify it under the terms of the GNU General Public License
9
 
* as published by the Free Software Foundation; either version 3
10
 
* of the License, or (at your option) any later version.
11
 
*
12
 
* This program is distributed in the hope that it will be useful,
13
 
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
* GNU General Public License for more details.
16
 
* You should have received a copy of the GNU General Public License
17
 
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
18
 
*/
19
 
 
20
 
#include <string.h>
21
 
#include <stdlib.h>
22
 
 
23
 
#include "cairo-dock-log.h"
24
 
#include "cairo-dock-keyfile-utilities.h"
25
 
 
26
 
 
27
 
GKeyFile *cairo_dock_open_key_file (const gchar *cConfFilePath)
28
 
{
29
 
        GKeyFile *pKeyFile = g_key_file_new ();
30
 
        GError *erreur = NULL;
31
 
        g_key_file_load_from_file (pKeyFile, cConfFilePath, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &erreur);
32
 
        if (erreur != NULL)
33
 
        {
34
 
                cd_warning (erreur->message);
35
 
                g_error_free (erreur);
36
 
                g_key_file_free (pKeyFile);
37
 
                return NULL;
38
 
        }
39
 
        return pKeyFile;
40
 
}
41
 
 
42
 
void cairo_dock_write_keys_to_file (GKeyFile *pKeyFile, const gchar *cConfFilePath)
43
 
{
44
 
        cd_debug ("%s (%s)", __func__, cConfFilePath);
45
 
        GError *erreur = NULL;
46
 
 
47
 
        gchar *cDirectory = g_path_get_dirname (cConfFilePath);
48
 
        if (! g_file_test (cDirectory, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_EXECUTABLE))
49
 
        {
50
 
                g_mkdir_with_parents (cDirectory, 7*8*8+7*8+5);
51
 
        }
52
 
        g_free (cDirectory);
53
 
 
54
 
 
55
 
        gsize length=0;
56
 
        gchar *cNewConfFileContent = g_key_file_to_data (pKeyFile, &length, &erreur);
57
 
        if (erreur != NULL)
58
 
        {
59
 
                cd_warning ("Error while fetching data : %s", erreur->message);
60
 
                g_error_free (erreur);
61
 
                return ;
62
 
        }
63
 
        g_return_if_fail (cNewConfFileContent != NULL && *cNewConfFileContent != '\0');
64
 
 
65
 
        g_file_set_contents (cConfFilePath, cNewConfFileContent, length, &erreur);
66
 
        if (erreur != NULL)
67
 
        {
68
 
                cd_warning ("Error while writing data to %s : %s", cConfFilePath, erreur->message);
69
 
                g_error_free (erreur);
70
 
                return ;
71
 
        }
72
 
        g_free (cNewConfFileContent);
73
 
}
74
 
 
75
 
 
76
 
void cairo_dock_flush_conf_file_full (GKeyFile *pKeyFile, const gchar *cConfFilePath, const gchar *cShareDataDirPath, gboolean bUseFileKeys, const gchar *cTemplateFileName)
77
 
{
78
 
        gchar *cTemplateConfFilePath = g_strdup_printf ("%s/%s", cShareDataDirPath, cTemplateFileName);
79
 
        cd_message ("%s (%s)", __func__, cTemplateConfFilePath);
80
 
        
81
 
        if (! g_file_test (cTemplateConfFilePath, G_FILE_TEST_EXISTS))
82
 
        {
83
 
                cd_warning ("Couldn't find any installed conf file in %s", cShareDataDirPath);
84
 
        }
85
 
        else
86
 
        {
87
 
                gchar *cCommand = g_strdup_printf ("/bin/cp \"%s\" \"%s\"", cTemplateConfFilePath, cConfFilePath);
88
 
                int r = system (cCommand);
89
 
                g_free (cCommand);
90
 
                
91
 
                cairo_dock_replace_values_in_conf_file (cConfFilePath, pKeyFile, bUseFileKeys, 0);
92
 
        }
93
 
        g_free (cTemplateConfFilePath);
94
 
}
95
 
 
96
 
 
97
 
 
98
 
void cairo_dock_replace_key_values (GKeyFile *pOriginalKeyFile, GKeyFile *pReplacementKeyFile, gboolean bUseOriginalKeys, gchar iIdentifier)
99
 
{
100
 
        //g_print ("%s (%d, %d)\n", __func__, iIdentifier, bUseOriginalKeys);
101
 
        GError *erreur = NULL;
102
 
        gsize length = 0;
103
 
        gchar **pKeyList;
104
 
        gchar **pGroupList = g_key_file_get_groups ((bUseOriginalKeys ? pOriginalKeyFile : pReplacementKeyFile), &length);
105
 
        g_return_if_fail (pGroupList != NULL);
106
 
        gchar *cGroupName, *cKeyName, *cKeyValue, *cComment;
107
 
        int i, j;
108
 
 
109
 
        i = 0;
110
 
        while (pGroupList[i] != NULL)
111
 
        {
112
 
                cGroupName = pGroupList[i];
113
 
 
114
 
                length = 0;
115
 
                pKeyList = g_key_file_get_keys ((bUseOriginalKeys ? pOriginalKeyFile : pReplacementKeyFile), cGroupName, NULL, NULL);
116
 
                g_return_if_fail (pKeyList != NULL);
117
 
                
118
 
                j = 0;
119
 
                while (pKeyList[j] != NULL)
120
 
                {
121
 
                        cKeyName = pKeyList[j];
122
 
                        //g_print ("%s\n  %s", cKeyName, g_key_file_get_comment (pOriginalKeyFile, cGroupName, cKeyName, NULL));
123
 
 
124
 
                        if (iIdentifier != 0)
125
 
                        {
126
 
                                cComment = g_key_file_get_comment (bUseOriginalKeys ? pOriginalKeyFile : pReplacementKeyFile, cGroupName, cKeyName, NULL);
127
 
                                //g_print ("%s\n  %s", cKeyName, cComment);
128
 
                                if (cComment == NULL || strlen (cComment) < 2 || cComment[1] != iIdentifier)
129
 
                                {
130
 
                                        //g_print ("  on saute %s;%s (%s)\n", cGroupName, cKeyName, cComment);
131
 
                                        g_free (cComment);
132
 
                                        j ++;
133
 
                                        continue ;
134
 
                                }
135
 
                                g_free (cComment);
136
 
                        }
137
 
 
138
 
                        cKeyValue =  g_key_file_get_string (pReplacementKeyFile, cGroupName, cKeyName, &erreur);
139
 
                        if (erreur != NULL)
140
 
                        {
141
 
                                cd_warning (erreur->message);
142
 
                                g_error_free (erreur);
143
 
                                erreur = NULL;
144
 
                        }
145
 
                        else
146
 
                        {
147
 
                                //g_print (" -> %s\n", cKeyValue);
148
 
                                if (cKeyValue[strlen(cKeyValue) - 1] == '\n')
149
 
                                        cKeyValue[strlen(cKeyValue) - 1] = '\0';
150
 
                                g_key_file_set_string (pOriginalKeyFile, cGroupName, cKeyName, (cKeyValue != NULL ? cKeyValue : ""));
151
 
                        }
152
 
                        g_free (cKeyValue);
153
 
                        j ++;
154
 
                }
155
 
 
156
 
                g_strfreev (pKeyList);
157
 
                i ++;
158
 
        }
159
 
        g_strfreev (pGroupList);
160
 
        
161
 
        if (bUseOriginalKeys)
162
 
        {
163
 
                pGroupList = g_key_file_get_groups (pReplacementKeyFile, &length);
164
 
                i = 0;
165
 
                while (pGroupList[i] != NULL)
166
 
                {
167
 
                        cGroupName = pGroupList[i];
168
 
 
169
 
                        length = 0;
170
 
                        pKeyList = g_key_file_get_keys (pReplacementKeyFile, cGroupName, NULL, NULL);
171
 
 
172
 
                        j = 0;
173
 
                        while (pKeyList[j] != NULL)
174
 
                        {
175
 
                                cKeyName = pKeyList[j];
176
 
                                //g_print ("%s\n  %s", cKeyName, g_key_file_get_comment (pOriginalKeyFile, cGroupName, cKeyName, NULL));
177
 
 
178
 
                                cComment = g_key_file_get_comment (pReplacementKeyFile, cGroupName, cKeyName, NULL);
179
 
                                if (cComment == NULL || strlen (cComment) < 3 || (cComment[1] != '0' && cComment[2] != '0'))
180
 
                                {
181
 
                                        g_free (cComment);
182
 
                                        j ++;
183
 
                                        continue ;
184
 
                                }
185
 
                                if (iIdentifier != 0)
186
 
                                {
187
 
                                        if (cComment == NULL || strlen (cComment) < 2 || cComment[1] != iIdentifier)
188
 
                                        {
189
 
                                                //g_print ("  on saute %s;%s (%s)\n", cGroupName, cKeyName, cComment);
190
 
                                                g_free (cComment);
191
 
                                                j ++;
192
 
                                                continue ;
193
 
                                        }
194
 
                                }
195
 
 
196
 
                                cKeyValue =  g_key_file_get_string (pReplacementKeyFile, cGroupName, cKeyName, &erreur);
197
 
                                if (erreur != NULL)
198
 
                                {
199
 
                                        cd_warning (erreur->message);
200
 
                                        g_error_free (erreur);
201
 
                                        erreur = NULL;
202
 
                                }
203
 
                                else
204
 
                                {
205
 
                                        //g_print (" -> %s\n", cKeyValue);
206
 
                                        if (cKeyValue[strlen(cKeyValue) - 1] == '\n')
207
 
                                                cKeyValue[strlen(cKeyValue) - 1] = '\0';
208
 
                                        g_key_file_set_string (pOriginalKeyFile, cGroupName, cKeyName, (cKeyValue != NULL ? cKeyValue : ""));
209
 
                                        if (cComment != NULL)
210
 
                                        {
211
 
                                                g_key_file_set_comment (pOriginalKeyFile, cGroupName, cKeyName, cComment, &erreur);
212
 
                                                if (erreur != NULL)
213
 
                                                {
214
 
                                                        cd_warning (erreur->message);
215
 
                                                        g_error_free (erreur);
216
 
                                                        erreur = NULL;
217
 
                                                }
218
 
                                        }
219
 
                                }
220
 
                                g_free (cKeyValue);
221
 
                                g_free (cComment);
222
 
                                j ++;
223
 
                        }
224
 
 
225
 
                        g_strfreev (pKeyList);
226
 
                        i ++;
227
 
                }
228
 
                g_strfreev (pGroupList);
229
 
        }
230
 
}
231
 
 
232
 
 
233
 
void cairo_dock_replace_values_in_conf_file (const gchar *cConfFilePath, GKeyFile *pValidKeyFile, gboolean bUseFileKeys, gchar iIdentifier)
234
 
{
235
 
        GKeyFile *pConfKeyFile = cairo_dock_open_key_file (cConfFilePath);
236
 
        if (pConfKeyFile == NULL)
237
 
                return ;
238
 
 
239
 
        g_print ("%s (%s)\n", __func__,cConfFilePath );
240
 
        cairo_dock_replace_key_values (pConfKeyFile, pValidKeyFile, bUseFileKeys, iIdentifier);
241
 
 
242
 
        cairo_dock_write_keys_to_file (pConfKeyFile, cConfFilePath);
243
 
 
244
 
        g_key_file_free (pConfKeyFile);
245
 
}
246
 
 
247
 
void cairo_dock_replace_keys_by_identifier (const gchar *cConfFilePath, gchar *cReplacementConfFilePath, gchar iIdentifier)
248
 
{
249
 
        GKeyFile *pReplacementKeyFile = cairo_dock_open_key_file (cReplacementConfFilePath);
250
 
        if (pReplacementKeyFile == NULL)
251
 
                return ;
252
 
        
253
 
        g_print ("%s (%s <- %s, '%c')\n", __func__, cConfFilePath, cReplacementConfFilePath, iIdentifier);
254
 
        cairo_dock_replace_values_in_conf_file (cConfFilePath, pReplacementKeyFile, TRUE, iIdentifier);
255
 
 
256
 
        g_key_file_free (pReplacementKeyFile);
257
 
}
258
 
 
259
 
 
260
 
 
261
 
void cairo_dock_get_conf_file_version (GKeyFile *pKeyFile, gchar **cConfFileVersion)
262
 
{
263
 
        *cConfFileVersion = NULL;
264
 
        
265
 
        gchar *cFirstComment =  g_key_file_get_comment (pKeyFile, NULL, NULL, NULL);
266
 
        
267
 
        if (cFirstComment != NULL && *cFirstComment != '\0')
268
 
        {
269
 
                gchar *str = strchr (cFirstComment, '\n');
270
 
                if (str != NULL)
271
 
                        *str = '\0';
272
 
                
273
 
                str = strchr (cFirstComment, ';');  // le 1er est pour la langue (obsolete).
274
 
                if (str != NULL)
275
 
                {
276
 
                        *cConfFileVersion = g_strdup (str+1);
277
 
                }
278
 
                else
279
 
                {
280
 
                        *cConfFileVersion = g_strdup (cFirstComment + (*cFirstComment == '!'));  // le '!' est obsolete.
281
 
                }
282
 
        }
283
 
        g_free (cFirstComment);
284
 
}
285
 
 
286
 
gboolean cairo_dock_conf_file_needs_update (GKeyFile *pKeyFile, const gchar *cVersion)
287
 
{
288
 
        gchar *cPreviousVersion = NULL;
289
 
        cairo_dock_get_conf_file_version (pKeyFile, &cPreviousVersion);
290
 
        gboolean bNeedsUpdate;
291
 
        if (cPreviousVersion == NULL || strcmp (cPreviousVersion, cVersion) != 0)
292
 
                bNeedsUpdate = TRUE;
293
 
        else
294
 
                bNeedsUpdate = FALSE;
295
 
        
296
 
        g_free (cPreviousVersion);
297
 
        return bNeedsUpdate;
298
 
}
299
 
 
300
 
 
301
 
void cairo_dock_add_remove_element_to_key (const gchar *cConfFilePath, const gchar *cGroupName, const gchar *cKeyName, gchar *cElementName, gboolean bAdd)
302
 
{
303
 
        GKeyFile *pKeyFile = cairo_dock_open_key_file (cConfFilePath);
304
 
        if (pKeyFile == NULL)
305
 
                return ;
306
 
        
307
 
        gchar *cElementList = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL), *cNewElementList = NULL;
308
 
        if (cElementList != NULL && *cElementList == '\0')
309
 
        {
310
 
                g_free (cElementList);
311
 
                cElementList= NULL;
312
 
        }
313
 
        
314
 
        if (bAdd)
315
 
        {
316
 
                //g_print ("on rajoute %s\n", cElementName);
317
 
                if (cElementList != NULL)
318
 
                        cNewElementList = g_strdup_printf ("%s;%s", cElementList, cElementName);
319
 
                else
320
 
                        cNewElementList = g_strdup (cElementName);
321
 
        }
322
 
        else
323
 
        {
324
 
                //g_print ("on enleve %s\n", cElementName);
325
 
                gchar *str = g_strstr_len (cElementList, strlen (cElementList), cElementName);
326
 
                g_return_if_fail (str != NULL);
327
 
                if (str == cElementList)
328
 
                {
329
 
                        if (str[strlen (cElementName)] == '\0')
330
 
                                cNewElementList = g_strdup ("");
331
 
                        else
332
 
                                cNewElementList = g_strdup (str + strlen (cElementName) + 1);
333
 
                }
334
 
                else
335
 
                {
336
 
                        *(str-1) = '\0';
337
 
                        if (str[strlen (cElementName)] == '\0')
338
 
                                cNewElementList = g_strdup (cElementList);
339
 
                        else
340
 
                                cNewElementList = g_strdup_printf ("%s;%s", cElementList, str + strlen (cElementName) + 1);
341
 
                }
342
 
        }
343
 
        g_key_file_set_string (pKeyFile, cGroupName, cKeyName, cNewElementList);
344
 
        cairo_dock_write_keys_to_file (pKeyFile, cConfFilePath);
345
 
        g_free (cElementList);
346
 
        g_free (cNewElementList);
347
 
        g_key_file_free (pKeyFile);
348
 
}
349
 
 
350
 
 
351
 
void cairo_dock_add_widget_to_conf_file (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *ckeyName, const gchar *cInitialValue, gchar iWidgetType, const gchar *cDescription, const gchar *cTooltip)
352
 
{
353
 
        g_key_file_set_string (pKeyFile, cGroupName, ckeyName, cInitialValue);
354
 
        gchar *Comment = g_strdup_printf ("%c0 %s%s%s%s", iWidgetType, cDescription, cTooltip ? "\n{" : "", cTooltip ? cTooltip : "", cTooltip ? "}" : "");
355
 
        g_key_file_set_comment (pKeyFile, cGroupName, ckeyName, Comment, NULL);
356
 
        g_free (Comment);
357
 
}
358
 
 
359
 
 
360
 
gboolean cairo_dock_rename_group_in_conf_file (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cNewGroupName)
361
 
{
362
 
        if (g_key_file_has_group (pKeyFile, cNewGroupName))
363
 
                return FALSE;
364
 
        
365
 
        gchar **pKeyList = g_key_file_get_keys (pKeyFile, cGroupName, NULL, NULL);
366
 
        gchar *cValue;
367
 
        int i;
368
 
        for (i = 0; pKeyList[i] != NULL; i ++)
369
 
        {
370
 
                cValue = g_key_file_get_value (pKeyFile, cGroupName, pKeyList[i], NULL);
371
 
                g_key_file_set_value (pKeyFile, cNewGroupName, pKeyList[i], cValue);
372
 
                g_free (cValue);
373
 
        }
374
 
        g_strfreev (pKeyList);
375
 
        
376
 
        g_key_file_remove_group (pKeyFile, cGroupName, NULL);
377
 
        
378
 
        return TRUE;
379
 
}