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 "gldi-config.h"
29
30 #ifdef HAVE_LIBCRYPT
31 #if defined(__FreeBSD__) || defined(__DragonFly__)
32 #include <unistd.h> // on BSD, there is no crypt.h
33 #else
34 #include <crypt.h>
35 #endif
36 static char DES_crypt_key[64] =
37 {
38 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,
39 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
40 };
41 #endif
42
43 #include "cairo-dock-log.h"
44 #include "cairo-dock-icon-manager.h" // cairo_dock_hide_show_launchers_on_other_desktops
45 #include "cairo-dock-applications-manager.h" // cairo_dock_start_applications_manager
46 #include "cairo-dock-module-manager.h" // gldi_modules_activate_from_list
47 #include "cairo-dock-themes-manager.h" // cairo_dock_update_conf_file
48 #include "cairo-dock-dock-factory.h" // gldi_dock_new
49 #include "cairo-dock-file-manager.h" // cairo_dock_get_file_size
50 #include "cairo-dock-user-icon-manager.h" // gldi_user_icons_new_from_directory
51 #include "cairo-dock-core.h" // gldi_free_all
52 #include "cairo-dock-config.h"
53
54 gboolean g_bEasterEggs = FALSE;
55
56 extern gchar *g_cCurrentLaunchersPath;
57 extern gchar *g_cConfFile;
58 extern gboolean g_bUseOpenGL;
59
60 static gboolean s_bLoading = FALSE;
61
62
cairo_dock_get_boolean_key_value(GKeyFile * pKeyFile,const gchar * cGroupName,const gchar * cKeyName,gboolean * bFlushConfFileNeeded,gboolean bDefaultValue,const gchar * cDefaultGroupName,const gchar * cDefaultKeyName)63 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)
64 {
65 GError *erreur = NULL;
66 gboolean bValue = g_key_file_get_boolean (pKeyFile, cGroupName, cKeyName, &erreur);
67 if (erreur != NULL)
68 {
69 if (bFlushConfFileNeeded != NULL)
70 cd_warning (erreur->message);
71 g_error_free (erreur);
72 erreur = NULL;
73
74 gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
75 bValue = g_key_file_get_boolean (pKeyFile, cGroupNameUpperCase, cKeyName, &erreur);
76 g_free (cGroupNameUpperCase);
77 if (erreur != NULL)
78 {
79 g_error_free (erreur);
80 erreur = NULL;
81 bValue = g_key_file_get_boolean (pKeyFile, "Cairo Dock", cKeyName, &erreur);
82 if (erreur != NULL)
83 {
84 g_error_free (erreur);
85 erreur = NULL;
86 bValue = g_key_file_get_boolean (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &erreur);
87 if (erreur != NULL)
88 {
89 g_error_free (erreur);
90 bValue = bDefaultValue;
91 }
92 else
93 cd_message (" (recuperee)");
94 }
95 else
96 cd_message (" (recuperee)");
97 }
98
99 g_key_file_set_boolean (pKeyFile, cGroupName, cKeyName, bValue);
100 if (bFlushConfFileNeeded != NULL)
101 *bFlushConfFileNeeded = TRUE;
102 }
103 return bValue;
104 }
105
cairo_dock_get_integer_key_value(GKeyFile * pKeyFile,const gchar * cGroupName,const gchar * cKeyName,gboolean * bFlushConfFileNeeded,int iDefaultValue,const gchar * cDefaultGroupName,const gchar * cDefaultKeyName)106 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)
107 {
108 GError *erreur = NULL;
109 int iValue = g_key_file_get_integer (pKeyFile, cGroupName, cKeyName, &erreur);
110 if (erreur != NULL)
111 {
112 if (bFlushConfFileNeeded != NULL)
113 cd_warning (erreur->message);
114 g_error_free (erreur);
115 erreur = NULL;
116
117 gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
118 iValue = g_key_file_get_integer (pKeyFile, cGroupNameUpperCase, cKeyName, &erreur);
119 if (erreur != NULL)
120 {
121 g_error_free (erreur);
122 erreur = NULL;
123 iValue = g_key_file_get_integer (pKeyFile, "Cairo Dock", cKeyName, &erreur);
124 if (erreur != NULL)
125 {
126 g_error_free (erreur);
127 erreur = NULL;
128 iValue = g_key_file_get_integer (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &erreur);
129 if (erreur != NULL)
130 {
131 g_error_free (erreur);
132 iValue = iDefaultValue;
133 }
134 else
135 cd_message (" (recuperee)");
136 }
137 else
138 cd_message (" (recuperee)");
139 }
140 g_free (cGroupNameUpperCase);
141
142 g_key_file_set_integer (pKeyFile, cGroupName, cKeyName, iValue);
143 if (bFlushConfFileNeeded != NULL)
144 *bFlushConfFileNeeded = TRUE;
145 }
146 return iValue;
147 }
148
cairo_dock_get_double_key_value(GKeyFile * pKeyFile,const gchar * cGroupName,const gchar * cKeyName,gboolean * bFlushConfFileNeeded,double fDefaultValue,const gchar * cDefaultGroupName,const gchar * cDefaultKeyName)149 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)
150 {
151 GError *erreur = NULL;
152 double fValue = g_key_file_get_double (pKeyFile, cGroupName, cKeyName, &erreur);
153 if (erreur != NULL)
154 {
155 if (bFlushConfFileNeeded != NULL)
156 cd_warning (erreur->message);
157 g_error_free (erreur);
158 erreur = NULL;
159
160 gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
161 fValue = g_key_file_get_double (pKeyFile, cGroupNameUpperCase, cKeyName, &erreur);
162 if (erreur != NULL)
163 {
164 g_error_free (erreur);
165 erreur = NULL;
166 fValue = g_key_file_get_double (pKeyFile, "Cairo Dock", cKeyName, &erreur);
167 if (erreur != NULL)
168 {
169 g_error_free (erreur);
170 erreur = NULL;
171 fValue = g_key_file_get_double (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &erreur);
172 if (erreur != NULL)
173 {
174 g_error_free (erreur);
175 fValue = fDefaultValue;
176 }
177 else
178 cd_message (" (recuperee)");
179 }
180 else
181 cd_message (" (recuperee)");
182 }
183 g_free (cGroupNameUpperCase);
184
185 g_key_file_set_double (pKeyFile, cGroupName, cKeyName, fValue);
186 if (bFlushConfFileNeeded != NULL)
187 *bFlushConfFileNeeded = TRUE;
188 }
189 return fValue;
190 }
191
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)192 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)
193 {
194 GError *erreur = NULL;
195 gchar *cValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, &erreur);
196 if (erreur != NULL)
197 {
198 if (bFlushConfFileNeeded != NULL)
199 cd_warning (erreur->message);
200 g_error_free (erreur);
201 erreur = NULL;
202
203 gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
204 cValue = g_key_file_get_string (pKeyFile, cGroupNameUpperCase, cKeyName, &erreur);
205 if (erreur != NULL)
206 {
207 g_error_free (erreur);
208 erreur = NULL;
209 cValue = g_key_file_get_string (pKeyFile, "Cairo Dock", cKeyName, &erreur);
210 if (erreur != NULL)
211 {
212 g_error_free (erreur);
213 erreur = NULL;
214 cValue = g_key_file_get_string (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &erreur);
215 if (erreur != NULL)
216 {
217 g_error_free (erreur);
218 cValue = g_strdup (cDefaultValue);
219 }
220 else
221 cd_message (" (recuperee)");
222 }
223 else
224 cd_message (" (recuperee)");
225 }
226 g_free (cGroupNameUpperCase);
227
228 g_key_file_set_string (pKeyFile, cGroupName, cKeyName, (cValue != NULL ? cValue : ""));
229 if (bFlushConfFileNeeded != NULL)
230 *bFlushConfFileNeeded = TRUE;
231 }
232 if (cValue != NULL && *cValue == '\0')
233 {
234 g_free (cValue);
235 cValue = NULL;
236 }
237 return cValue;
238 }
239
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)240 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)
241 {
242 GError *erreur = NULL;
243 gsize length = 0;
244 if (iDefaultValues != NULL)
245 memcpy (iValueBuffer, iDefaultValues, iNbElements * sizeof (int));
246
247 int *iValuesList = g_key_file_get_integer_list (pKeyFile, cGroupName, cKeyName, &length, &erreur);
248 if (erreur != NULL)
249 {
250 if (bFlushConfFileNeeded != NULL)
251 cd_warning (erreur->message);
252 g_error_free (erreur);
253 erreur = NULL;
254
255 gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
256 iValuesList = g_key_file_get_integer_list (pKeyFile, cGroupNameUpperCase, cKeyName, &length, &erreur);
257 if (erreur != NULL)
258 {
259 g_error_free (erreur);
260 erreur = NULL;
261 iValuesList = g_key_file_get_integer_list (pKeyFile, "Cairo Dock", cKeyName, &length, &erreur);
262 if (erreur != NULL)
263 {
264 g_error_free (erreur);
265 erreur = NULL;
266 iValuesList = g_key_file_get_integer_list (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &length, &erreur);
267 if (erreur != NULL)
268 {
269 g_error_free (erreur);
270 }
271 else
272 {
273 cd_message (" (recuperee)");
274 if (length > 0)
275 memcpy (iValueBuffer, iValuesList, MIN (iNbElements, length) * sizeof (int));
276 }
277 }
278 else
279 {
280 cd_message (" (recuperee)");
281 if (length > 0)
282 memcpy (iValueBuffer, iValuesList, MIN (iNbElements, length) * sizeof (int));
283 }
284 }
285 else
286 {
287 if (length > 0)
288 memcpy (iValueBuffer, iValuesList, MIN (iNbElements, length) * sizeof (int));
289 }
290 g_free (cGroupNameUpperCase);
291
292 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.
293 g_key_file_set_integer_list (pKeyFile, cGroupName, cKeyName, iValueBuffer, iNbElements);
294 if (bFlushConfFileNeeded != NULL)
295 *bFlushConfFileNeeded = TRUE;
296 }
297 else
298 {
299 if (length > 0)
300 memcpy (iValueBuffer, iValuesList, MIN (iNbElements, length) * sizeof (int));
301 }
302 g_free (iValuesList);
303 }
304
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)305 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)
306 {
307 GError *erreur = NULL;
308 gsize length = 0;
309 if (fDefaultValues != NULL)
310 memcpy (fValueBuffer, fDefaultValues, iNbElements * sizeof (double));
311
312 double *fValuesList = g_key_file_get_double_list (pKeyFile, cGroupName, cKeyName, &length, &erreur);
313 if (erreur != NULL)
314 {
315 if (bFlushConfFileNeeded != NULL)
316 cd_warning (erreur->message);
317 g_error_free (erreur);
318 erreur = NULL;
319
320 gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
321 fValuesList = g_key_file_get_double_list (pKeyFile, cGroupNameUpperCase, cKeyName, &length, &erreur);
322 if (erreur != NULL)
323 {
324 g_error_free (erreur);
325 erreur = NULL;
326 fValuesList = g_key_file_get_double_list (pKeyFile, "Cairo Dock", cKeyName, &length, &erreur);
327 if (erreur != NULL)
328 {
329 g_error_free (erreur);
330 erreur = NULL;
331 fValuesList = g_key_file_get_double_list (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), &length, &erreur);
332 if (erreur != NULL)
333 {
334 g_error_free (erreur);
335 }
336 else
337 {
338 cd_message (" (recuperee)");
339 if (length > 0)
340 memcpy (fValueBuffer, fValuesList, MIN (iNbElements, length) * sizeof (double));
341 }
342 }
343 else
344 {
345 cd_message (" (recuperee)");
346 if (length > 0)
347 memcpy (fValueBuffer, fValuesList, MIN (iNbElements, length) * sizeof (double));
348 }
349 }
350 else
351 {
352 if (length > 0)
353 memcpy (fValueBuffer, fValuesList, MIN (iNbElements, length) * sizeof (double));
354 }
355 g_free (cGroupNameUpperCase);
356
357 g_key_file_set_double_list (pKeyFile, cGroupName, cKeyName, fValueBuffer, iNbElements);
358 if (bFlushConfFileNeeded != NULL)
359 *bFlushConfFileNeeded = TRUE;
360 }
361 else
362 {
363 if (length > 0)
364 memcpy (fValueBuffer, fValuesList, MIN (iNbElements, length) * sizeof (double));
365 }
366 g_free (fValuesList);
367 }
368
cairo_dock_get_color_key_value(GKeyFile * pKeyFile,const gchar * cGroupName,const gchar * cKeyName,gboolean * bFlushConfFileNeeded,GldiColor * fValueBuffer,GldiColor * fDefaultValues,const gchar * cDefaultGroupName,const gchar * cDefaultKeyName)369 void cairo_dock_get_color_key_value (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cKeyName, gboolean *bFlushConfFileNeeded, GldiColor *fValueBuffer, GldiColor *fDefaultValues, const gchar *cDefaultGroupName, const gchar *cDefaultKeyName)
370 {
371 fValueBuffer->rgba.alpha = 1.; // in case it's an RGB color in conf
372 cairo_dock_get_double_list_key_value (pKeyFile, cGroupName, cKeyName, bFlushConfFileNeeded, (double*)&fValueBuffer->rgba, 4, (double*)&fDefaultValues->rgba, cDefaultGroupName, cDefaultKeyName);
373 }
374
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)375 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)
376 {
377 GError *erreur = NULL;
378 *length = 0;
379 gchar **cValuesList = g_key_file_get_string_list (pKeyFile, cGroupName, cKeyName, length, &erreur);
380 if (erreur != NULL)
381 {
382 if (bFlushConfFileNeeded != NULL)
383 cd_warning (erreur->message);
384 g_error_free (erreur);
385 erreur = NULL;
386
387 gchar* cGroupNameUpperCase = g_ascii_strup (cGroupName, -1);
388 cValuesList = g_key_file_get_string_list (pKeyFile, cGroupNameUpperCase, cKeyName, length, &erreur);
389 if (erreur != NULL)
390 {
391 g_error_free (erreur);
392 erreur = NULL;
393 cValuesList = g_key_file_get_string_list (pKeyFile, (cDefaultGroupName != NULL ? cDefaultGroupName : cGroupName), (cDefaultKeyName != NULL ? cDefaultKeyName : cKeyName), length, &erreur);
394 if (erreur != NULL)
395 {
396 g_error_free (erreur);
397 cValuesList = g_strsplit (cDefaultValues, ";", -1); // "" -> NULL.
398 int i = 0;
399 if (cValuesList != NULL)
400 {
401 while (cValuesList[i] != NULL)
402 i ++;
403 }
404 *length = i;
405 }
406 }
407 g_free (cGroupNameUpperCase);
408
409 if (*length > 0)
410 g_key_file_set_string_list (pKeyFile, cGroupName, cKeyName, (const gchar **)cValuesList, *length);
411 else
412 g_key_file_set_string (pKeyFile, cGroupName, cKeyName, "");
413 if (bFlushConfFileNeeded != NULL)
414 *bFlushConfFileNeeded = TRUE;
415 }
416 if (cValuesList != NULL && (cValuesList[0] == NULL || (*(cValuesList[0]) == '\0' && *length == 1)))
417 {
418 g_strfreev (cValuesList);
419 cValuesList = NULL;
420 *length = 0;
421 }
422 return cValuesList;
423 }
424
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)425 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)
426 {
427 gchar *cFileName = cairo_dock_get_string_key_value (pKeyFile, cGroupName, cKeyName, bFlushConfFileNeeded, NULL, cDefaultGroupName, cDefaultKeyName);
428 gchar *cFilePath = NULL;
429 if (cFileName != NULL)
430 cFilePath = cairo_dock_search_image_s_path (cFileName);
431 if (cFilePath == NULL && cDefaultFileName != NULL && cDefaultDir != NULL) // pas d'image specifiee, ou image introuvable => on prend l'image par defaut fournie.
432 cFilePath = g_strdup_printf ("%s/%s", cDefaultDir, cDefaultFileName);
433 g_free (cFileName);
434 return cFilePath;
435 }
436
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)437 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)
438 {
439 int iSize[2];
440 int iDefaultValues[2] = {iDefaultSize, iDefaultSize};
441 cairo_dock_get_integer_list_key_value (pKeyFile, cGroupName, cKeyName, bFlushConfFileNeeded, iSize, 2, iDefaultValues, cDefaultGroupName, cDefaultKeyName);
442 *iWidth = iSize[0];
443 *iHeight = iSize[1];
444 }
445
446
cairo_dock_load_current_theme(void)447 void cairo_dock_load_current_theme (void)
448 {
449 cd_message ("%s ()", __func__);
450 s_bLoading = TRUE;
451
452 //\___________________ Free everything.
453 gldi_free_all (); // do nothing if there is nothing to unload.
454
455 //\___________________ Get all managers config.
456 gldi_managers_get_config (g_cConfFile, GLDI_VERSION); /// en fait, CAIRO_DOCK_VERSION ...
457
458 //\___________________ Create the primary container (needed to have a cairo/opengl context).
459 CairoDock *pMainDock = gldi_dock_new (CAIRO_DOCK_MAIN_DOCK_NAME);
460
461 //\___________________ Load all managers data.
462 gldi_managers_load ();
463 gldi_modules_activate_from_list (NULL); // load auto-loaded modules before loading anything (views, etc)
464
465 //\___________________ Now load the user icons (launchers, etc).
466 gldi_user_icons_new_from_directory (g_cCurrentLaunchersPath);
467
468 cairo_dock_hide_show_launchers_on_other_desktops ();
469
470 //\___________________ Load the applets.
471 gldi_modules_activate_from_list (myModulesParam.cActiveModuleList);
472
473 //\___________________ Start the applications manager (will load the icons if the option is enabled).
474 cairo_dock_start_applications_manager (pMainDock);
475
476 s_bLoading = FALSE;
477 }
478
479
cairo_dock_is_loading(void)480 gboolean cairo_dock_is_loading (void)
481 {
482 return s_bLoading;
483 }
484
485
486
cairo_dock_decrypt_string(const gchar * cEncryptedString,gchar ** cDecryptedString)487 void cairo_dock_decrypt_string( const gchar *cEncryptedString, gchar **cDecryptedString )
488 {
489 g_return_if_fail (cDecryptedString != NULL);
490 if( !cEncryptedString || *cEncryptedString == '\0' )
491 {
492 *cDecryptedString = g_strdup( "" );
493 return;
494 }
495 #ifdef HAVE_LIBCRYPT
496 guchar *input = (guchar *)g_strdup (cEncryptedString);
497 guchar *shifted_input = input;
498 guchar **output = (guchar **)cDecryptedString;
499
500 guchar *current_output = NULL;
501
502 *output = g_malloc( (strlen((char *)input)+1)/3+1 );
503 current_output = *output;
504
505 guchar *last_char_in_input = input + strlen((char *)input);
506 // g_print( "Password (before decrypt): %s\n", input );
507
508 for( ; shifted_input < last_char_in_input; shifted_input += 16+8, current_output += 8 )
509 {
510 guint block[8];
511 guchar txt[64];
512 gint i = 0, j = 0;
513
514 memset( txt, 0, 64 );
515
516 shifted_input[16+8-1] = 0; // cut the string
517
518 sscanf( (char *)shifted_input, "%X-%X-%X-%X-%X-%X-%X-%X",
519 &block[0], &block[1], &block[2], &block[3], &block[4], &block[5], &block[6], &block[7] );
520
521 // process the eight first characters of "input"
522 for( i = 0; i < 8 ; i++ )
523 for ( j = 0; j < 8; j++ )
524 txt[i*8+j] = block[i] >> j & 1;
525
526 setkey( DES_crypt_key );
527 encrypt( (gchar *)txt, 1 ); // decrypt
528
529 for ( i = 0; i < 8; i++ )
530 {
531 current_output[i] = 0;
532 for ( j = 0; j < 8; j++ )
533 {
534 current_output[i] |= txt[i*8+j] << j;
535 }
536 }
537 }
538
539 *current_output = 0;
540
541 // g_print( "Password (after decrypt): %s\n", *output );
542
543 g_free( input );
544
545 #else
546 *cDecryptedString = g_strdup( cEncryptedString );
547 #endif
548 }
549
cairo_dock_encrypt_string(const gchar * cDecryptedString,gchar ** cEncryptedString)550 void cairo_dock_encrypt_string( const gchar *cDecryptedString, gchar **cEncryptedString )
551 {
552 g_return_if_fail (cEncryptedString != NULL);
553 if( !cDecryptedString || *cDecryptedString == '\0' )
554 {
555 *cEncryptedString = g_strdup( "" );
556 return;
557 }
558
559 #ifdef HAVE_LIBCRYPT
560 const guchar *input = (guchar *)cDecryptedString;
561 guchar **output = (guchar **)cEncryptedString;
562
563 guchar *current_output = NULL;
564 // for each block of 8 characters, we need 24 bytes.
565 guint nbBlocks = strlen((char *)input)/8+1;
566 *output = g_malloc( nbBlocks*24+1 );
567 current_output = *output;
568
569 const guchar *last_char_in_input = input + strlen((char *)input);
570
571 // g_print( "Password (before encrypt): %s\n", input );
572
573 for( ; input < last_char_in_input; input += 8, current_output += 16+8 )
574 {
575 guchar txt[64];
576 guint i = 0, j = 0;
577 guchar current_letter = 0;
578
579 memset( txt, 0, 64 );
580
581 // process the eight first characters of "input"
582 for( i = 0; i < strlen((char *)input) && i < 8 ; i++ )
583 for ( j = 0; j < 8; j++ )
584 txt[i*8+j] = input[i] >> j & 1;
585
586 setkey( DES_crypt_key );
587 encrypt( (char *)txt, 0 ); // encrypt
588
589 for ( i = 0; i < 8; i++ )
590 {
591 current_letter = 0;
592 for ( j = 0; j < 8; j++ )
593 {
594 current_letter |= txt[i*8+j] << j;
595 }
596 snprintf( (char *)current_output + i*3, 4, "%02X-", current_letter );
597 }
598 }
599
600 *(current_output-1) = 0;
601
602 // g_print( "Password (after encrypt): %s\n", *output );
603 #else
604 *cEncryptedString = g_strdup( cDecryptedString );
605 #endif
606 }
607
608
cairo_dock_open_xml_file(const gchar * cDataFilePath,const gchar * cRootNodeName,xmlNodePtr * root_node,GError ** erreur)609 xmlDocPtr cairo_dock_open_xml_file (const gchar *cDataFilePath, const gchar *cRootNodeName, xmlNodePtr *root_node, GError **erreur)
610 {
611 if (cairo_dock_get_file_size (cDataFilePath) == 0)
612 {
613 g_set_error (erreur, 1, 1, "file '%s' doesn't exist or is empty", cDataFilePath);
614 *root_node = NULL;
615 return NULL;
616 }
617 xmlInitParser ();
618
619 xmlDocPtr doc = xmlParseFile (cDataFilePath);
620 if (doc == NULL)
621 {
622 g_set_error (erreur, 1, 1, "file '%s' is incorrect", cDataFilePath);
623 *root_node = NULL;
624 return NULL;
625 }
626
627 xmlNodePtr noeud = xmlDocGetRootElement (doc);
628 if (noeud == NULL || xmlStrcmp (noeud->name, (const xmlChar *) cRootNodeName) != 0)
629 {
630 g_set_error (erreur, 1, 2, "xml file '%s' is not well formed", cDataFilePath);
631 *root_node = NULL;
632 return doc;
633 }
634 *root_node = noeud;
635 return doc;
636 }
637
cairo_dock_close_xml_file(xmlDocPtr doc)638 void cairo_dock_close_xml_file (xmlDocPtr doc)
639 {
640 if (doc)
641 xmlFreeDoc (doc); // ne pas utiliser xmlCleanupParser(), cela peut affecter les autres threads utilisant libxml !
642 }
643