← 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/gldit/cairo-dock-config.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/gldit/cairo-dock-config.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 <math.h>
 
21
#include <string.h>
 
22
 
 
23
#include <gtk/gtk.h>
 
24
 
 
25
#include <stdio.h>
 
26
#include <stdlib.h>
 
27
 
 
28
#include "../config.h"
 
29
#ifdef HAVE_LIBCRYPT
 
30
/* libC crypt */
 
31
#include <crypt.h>
 
32
 
 
33
static char DES_crypt_key[64] =
 
34
{
 
35
    1,0,0,1,1,1,0,0, 1,0,1,1,1,0,1,1, 1,1,0,1,0,1,0,1, 1,1,0,0,0,0,0,1,
 
36
    0,0,0,1,0,1,1,0, 1,1,1,0,1,1,1,0, 1,1,1,0,0,1,0,0, 1,0,1,0,1,0,1,1
 
37
}; 
 
38
#endif
 
39
 
 
40
#include "cairo-dock-draw.h"
 
41
#include "cairo-dock-draw-opengl.h"
 
42
#include "cairo-dock-load.h"
 
43
#include "cairo-dock-icons.h"
 
44
#include "cairo-dock-applications-manager.h"
 
45
#include "cairo-dock-modules.h"
 
46
#include "cairo-dock-keyfile-utilities.h"
 
47
#include "cairo-dock-dock-factory.h"
 
48
#include "cairo-dock-themes-manager.h"
 
49
#include "cairo-dock-backends-manager.h"
 
50
#include "cairo-dock-callbacks.h"
 
51
#include "cairo-dock-dialog-manager.h"
 
52
#include "cairo-dock-X-utilities.h"
 
53
#include "cairo-dock-log.h"
 
54
#include "cairo-dock-keybinder.h"
 
55
#include "cairo-dock-dock-manager.h"
 
56
#include "cairo-dock-surface-factory.h"
 
57
#include "cairo-dock-class-manager.h"
 
58
#include "cairo-dock-gui-manager.h"
 
59
#include "cairo-dock-desklet-manager.h"
 
60
#include "cairo-dock-internal-position.h"
 
61
#include "cairo-dock-internal-accessibility.h"
 
62
#include "cairo-dock-internal-system.h"
 
63
#include "cairo-dock-internal-taskbar.h"
 
64
#include "cairo-dock-internal-dialogs.h"
 
65
#include "cairo-dock-internal-indicators.h"
 
66
#include "cairo-dock-internal-views.h"
 
67
#include "cairo-dock-internal-labels.h"
 
68
#include "cairo-dock-internal-desklets.h"
 
69
#include "cairo-dock-internal-icons.h"
 
70
#include "cairo-dock-internal-background.h"
 
71
#include "cairo-dock-container.h"
 
72
#include "cairo-dock-dock-facility.h"
 
73
#include "cairo-dock-file-manager.h"
 
74
#include "cairo-dock-animations.h"
 
75
#include "cairo-dock-launcher-manager.h"
 
76
#include "cairo-dock-indicator-manager.h"
 
77
#include "cairo-dock-config.h"
 
78
 
 
79
CairoDockDesktopBackground *g_pFakeTransparencyDesktopBg = NULL;
 
80
gboolean g_bEasterEggs = FALSE;
 
81
 
 
82
extern gchar *g_cCurrentLaunchersPath;
 
83
extern gchar *g_cConfFile;
 
84
extern gboolean g_bUseOpenGL;
 
85
extern CairoDockDesktopEnv g_iDesktopEnv;
 
86
extern CairoDockHidingEffect *g_pHidingBackend;
 
87
 
 
88
static gboolean s_bLoading = FALSE;
 
89
 
 
90
 
 
91
gboolean cairo_dock_get_boolean_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, gboolean bDefaultValue, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName)
 
92
{
 
93
        GError *erreur = NULL;
 
94
        gboolean bValue = g_key_file_get_boolean (pKeyFile, cGroupName, cKeyName, &erreur);
 
95
        if (erreur != NULL)
 
96
        {
 
97
                if (bFlushConfFileNeeded != NULL)
 
98
                        cd_warning (erreur->message);
 
99
                g_error_free (erreur);
 
100
                erreur = NULL;
 
101
 
 
102
                gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
 
103
                bValue = g_key_file_get_boolean (pKeyFile, cGroupNameUpperCase, cKeyName, &erreur);
 
104
                g_free (cGroupNameUpperCase);
 
105
                if (erreur != NULL)
 
106
                {
 
107
                        g_error_free (erreur);
 
108
                        erreur = NULL;
 
109
                        bValue = g_key_file_get_boolean (pKeyFile, "Cairo Dock", cKeyName, &erreur);
 
110
                        if (erreur != NULL)
 
111
                        {
 
112
                                g_error_free (erreur);
 
113
                                erreur = NULL;
 
114
                                bValue = g_key_file_get_boolean (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &erreur);
 
115
                                if (erreur != NULL)
 
116
                                {
 
117
                                        g_error_free (erreur);
 
118
                                        bValue = bDefaultValue;
 
119
                                }
 
120
                                else
 
121
                                        cd_message (" (recuperee)");
 
122
                        }
 
123
                        else
 
124
                                cd_message (" (recuperee)");
 
125
                }
 
126
 
 
127
                g_key_file_set_boolean (pKeyFile, cGroupName, cKeyName, bValue);
 
128
                if (bFlushConfFileNeeded != NULL)
 
129
                        *bFlushConfFileNeeded = TRUE;
 
130
        }
 
131
        return bValue;
 
132
}
 
133
 
 
134
int cairo_dock_get_integer_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, int iDefaultValue, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName)
 
135
{
 
136
        GError *erreur = NULL;
 
137
        int iValue = g_key_file_get_integer (pKeyFile, cGroupName, cKeyName, &erreur);
 
138
        if (erreur != NULL)
 
139
        {
 
140
                if (bFlushConfFileNeeded != NULL)
 
141
                        cd_warning (erreur->message);
 
142
                g_error_free (erreur);
 
143
                erreur = NULL;
 
144
 
 
145
                gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
 
146
                iValue = g_key_file_get_integer (pKeyFile, cGroupNameUpperCase, cKeyName, &erreur);
 
147
                if (erreur != NULL)
 
148
                {
 
149
                        g_error_free (erreur);
 
150
                        erreur = NULL;
 
151
                        iValue = g_key_file_get_integer (pKeyFile, "Cairo Dock", cKeyName, &erreur);
 
152
                        if (erreur != NULL)
 
153
                        {
 
154
                                g_error_free (erreur);
 
155
                                erreur = NULL;
 
156
                                iValue = g_key_file_get_integer (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &erreur);
 
157
                                if (erreur != NULL)
 
158
                                {
 
159
                                        g_error_free (erreur);
 
160
                                        iValue = iDefaultValue;
 
161
                                }
 
162
                                else
 
163
                                        cd_message (" (recuperee)");
 
164
                        }
 
165
                        else
 
166
                                cd_message (" (recuperee)");
 
167
                }
 
168
                g_free (cGroupNameUpperCase);
 
169
 
 
170
                g_key_file_set_integer (pKeyFile, cGroupName, cKeyName, iValue);
 
171
                if (bFlushConfFileNeeded != NULL)
 
172
                        *bFlushConfFileNeeded = TRUE;
 
173
        }
 
174
        return iValue;
 
175
}
 
176
 
 
177
double cairo_dock_get_double_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, double fDefaultValue, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName)
 
178
{
 
179
        GError *erreur = NULL;
 
180
        double fValue = g_key_file_get_double (pKeyFile, cGroupName, cKeyName, &erreur);
 
181
        if (erreur != NULL)
 
182
        {
 
183
                if (bFlushConfFileNeeded != NULL)
 
184
                        cd_warning (erreur->message);
 
185
                g_error_free (erreur);
 
186
                erreur = NULL;
 
187
 
 
188
                gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
 
189
                fValue = g_key_file_get_double (pKeyFile, cGroupNameUpperCase, cKeyName, &erreur);
 
190
                if (erreur != NULL)
 
191
                {
 
192
                        g_error_free (erreur);
 
193
                        erreur = NULL;
 
194
                        fValue = g_key_file_get_double (pKeyFile, "Cairo Dock", cKeyName, &erreur);
 
195
                        if (erreur != NULL)
 
196
                        {
 
197
                                g_error_free (erreur);
 
198
                                erreur = NULL;
 
199
                                fValue = g_key_file_get_double (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &erreur);
 
200
                                if (erreur != NULL)
 
201
                                {
 
202
                                        g_error_free (erreur);
 
203
                                        fValue = fDefaultValue;
 
204
                                }
 
205
                                else
 
206
                                        cd_message (" (recuperee)");
 
207
                        }
 
208
                        else
 
209
                                cd_message (" (recuperee)");
 
210
                }
 
211
                g_free (cGroupNameUpperCase);
 
212
 
 
213
                g_key_file_set_double (pKeyFile, cGroupName, cKeyName, fValue);
 
214
                if (bFlushConfFileNeeded != NULL)
 
215
                        *bFlushConfFileNeeded = TRUE;
 
216
        }
 
217
        return fValue;
 
218
}
 
219
 
 
220
gchar *cairo_dock_get_string_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, const gchar *cDefaultValue, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName)
 
221
{
 
222
        GError *erreur = NULL;
 
223
        gchar *cValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, &erreur);
 
224
        if (erreur != NULL)
 
225
        {
 
226
                if (bFlushConfFileNeeded != NULL)
 
227
                        cd_warning (erreur->message);
 
228
                g_error_free (erreur);
 
229
                erreur = NULL;
 
230
 
 
231
                gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
 
232
                cValue = g_key_file_get_string (pKeyFile, cGroupNameUpperCase, cKeyName, &erreur);
 
233
                if (erreur != NULL)
 
234
                {
 
235
                        g_error_free (erreur);
 
236
                        erreur = NULL;
 
237
                        cValue = g_key_file_get_string (pKeyFile, "Cairo Dock", cKeyName, &erreur);
 
238
                        if (erreur != NULL)
 
239
                        {
 
240
                                g_error_free (erreur);
 
241
                                erreur = NULL;
 
242
                                cValue = g_key_file_get_string (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &erreur);
 
243
                                if (erreur != NULL)
 
244
                                {
 
245
                                        g_error_free (erreur);
 
246
                                        cValue = g_strdup (cDefaultValue);
 
247
                                }
 
248
                                else
 
249
                                        cd_message (" (recuperee)");
 
250
                        }
 
251
                        else
 
252
                                cd_message (" (recuperee)");
 
253
                }
 
254
                g_free (cGroupNameUpperCase);
 
255
 
 
256
                g_key_file_set_string (pKeyFile, cGroupName, cKeyName, (cValue != NULL ? cValue : ""));
 
257
                if (bFlushConfFileNeeded != NULL)
 
258
                        *bFlushConfFileNeeded = TRUE;
 
259
        }
 
260
        if (cValue != NULL && *cValue == '\0')
 
261
        {
 
262
                g_free (cValue);
 
263
                cValue = NULL;
 
264
        }
 
265
        return cValue;
 
266
}
 
267
 
 
268
void cairo_dock_get_integer_list_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, int *iValueBuffer, guint iNbElements, int *iDefaultValues, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName)
 
269
{
 
270
        GError *erreur = NULL;
 
271
        gsize length = 0;
 
272
        if (iDefaultValues != NULL)
 
273
                memcpy (iValueBuffer, iDefaultValues, iNbElements * sizeof (int));
 
274
 
 
275
        int *iValuesList = g_key_file_get_integer_list (pKeyFile, cGroupName, cKeyName, &length, &erreur);
 
276
        if (erreur != NULL)
 
277
        {
 
278
                if (bFlushConfFileNeeded != NULL)
 
279
                        cd_warning (erreur->message);
 
280
                g_error_free (erreur);
 
281
                erreur = NULL;
 
282
 
 
283
                gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
 
284
                iValuesList = g_key_file_get_integer_list (pKeyFile, cGroupNameUpperCase, cKeyName, &length, &erreur);
 
285
                if (erreur != NULL)
 
286
                {
 
287
                        g_error_free (erreur);
 
288
                        erreur = NULL;
 
289
                        iValuesList = g_key_file_get_integer_list (pKeyFile, "Cairo Dock", cKeyName, &length, &erreur);
 
290
                        if (erreur != NULL)
 
291
                        {
 
292
                                g_error_free (erreur);
 
293
                                erreur = NULL;
 
294
                                iValuesList = g_key_file_get_integer_list (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &length, &erreur);
 
295
                                if (erreur != NULL)
 
296
                                {
 
297
                                        g_error_free (erreur);
 
298
                                }
 
299
                                else
 
300
                                {
 
301
                                        cd_message (" (recuperee)");
 
302
                                        if (length > 0)
 
303
                                                memcpy (iValueBuffer, iValuesList, MIN (iNbElements, length) * sizeof (int));
 
304
                                }
 
305
                        }
 
306
                        else
 
307
                        {
 
308
                                cd_message (" (recuperee)");
 
309
                                if (length > 0)
 
310
                                        memcpy (iValueBuffer, iValuesList, MIN (iNbElements, length) * sizeof (int));
 
311
                        }
 
312
                }
 
313
                else
 
314
                {
 
315
                        if (length > 0)
 
316
                                memcpy (iValueBuffer, iValuesList, MIN (iNbElements, length) * sizeof (int));
 
317
                }
 
318
                g_free (cGroupNameUpperCase);
 
319
                
 
320
                if (iDefaultValues != NULL)  // on ne modifie les valeurs actuelles que si on a explicitement passe des valeurs par defaut en entree; sinon on considere que l'on va traiter le cas en aval.
 
321
                        g_key_file_set_integer_list (pKeyFile, cGroupName, cKeyName, iValueBuffer, iNbElements);
 
322
                if (bFlushConfFileNeeded != NULL)
 
323
                        *bFlushConfFileNeeded = TRUE;
 
324
        }
 
325
        else
 
326
        {
 
327
                if (length > 0)
 
328
                        memcpy (iValueBuffer, iValuesList, MIN (iNbElements, length) * sizeof (int));
 
329
        }
 
330
        g_free (iValuesList);
 
331
}
 
332
 
 
333
void cairo_dock_get_double_list_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, double *fValueBuffer, guint iNbElements, double *fDefaultValues, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName)
 
334
{
 
335
        GError *erreur = NULL;
 
336
        gsize length = 0;
 
337
        if (fDefaultValues != NULL)
 
338
                memcpy (fValueBuffer, fDefaultValues, iNbElements * sizeof (double));
 
339
 
 
340
        double *fValuesList = g_key_file_get_double_list (pKeyFile, cGroupName, cKeyName, &length, &erreur);
 
341
        if (erreur != NULL)
 
342
        {
 
343
                if (bFlushConfFileNeeded != NULL)
 
344
                        cd_warning (erreur->message);
 
345
                g_error_free (erreur);
 
346
                erreur = NULL;
 
347
 
 
348
                gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
 
349
                fValuesList = g_key_file_get_double_list (pKeyFile, cGroupNameUpperCase, cKeyName, &length, &erreur);
 
350
                if (erreur != NULL)
 
351
                {
 
352
                        g_error_free (erreur);
 
353
                        erreur = NULL;
 
354
                        fValuesList = g_key_file_get_double_list (pKeyFile, "Cairo Dock", cKeyName, &length, &erreur);
 
355
                        if (erreur != NULL)
 
356
                        {
 
357
                                g_error_free (erreur);
 
358
                                erreur = NULL;
 
359
                                fValuesList = g_key_file_get_double_list (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &length, &erreur);
 
360
                                if (erreur != NULL)
 
361
                                {
 
362
                                        g_error_free (erreur);
 
363
                                }
 
364
                                else
 
365
                                {
 
366
                                        cd_message (" (recuperee)");
 
367
                                        if (length > 0)
 
368
                                                memcpy (fValueBuffer, fValuesList, MIN (iNbElements, length) * sizeof (double));
 
369
                                }
 
370
                        }
 
371
                        else
 
372
                        {
 
373
                                cd_message (" (recuperee)");
 
374
                                if (length > 0)
 
375
                                        memcpy (fValueBuffer, fValuesList, MIN (iNbElements, length) * sizeof (double));
 
376
                        }
 
377
                }
 
378
                else
 
379
                {
 
380
                        if (length > 0)
 
381
                                memcpy (fValueBuffer, fValuesList, MIN (iNbElements, length) * sizeof (double));
 
382
                }
 
383
                g_free (cGroupNameUpperCase);
 
384
 
 
385
                g_key_file_set_double_list (pKeyFile, cGroupName, cKeyName, fValueBuffer, iNbElements);
 
386
                if (bFlushConfFileNeeded != NULL)
 
387
                        *bFlushConfFileNeeded = TRUE;
 
388
        }
 
389
        else
 
390
        {
 
391
                if (length > 0)
 
392
                        memcpy (fValueBuffer, fValuesList, MIN (iNbElements, length) * sizeof (double));
 
393
        }
 
394
        g_free (fValuesList);
 
395
}
 
396
 
 
397
gchar **cairo_dock_get_string_list_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, gsize *length, const gchar *cDefaultValues, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName)
 
398
{
 
399
        GError *erreur = NULL;
 
400
        *length = 0;
 
401
        gchar **cValuesList = g_key_file_get_string_list (pKeyFile, cGroupName, cKeyName, length, &erreur);
 
402
        if (erreur != NULL)
 
403
        {
 
404
                if (bFlushConfFileNeeded != NULL)
 
405
                        cd_warning (erreur->message);
 
406
                g_error_free (erreur);
 
407
                erreur = NULL;
 
408
 
 
409
                gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
 
410
                cValuesList = g_key_file_get_string_list (pKeyFile, cGroupNameUpperCase, cKeyName, length, &erreur);
 
411
                if (erreur != NULL)
 
412
                {
 
413
                        g_error_free (erreur);
 
414
                        erreur = NULL;
 
415
                        cValuesList = g_key_file_get_string_list (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), length, &erreur);
 
416
                        if (erreur != NULL)
 
417
                        {
 
418
                                g_error_free (erreur);
 
419
                                cValuesList = g_strsplit (cDefaultValues, ";", -1);  // "" -> NULL.
 
420
                                int i = 0;
 
421
                                if (cValuesList != NULL)
 
422
                                {
 
423
                                        while (cValuesList[i] != NULL)
 
424
                                                i ++;
 
425
                                }
 
426
                                *length = i;
 
427
                        }
 
428
                }
 
429
                g_free (cGroupNameUpperCase);
 
430
 
 
431
                if (*length > 0)
 
432
                        g_key_file_set_string_list (pKeyFile, cGroupName, cKeyName, (const gchar **)cValuesList, *length);
 
433
                else
 
434
                        g_key_file_set_string (pKeyFile, cGroupName, cKeyName, "");
 
435
                if (bFlushConfFileNeeded != NULL)
 
436
                        *bFlushConfFileNeeded = TRUE;
 
437
        }
 
438
        if (cValuesList != NULL && (cValuesList[0] == NULL || (*(cValuesList[0]) == '\0' && *length == 1)))
 
439
        {
 
440
                g_strfreev (cValuesList);
 
441
                cValuesList = NULL;
 
442
                *length = 0;
 
443
        }
 
444
        return cValuesList;
 
445
}
 
446
 
 
447
gchar *cairo_dock_get_file_path_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName, const gchar *cDefaultDir, const gchar *cDefaultFileName)
 
448
{
 
449
        gchar *cFileName = cairo_dock_get_string_key_value (pKeyFile, cGroupName, cKeyName, bFlushConfFileNeeded, NULL, cDefaultGroupName, cDefaultKeyName);
 
450
        gchar *cFilePath = NULL;
 
451
        if (cFileName != NULL)
 
452
                cFilePath = cairo_dock_generate_file_path (cFileName);
 
453
        else if (cDefaultFileName != NULL && cDefaultDir != NULL)
 
454
                cFilePath = g_strdup_printf ("%s/%s", cDefaultDir, cDefaultFileName);
 
455
        return cFilePath;
 
456
}
 
457
void cairo_dock_get_size_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, gint iDefaultSize, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName, int *iWidth, int *iHeight)
 
458
{
 
459
        int iSize[2];
 
460
        int iDefaultValues[2] = {iDefaultSize, iDefaultSize};
 
461
        cairo_dock_get_integer_list_key_value (pKeyFile, cGroupName, cKeyName, bFlushConfFileNeeded, iSize, 2, iDefaultValues, cDefaultGroupName, cDefaultKeyName);
 
462
        *iWidth = iSize[0];
 
463
        *iHeight = iSize[1];
 
464
}
 
465
 
 
466
 
 
467
void cairo_dock_load_config (const gchar *cConfFilePath, CairoDock *pMainDock)
 
468
{
 
469
        //\___________________ On ouvre le fichier de conf.
 
470
        gboolean bFlushConfFileNeeded = FALSE;  // si un champ n'existe pas, on le rajoute au fichier de conf.
 
471
        GKeyFile *pKeyFile = cairo_dock_open_key_file (cConfFilePath);
 
472
        g_return_if_fail (pKeyFile != NULL);
 
473
        
 
474
        s_bLoading = TRUE;
 
475
        
 
476
        //\___________________ On recupere la conf de tous les modules.
 
477
        bFlushConfFileNeeded = cairo_dock_get_global_config (pKeyFile);
 
478
        
 
479
        //\___________________ Post-initialisation : parametres impactant le main dock.
 
480
        pMainDock->iGapX = myPosition.iGapX;
 
481
        pMainDock->iGapY = myPosition.iGapY;
 
482
        pMainDock->fAlign = myPosition.fAlign;
 
483
        if (myPosition.bUseXinerama)
 
484
        {
 
485
                pMainDock->iNumScreen = myPosition.iNumScreen;
 
486
                cairo_dock_get_screen_offsets (myPosition.iNumScreen, &pMainDock->iScreenOffsetX, &pMainDock->iScreenOffsetY);
 
487
        }
 
488
        
 
489
        cairo_dock_set_dock_orientation (pMainDock, myPosition.iScreenBorder);
 
490
        cairo_dock_move_resize_dock (pMainDock);
 
491
        
 
492
        //\___________________ fausse transparence.
 
493
        if (mySystem.bUseFakeTransparency)
 
494
        {
 
495
                g_pFakeTransparencyDesktopBg = cairo_dock_get_desktop_background (g_bUseOpenGL);
 
496
        }
 
497
        
 
498
        //\___________________ On charge les images dont on aura besoin tout de suite.
 
499
        cairo_dock_load_icon_textures ();
 
500
        cairo_dock_load_indicator_textures ();
 
501
        
 
502
        cairo_dock_load_visible_zone (myAccessibility.cZoneImage, myAccessibility.iZoneWidth, myAccessibility.iZoneHeight, myAccessibility.fZoneAlpha);
 
503
        
 
504
        cairo_dock_create_icon_fbo ();
 
505
        
 
506
        //\___________________ On charge les lanceurs.
 
507
        pMainDock->fFlatDockWidth = - myIcons.iIconGap;  // car on ne le connaissait pas encore au moment de sa creation .
 
508
        cairo_dock_build_docks_tree_with_desktop_files (g_cCurrentLaunchersPath);
 
509
        
 
510
        cairo_dock_hide_show_launchers_on_other_desktops (pMainDock);
 
511
        
 
512
        //\___________________ On charge les applets.
 
513
        GTimeVal time_val;
 
514
        g_get_current_time (&time_val);  // on pourrait aussi utiliser un compteur statique a la fonction ...
 
515
        double fTime = time_val.tv_sec + time_val.tv_usec * 1e-6;
 
516
        cairo_dock_activate_modules_from_list (mySystem.cActiveModuleList, fTime);
 
517
        
 
518
        //\___________________ On lance la barre des taches.
 
519
        if (myTaskBar.bShowAppli)
 
520
        {
 
521
                cairo_dock_start_application_manager (pMainDock);  // va inserer le separateur si necessaire.
 
522
        }
 
523
        
 
524
        //\___________________ On dessine tout.
 
525
        cairo_dock_draw_subdock_icons ();
 
526
        
 
527
        cairo_dock_set_all_views_to_default (0);  // met a jour la taille de tous les docks, maintenant qu'ils sont tous remplis.
 
528
        cairo_dock_redraw_root_docks (FALSE);  // FALSE <=> main dock inclus.
 
529
        
 
530
        //\___________________ On charge le comportement d'accessibilite.
 
531
        g_pHidingBackend = cairo_dock_get_hiding_effect (myAccessibility.cHideEffect);
 
532
        
 
533
        cairo_dock_set_dock_visibility (pMainDock, myAccessibility.iVisibility);
 
534
        
 
535
        //\___________________ On charge les decorations des desklets.
 
536
        if (myDesklets.cDeskletDecorationsName != NULL)  // chargement initial, on charge juste ceux qui n'ont pas encore leur deco et qui ont atteint leur taille definitive.
 
537
        {
 
538
                cairo_dock_reload_desklets_decorations (FALSE);
 
539
        }
 
540
        
 
541
        //\___________________ On charge les listes de backends.
 
542
        cairo_dock_update_renderer_list_for_gui ();
 
543
        cairo_dock_update_desklet_decorations_list_for_gui ();
 
544
        cairo_dock_update_desklet_decorations_list_for_applet_gui ();
 
545
        cairo_dock_update_animations_list_for_gui ();
 
546
        cairo_dock_update_dialog_decorator_list_for_gui ();
 
547
        
 
548
        //\___________________ On met a jour le fichier sur le disque si necessaire.
 
549
        if (! bFlushConfFileNeeded)
 
550
                bFlushConfFileNeeded = cairo_dock_conf_file_needs_update (pKeyFile, GLDI_VERSION);
 
551
        if (bFlushConfFileNeeded)
 
552
        {
 
553
                cairo_dock_flush_conf_file (pKeyFile, cConfFilePath, CAIRO_DOCK_SHARE_DATA_DIR, CAIRO_DOCK_CONF_FILE);
 
554
        }
 
555
        
 
556
        g_key_file_free (pKeyFile);
 
557
 
 
558
        s_bLoading = FALSE;
 
559
        
 
560
        cairo_dock_trigger_refresh_launcher_gui ();
 
561
}
 
562
 
 
563
void cairo_dock_read_conf_file (const gchar *cConfFilePath, CairoDock *pDock)
 
564
{
 
565
        //g_print ("%s (%s)\n", __func__, cConfFilePath);
 
566
        GError *erreur = NULL;
 
567
        gsize length;
 
568
        gboolean bFlushConfFileNeeded = FALSE, bFlushConfFileNeeded2 = FALSE;  // si un champ n'existe pas, on le rajoute au fichier de conf.
 
569
 
 
570
        //\___________________ On ouvre le fichier de conf.
 
571
        GKeyFile *pKeyFile = cairo_dock_open_key_file (cConfFilePath);
 
572
        if (pKeyFile == NULL)
 
573
                return ;
 
574
        
 
575
        s_bLoading = TRUE;
 
576
        
 
577
        //\___________________ On garde une trace de certains parametres.
 
578
        gchar *cRaiseDockShortcutOld = myAccessibility.cRaiseDockShortcut;
 
579
        myAccessibility.cRaiseDockShortcut = NULL;
 
580
        ///gboolean bPopUpOld = myAccessibility.bPopUp;  // FALSE initialement.
 
581
        gboolean bUseFakeTransparencyOld = mySystem.bUseFakeTransparency;  // FALSE initialement.
 
582
        gboolean bGroupAppliByClassOld = myTaskBar.bGroupAppliByClass;  // FALSE initialement.
 
583
        gboolean bHideVisibleApplisOld = myTaskBar.bHideVisibleApplis;
 
584
        gboolean bAppliOnCurrentDesktopOnlyOld = myTaskBar.bAppliOnCurrentDesktopOnly;
 
585
        gboolean bMixLauncherAppliOld = myTaskBar.bMixLauncherAppli;
 
586
        gboolean bOverWriteXIconsOld = myTaskBar.bOverWriteXIcons;  // TRUE initialement.
 
587
        gint iMinimizedWindowRenderTypeOld = myTaskBar.iMinimizedWindowRenderType;
 
588
        gchar *cDeskletDecorationsNameOld = myDesklets.cDeskletDecorationsName;
 
589
        myDesklets.cDeskletDecorationsName = NULL;
 
590
        int iSeparateIconsOld = myIcons.iSeparateIcons;
 
591
        CairoDockIconType tIconTypeOrderOld[CAIRO_DOCK_NB_TYPES];
 
592
        memcpy (tIconTypeOrderOld, myIcons.tIconTypeOrder, sizeof (tIconTypeOrderOld));
 
593
        
 
594
        //\___________________ On recupere la conf de tous les modules.
 
595
        bFlushConfFileNeeded = cairo_dock_get_global_config (pKeyFile);
 
596
        
 
597
        //\___________________ Post-initialisation : parametres impactant le main dock.
 
598
        pDock->iGapX = myPosition.iGapX;
 
599
        pDock->iGapY = myPosition.iGapY;
 
600
        
 
601
        pDock->fAlign = myPosition.fAlign;
 
602
        
 
603
        gboolean bGroupOrderChanged;
 
604
        if (tIconTypeOrderOld[CAIRO_DOCK_LAUNCHER] != myIcons.tIconTypeOrder[CAIRO_DOCK_LAUNCHER] ||
 
605
                tIconTypeOrderOld[CAIRO_DOCK_APPLI] != myIcons.tIconTypeOrder[CAIRO_DOCK_APPLI] ||
 
606
                tIconTypeOrderOld[CAIRO_DOCK_APPLET] != myIcons.tIconTypeOrder[CAIRO_DOCK_APPLET])
 
607
                bGroupOrderChanged = TRUE;
 
608
        else
 
609
                bGroupOrderChanged = FALSE;
 
610
        
 
611
        if (myPosition.bUseXinerama)
 
612
        {
 
613
                pDock->iNumScreen = myPosition.iNumScreen;
 
614
                cairo_dock_get_screen_offsets (myPosition.iNumScreen, &pDock->iScreenOffsetX, &pDock->iScreenOffsetY);
 
615
        }
 
616
        else
 
617
        {
 
618
                pDock->iNumScreen = pDock->iScreenOffsetX = pDock->iScreenOffsetY = 0;
 
619
        }
 
620
        
 
621
        switch (myPosition.iScreenBorder)
 
622
        {
 
623
                case CAIRO_DOCK_BOTTOM :
 
624
                default :
 
625
                        pDock->container.bIsHorizontal = CAIRO_DOCK_HORIZONTAL;
 
626
                        pDock->container.bDirectionUp = TRUE;
 
627
                break;
 
628
                case CAIRO_DOCK_TOP :
 
629
                        pDock->container.bIsHorizontal = CAIRO_DOCK_HORIZONTAL;
 
630
                        pDock->container.bDirectionUp = FALSE;
 
631
                break;
 
632
                case CAIRO_DOCK_RIGHT :
 
633
                        pDock->container.bIsHorizontal = CAIRO_DOCK_VERTICAL;
 
634
                        pDock->container.bDirectionUp = TRUE;
 
635
                break;
 
636
                case CAIRO_DOCK_LEFT :
 
637
                        pDock->container.bIsHorizontal = CAIRO_DOCK_VERTICAL;
 
638
                        pDock->container.bDirectionUp = FALSE;
 
639
                break;
 
640
        }
 
641
        
 
642
        //\___________________ On (re)charge tout, car n'importe quel parametre peut avoir change.
 
643
        // fausse transparence.
 
644
        if (mySystem.bUseFakeTransparency)
 
645
        {
 
646
                if (g_pFakeTransparencyDesktopBg == NULL)
 
647
                {
 
648
                        g_pFakeTransparencyDesktopBg = cairo_dock_get_desktop_background (g_bUseOpenGL);
 
649
                }
 
650
                else if (g_bUseOpenGL)
 
651
                {
 
652
                        CairoDockDesktopBackground *dummy = cairo_dock_get_desktop_background (g_bUseOpenGL);  // pour recharger la texture.
 
653
                        cairo_dock_destroy_desktop_background (dummy);
 
654
                }
 
655
        }
 
656
        else if (g_pFakeTransparencyDesktopBg != NULL)
 
657
        {
 
658
                cairo_dock_destroy_desktop_background (g_pFakeTransparencyDesktopBg);
 
659
                g_pFakeTransparencyDesktopBg = NULL;
 
660
        }
 
661
        
 
662
        //\___________________ on recharge les buffers d'images.
 
663
        cairo_dock_unload_dialog_buttons ();  // on se contente de remettre a zero ces buffers,
 
664
        cairo_dock_unload_desklet_buttons ();  // qui seront charges lorsque necessaire.
 
665
        
 
666
        cairo_dock_load_icon_textures ();
 
667
        cairo_dock_load_indicator_textures ();
 
668
        
 
669
        cairo_dock_load_visible_zone (myAccessibility.cZoneImage, myAccessibility.iZoneWidth, myAccessibility.iZoneHeight, myAccessibility.fZoneAlpha);
 
670
        
 
671
        ///cairo_dock_create_icon_pbuffer ();
 
672
        cairo_dock_create_icon_fbo ();
 
673
        
 
674
        //\___________________ On recharge les lanceurs, les applis, et les applets.
 
675
        if (bGroupAppliByClassOld != myTaskBar.bGroupAppliByClass ||
 
676
                bHideVisibleApplisOld != myTaskBar.bHideVisibleApplis ||
 
677
                bAppliOnCurrentDesktopOnlyOld != myTaskBar.bAppliOnCurrentDesktopOnly ||
 
678
                bMixLauncherAppliOld != myTaskBar.bMixLauncherAppli ||
 
679
                bOverWriteXIconsOld != myTaskBar.bOverWriteXIcons ||
 
680
                iMinimizedWindowRenderTypeOld != myTaskBar.iMinimizedWindowRenderType ||
 
681
                (cairo_dock_application_manager_is_running () && ! myTaskBar.bShowAppli))  // on ne veut plus voir les applis, il faut donc les enlever.
 
682
        {
 
683
                cairo_dock_stop_application_manager ();
 
684
        }
 
685
        
 
686
        if (bGroupOrderChanged || myIcons.iSeparateIcons != iSeparateIconsOld)
 
687
                pDock->icons = g_list_sort (pDock->icons, (GCompareFunc) cairo_dock_compare_icons_order);
 
688
        
 
689
        if ((iSeparateIconsOld && ! myIcons.iSeparateIcons) || bGroupOrderChanged)
 
690
                cairo_dock_remove_automatic_separators (pDock);
 
691
                
 
692
        if (pDock->icons == NULL)
 
693
        {
 
694
                pDock->fFlatDockWidth = - myIcons.iIconGap;  // car on ne le connaissait pas encore au moment de la creation du dock.
 
695
                cairo_dock_build_docks_tree_with_desktop_files (g_cCurrentLaunchersPath);
 
696
        }
 
697
        else
 
698
        {
 
699
                cairo_dock_synchronize_sub_docks_orientation (pDock, FALSE);
 
700
                cairo_dock_reload_buffers_in_all_docks (FALSE);  // tout sauf les applets, qui seront rechargees en bloc juste apres.
 
701
        }
 
702
        
 
703
        GTimeVal time_val;
 
704
        g_get_current_time (&time_val);  // on pourrait aussi utiliser un compteur statique a la fonction ...
 
705
        double fTime = time_val.tv_sec + time_val.tv_usec * 1e-6;
 
706
        cairo_dock_activate_modules_from_list (mySystem.cActiveModuleList, fTime);
 
707
        cairo_dock_deactivate_old_modules (fTime);
 
708
        
 
709
        if (! cairo_dock_application_manager_is_running () && myTaskBar.bShowAppli)  // maintenant on veut voir les applis !
 
710
        {
 
711
                cairo_dock_start_application_manager (pDock);  // va inserer le separateur si necessaire.
 
712
        }
 
713
 
 
714
        if (myIcons.iSeparateIcons && (! iSeparateIconsOld || bGroupOrderChanged))
 
715
        {
 
716
                cairo_dock_insert_separators_in_dock (pDock);
 
717
        }
 
718
        
 
719
        cairo_dock_draw_subdock_icons ();
 
720
        
 
721
        cairo_dock_set_all_views_to_default (0);  // met a jour la taille de tous les docks, maintenant qu'ils sont tous remplis.
 
722
        cairo_dock_redraw_root_docks (TRUE);  // TRUE <=> sauf le main dock.
 
723
        
 
724
        if (myAccessibility.cRaiseDockShortcut != NULL)
 
725
        {
 
726
                if (cRaiseDockShortcutOld == NULL || strcmp (myAccessibility.cRaiseDockShortcut, cRaiseDockShortcutOld) != 0)
 
727
                {
 
728
                        if (cRaiseDockShortcutOld != NULL)
 
729
                                cd_keybinder_unbind (cRaiseDockShortcutOld, (CDBindkeyHandler) cairo_dock_raise_from_shortcut);
 
730
                        if (! cd_keybinder_bind (myAccessibility.cRaiseDockShortcut, (CDBindkeyHandler) cairo_dock_raise_from_shortcut, NULL))
 
731
                        {
 
732
                                g_free (myAccessibility.cRaiseDockShortcut);
 
733
                                myAccessibility.cRaiseDockShortcut = NULL;
 
734
                        }
 
735
                }
 
736
        }
 
737
        else
 
738
        {
 
739
                if (cRaiseDockShortcutOld != NULL)
 
740
                {
 
741
                        cd_keybinder_unbind (cRaiseDockShortcutOld, (CDBindkeyHandler) cairo_dock_raise_from_shortcut);
 
742
                        cairo_dock_move_resize_dock (pDock);
 
743
                        gtk_widget_show (pDock->container.pWidget);
 
744
                }
 
745
        }
 
746
        g_free (cRaiseDockShortcutOld);
 
747
        
 
748
        //\___________________ On gere le changement dans la visibilite.
 
749
        g_pHidingBackend = cairo_dock_get_hiding_effect (myAccessibility.cHideEffect);
 
750
        
 
751
        if (pDock->bAutoHide)
 
752
        {
 
753
                pDock->iInputState = CAIRO_DOCK_INPUT_HIDDEN;  // le 'configure' mettra a jour la zone d'input.
 
754
                pDock->fHideOffset = 1.;
 
755
        }
 
756
        else
 
757
        {
 
758
                cairo_dock_start_showing (pDock);
 
759
        }
 
760
        
 
761
        cairo_dock_hide_show_launchers_on_other_desktops (pDock);
 
762
        
 
763
        cairo_dock_set_dock_visibility (pDock, myAccessibility.iVisibility);
 
764
        
 
765
        ///cairo_dock_load_background_decorations (pDock);
 
766
 
 
767
        cairo_dock_move_resize_dock (pDock);
 
768
        
 
769
        pDock->container.iMouseX = 0;  // on se place hors du dock initialement.
 
770
        pDock->container.iMouseY = 0;
 
771
        cairo_dock_calculate_dock_icons (pDock);
 
772
        gtk_widget_queue_draw (pDock->container.pWidget);  // le 'gdk_window_move_resize' ci-dessous ne provoquera pas le redessin si la taille n'a pas change.
 
773
        
 
774
        //\___________________ On recharge les decorations des desklets.
 
775
        if (cDeskletDecorationsNameOld == NULL && myDesklets.cDeskletDecorationsName != NULL)  // chargement initial, on charge juste ceux qui n'ont pas encore leur deco et qui ont atteint leur taille definitive.
 
776
        {
 
777
                cairo_dock_reload_desklets_decorations (FALSE);
 
778
        }
 
779
        else if (cDeskletDecorationsNameOld != NULL && (myDesklets.cDeskletDecorationsName == NULL || strcmp (cDeskletDecorationsNameOld, myDesklets.cDeskletDecorationsName) != 0))  // le theme par defaut a change, on recharge les desklets qui utilisent le theme "default".
 
780
        {
 
781
                cairo_dock_reload_desklets_decorations (TRUE);
 
782
        }
 
783
        else if (myDesklets.cDeskletDecorationsName != NULL && strcmp (myDesklets.cDeskletDecorationsName, "personnal") == 0)  // on a configure le theme personnel, il peut avoir change.
 
784
        {
 
785
                cairo_dock_reload_desklets_decorations (TRUE);
 
786
        }
 
787
        else  // on charge juste ceux qui n'ont pas encore leur deco et qui ont atteint leur taille definitive.
 
788
        {
 
789
                cairo_dock_reload_desklets_decorations (FALSE);
 
790
        }
 
791
        g_free (cDeskletDecorationsNameOld);
 
792
        
 
793
        cairo_dock_update_renderer_list_for_gui ();
 
794
        cairo_dock_update_desklet_decorations_list_for_gui ();
 
795
        cairo_dock_update_desklet_decorations_list_for_applet_gui ();
 
796
        cairo_dock_update_animations_list_for_gui ();
 
797
        cairo_dock_update_dialog_decorator_list_for_gui ();
 
798
        
 
799
        //\___________________ On ecrit sur le disque si necessaire.
 
800
        if (! bFlushConfFileNeeded)
 
801
                bFlushConfFileNeeded = cairo_dock_conf_file_needs_update (pKeyFile, GLDI_VERSION);
 
802
        if (bFlushConfFileNeeded)
 
803
        {
 
804
                cairo_dock_flush_conf_file (pKeyFile, cConfFilePath, CAIRO_DOCK_SHARE_DATA_DIR, CAIRO_DOCK_CONF_FILE);
 
805
        }
 
806
        
 
807
        g_key_file_free (pKeyFile);
 
808
 
 
809
        s_bLoading = FALSE;
 
810
        
 
811
        cairo_dock_trigger_refresh_launcher_gui ();
 
812
}
 
813
 
 
814
gboolean cairo_dock_is_loading (void)
 
815
{
 
816
        return s_bLoading;
 
817
}
 
818
 
 
819
 
 
820
void cairo_dock_update_conf_file (const gchar *cConfFilePath, GType iFirstDataType, ...)  // type, groupe, cle, valeur, etc. finir par G_TYPE_INVALID.
 
821
{
 
822
        cd_message ("%s (%s)", __func__, cConfFilePath);
 
823
        GKeyFile *pKeyFile = cairo_dock_open_key_file (cConfFilePath);
 
824
        g_return_if_fail (pKeyFile != NULL);
 
825
        
 
826
        va_list args;
 
827
        va_start (args, iFirstDataType);
 
828
        
 
829
        GType iType = iFirstDataType;
 
830
        gboolean bValue;
 
831
        gint iValue;
 
832
        double fValue;
 
833
        gchar *cValue;
 
834
        gchar *cGroupName, *cGroupKey;
 
835
        while (iType != G_TYPE_INVALID)
 
836
        {
 
837
                cGroupName = va_arg (args, gchar *);
 
838
                cGroupKey = va_arg (args, gchar *);
 
839
 
 
840
                switch (iType)
 
841
                {
 
842
                        case G_TYPE_BOOLEAN :
 
843
                                bValue = va_arg (args, gboolean);
 
844
                                g_key_file_set_boolean (pKeyFile, cGroupName, cGroupKey, bValue);
 
845
                        break ;
 
846
                        case G_TYPE_INT :
 
847
                                iValue = va_arg (args, gint);
 
848
                                g_key_file_set_integer (pKeyFile, cGroupName, cGroupKey, iValue);
 
849
                        break ;
 
850
                        case G_TYPE_DOUBLE :
 
851
                                fValue = va_arg (args, gdouble);
 
852
                                g_key_file_set_double (pKeyFile, cGroupName, cGroupKey, fValue);
 
853
                        break ;
 
854
                        case G_TYPE_STRING :
 
855
                                cValue = va_arg (args, gchar *);
 
856
                                g_key_file_set_string (pKeyFile, cGroupName, cGroupKey, cValue);
 
857
                        break ;
 
858
                        default :
 
859
                        break ;
 
860
                }
 
861
 
 
862
                iType = va_arg (args, GType);
 
863
        }
 
864
 
 
865
        cairo_dock_write_keys_to_file (pKeyFile, cConfFilePath);
 
866
        g_key_file_free (pKeyFile);
 
867
 
 
868
        va_end (args);
 
869
}
 
870
 
 
871
 
 
872
void cairo_dock_update_conf_file_with_position (const gchar *cConfFilePath, int x, int y)
 
873
{
 
874
        //g_print ("%s (%s ; %d;%d)\n", __func__, cConfFilePath, x, y);
 
875
        cairo_dock_update_conf_file (cConfFilePath,
 
876
                G_TYPE_INT, "Position", "x gap", x,
 
877
                G_TYPE_INT, "Position", "y gap", y,
 
878
                G_TYPE_INVALID);
 
879
}
 
880
 
 
881
 
 
882
void cairo_dock_get_version_from_string (const gchar *cVersionString, int *iMajorVersion, int *iMinorVersion, int *iMicroVersion)
 
883
{
 
884
        gchar **cVersions = g_strsplit (cVersionString, ".", -1);
 
885
        if (cVersions[0] != NULL)
 
886
        {
 
887
                *iMajorVersion = atoi (cVersions[0]);
 
888
                if (cVersions[1] != NULL)
 
889
                {
 
890
                        *iMinorVersion = atoi (cVersions[1]);
 
891
                        if (cVersions[2] != NULL)
 
892
                                *iMicroVersion = atoi (cVersions[2]);
 
893
                }
 
894
        }
 
895
        g_strfreev (cVersions);
 
896
}
 
897
 
 
898
 
 
899
void cairo_dock_decrypt_string( const gchar *cEncryptedString,  gchar **cDecryptedString )
 
900
{
 
901
        g_return_if_fail (cDecryptedString != NULL);
 
902
        if( !cEncryptedString || *cEncryptedString == '\0' )
 
903
        {
 
904
                *cDecryptedString = g_strdup( "" );
 
905
                return;
 
906
        }
 
907
#ifdef HAVE_LIBCRYPT
 
908
        guchar *input = g_strdup(cEncryptedString);
 
909
        guchar *shifted_input = input;
 
910
        guchar **output = (guchar **)cDecryptedString;
 
911
        
 
912
        guchar *current_output = NULL;
 
913
        
 
914
        *output = g_malloc( (strlen(input)+1)/3+1 );
 
915
        current_output = *output;
 
916
 
 
917
  guchar *last_char_in_input = input + strlen(input);
 
918
//  g_print( "Password (before decrypt): %s\n", input );
 
919
 
 
920
  for( ; shifted_input < last_char_in_input; shifted_input += 16+8, current_output += 8 )
 
921
  {
 
922
    guint block[8];
 
923
    guchar txt[64];
 
924
    gint i = 0, j = 0;
 
925
    guchar current_letter = 0;
 
926
    
 
927
    memset( txt, 0, 64 );
 
928
 
 
929
    shifted_input[16+8-1] = 0; // cut the string
 
930
 
 
931
    sscanf( shifted_input, "%X-%X-%X-%X-%X-%X-%X-%X",
 
932
    &block[0], &block[1], &block[2], &block[3], &block[4], &block[5], &block[6], &block[7] );
 
933
 
 
934
    // process the eight first characters of "input"
 
935
    for( i = 0; i < 8 ; i++ )
 
936
      for ( j = 0; j < 8; j++ )
 
937
        txt[i*8+j] = block[i] >> j & 1;
 
938
    
 
939
    setkey( DES_crypt_key );
 
940
    encrypt( txt, 1 );  // decrypt
 
941
 
 
942
    for ( i = 0; i < 8; i++ )
 
943
    {
 
944
      current_output[i] = 0;
 
945
      for ( j = 0; j < 8; j++ )
 
946
      {
 
947
        current_output[i] |= txt[i*8+j] << j;
 
948
      }
 
949
    }
 
950
  }
 
951
 
 
952
  *current_output = 0;
 
953
 
 
954
//  g_print( "Password (after decrypt): %s\n", *output );
 
955
 
 
956
        g_free( input );
 
957
 
 
958
#else
 
959
        *cDecryptedString = g_strdup( cEncryptedString );
 
960
#endif
 
961
}
 
962
 
 
963
void cairo_dock_encrypt_string( const gchar *cDecryptedString,  gchar **cEncryptedString )
 
964
{
 
965
        g_return_if_fail (cEncryptedString != NULL);
 
966
        if( !cDecryptedString || *cDecryptedString == '\0' )
 
967
        {
 
968
                *cEncryptedString = g_strdup( "" );
 
969
                return;
 
970
        }
 
971
        
 
972
#ifdef HAVE_LIBCRYPT
 
973
        const guchar *input = (guchar *)cDecryptedString;
 
974
        guchar **output = (guchar **)cEncryptedString;
 
975
        guint input_length = 0;
 
976
        
 
977
        guchar *current_output = NULL;
 
978
        // for each block of 8 characters, we need 24 bytes.
 
979
        guint nbBlocks = strlen(input)/8+1;
 
980
        *output = g_malloc( nbBlocks*24+1 );
 
981
        current_output = *output;
 
982
 
 
983
  const guchar *last_char_in_input = input + strlen(input);
 
984
 
 
985
//  g_print( "Password (before encrypt): %s\n", input );
 
986
 
 
987
  for( ; input < last_char_in_input; input += 8, current_output += 16+8 )
 
988
  {
 
989
    guchar txt[64];
 
990
    guint i = 0, j = 0;
 
991
    guchar current_letter = 0;
 
992
    
 
993
    memset( txt, 0, 64 );
 
994
    
 
995
    // process the eight first characters of "input"
 
996
    for( i = 0; i < strlen(input) && i < 8 ; i++ )
 
997
      for ( j = 0; j < 8; j++ )
 
998
        txt[i*8+j] = input[i] >> j & 1;
 
999
    
 
1000
    setkey( DES_crypt_key );
 
1001
    encrypt( txt, 0 );  // encrypt
 
1002
 
 
1003
    for ( i = 0; i < 8; i++ )
 
1004
    {
 
1005
      current_letter = 0;
 
1006
      for ( j = 0; j < 8; j++ )
 
1007
      {
 
1008
        current_letter |= txt[i*8+j] << j;
 
1009
      }
 
1010
      snprintf( current_output + i*3, 4, "%02X-", current_letter );
 
1011
    }
 
1012
  }
 
1013
 
 
1014
  *(current_output-1) = 0;
 
1015
 
 
1016
//  g_print( "Password (after encrypt): %s\n", *output );
 
1017
#else
 
1018
        *cEncryptedString = g_strdup( cDecryptedString );
 
1019
#endif
 
1020
}
 
1021
 
 
1022
 
 
1023
xmlDocPtr cairo_dock_open_xml_file (const gchar *cDataFilePath, const gchar *cRootNodeName, xmlNodePtr *root_node, GError **erreur)
 
1024
{
 
1025
        if (cairo_dock_get_file_size (cDataFilePath) == 0)
 
1026
        {
 
1027
                g_set_error (erreur, 1, 1, "file '%s' doesn't exist or is empty", cDataFilePath);
 
1028
                *root_node = NULL;
 
1029
                return NULL;
 
1030
        }
 
1031
        xmlInitParser ();
 
1032
        
 
1033
        xmlDocPtr doc = xmlParseFile (cDataFilePath);
 
1034
        if (doc == NULL)
 
1035
        {
 
1036
                g_set_error (erreur, 1, 1, "file '%s' is incorrect", cDataFilePath);
 
1037
                *root_node = NULL;
 
1038
                return NULL;
 
1039
        }
 
1040
        
 
1041
        xmlNodePtr noeud = xmlDocGetRootElement (doc);
 
1042
        if (noeud == NULL || xmlStrcmp (noeud->name, (const xmlChar *) cRootNodeName) != 0)
 
1043
        {
 
1044
                g_set_error (erreur, 1, 2, "xml file '%s' is not well formed", cDataFilePath);
 
1045
                *root_node = NULL;
 
1046
                return doc;
 
1047
        }
 
1048
        *root_node = noeud;
 
1049
        return doc;
 
1050
}
 
1051
 
 
1052
void cairo_dock_close_xml_file (xmlDocPtr doc)
 
1053
{
 
1054
        if (doc)
 
1055
                xmlFreeDoc (doc);  // ne pas utiliser xmlCleanupParser(), cela peut affecter les autres threads utilisant libxml !
 
1056
}
 
1057
 
 
1058
 
 
1059
 
 
1060
gchar *cairo_dock_get_default_system_font (void)
 
1061
{
 
1062
        static gchar *s_cFontName = NULL;
 
1063
        if (s_cFontName == NULL)
 
1064
        {
 
1065
                if (g_iDesktopEnv == CAIRO_DOCK_GNOME)
 
1066
                        s_cFontName = cairo_dock_launch_command_sync ("gconftool-2 -g /desktop/gnome/interface/font_name");  /// ou document_font_name ?...
 
1067
                else
 
1068
                        s_cFontName = g_strdup ("Sans 10");
 
1069
        }
 
1070
        return g_strdup (s_cFontName);
 
1071
}