fix a couple of memory leaks
[claws.git] / src / prefs_gtk.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2012 Hiroyuki Yamamoto and the Claws Mail team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  * 
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #include "claws-features.h"
23 #endif
24
25 #define _GNU_SOURCE
26 #include <stdio.h>
27
28 #include <glib.h>
29 #include <glib/gi18n.h>
30 #include <gtk/gtk.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include <errno.h>
35
36 #include "defs.h"
37 #include "main.h"
38 #include "prefs.h"
39 #include "prefs_gtk.h"
40 #include "prefs_common.h"
41 #include "utils.h"
42 #include "gtkutils.h"
43 #include "passcrypt.h"
44 #include "codeconv.h"
45
46 #define CL(x)   (((gulong) (x) >> (gulong) 8) & 0xFFUL)
47 #define RGB_FROM_GDK_COLOR(c) \
48         ((CL(c.red)   << (gulong) 16) | \
49          (CL(c.green) << (gulong)  8) | \
50          (CL(c.blue)))
51
52 #ifdef HAVE_FGETS_UNLOCKED
53 #define SC_FGETS fgets_unlocked
54 #else
55 #define SC_FGETS fgets
56 #endif
57
58 typedef enum
59 {
60         DUMMY_PARAM
61 } DummyEnum;
62
63 static GHashTable *whole_cache = NULL;
64
65 static gboolean prefs_read_config_from_cache(PrefParam *param, const gchar *label,
66                                const gchar *rcfile);
67
68 static void prefs_config_parse_one_line(PrefParam       *param,
69                                          const gchar    *buf);
70
71 void prefs_read_config(PrefParam *param, const gchar *label,
72                        const gchar *rcfile, const gchar *encoding)
73 {
74         FILE *fp;
75         gchar buf[PREFSBUFSIZE];
76         gchar *block_label;
77
78         cm_return_if_fail(param != NULL);
79         cm_return_if_fail(label != NULL);
80         cm_return_if_fail(rcfile != NULL);
81
82         if (encoding != NULL)
83                 g_warning("Encoding is ignored\n");
84
85         debug_print("Reading configuration...\n");
86
87         prefs_set_default(param);
88
89         if (whole_cache != NULL) {
90                 if (prefs_read_config_from_cache(param, label, rcfile) == TRUE)
91                         return;
92         }
93
94         if ((fp = g_fopen(rcfile, "rb")) == NULL) {
95                 if (ENOENT != errno) FILE_OP_ERROR(rcfile, "fopen");
96                 return;
97         }
98
99         block_label = g_strdup_printf("[%s]", label);
100
101 #ifdef HAVE_FGETS_UNLOCKED
102         flockfile(fp);
103 #endif
104
105         /* search aiming block */
106         while (SC_FGETS(buf, sizeof(buf), fp) != NULL) {
107                 gint val;
108
109                 if (encoding) {
110                         gchar *conv_str;
111
112                         conv_str = conv_codeset_strdup
113                                 (buf, encoding, CS_INTERNAL);
114                         if (!conv_str)
115                                 conv_str = g_strdup(buf);
116                         val = strncmp
117                                 (conv_str, block_label, strlen(block_label));
118                         g_free(conv_str);
119                 } else
120                         val = strncmp(buf, block_label, strlen(block_label));
121                 if (val == 0) {
122                         debug_print("Found %s\n", block_label);
123                         break;
124                 }
125         }
126         g_free(block_label);
127
128         while (SC_FGETS(buf, sizeof(buf), fp) != NULL) {
129                 strretchomp(buf);
130                 /* reached next block */
131                 if (buf[0] == '[') break;
132                 if (buf[0] == '#') continue;
133
134                 if (encoding) {
135                         gchar *conv_str;
136
137                         conv_str = conv_codeset_strdup
138                                 (buf, encoding, CS_INTERNAL);
139                         if (!conv_str)
140                                 conv_str = g_strdup(buf);
141                         prefs_config_parse_one_line(param, conv_str);
142                         g_free(conv_str);
143                 } else
144                         prefs_config_parse_one_line(param, buf);
145         }
146
147         debug_print("Finished reading configuration.\n");
148 #ifdef HAVE_FGETS_UNLOCKED
149         funlockfile(fp);
150 #endif
151         fclose(fp);
152 }
153
154 static void prefs_config_parse_one_line(PrefParam *param, const gchar *buf)
155 {
156         gint i;
157         gint name_len;
158         const gchar *value;
159         GdkColor color;
160
161         for (i = 0; param[i].name != NULL; i++) {
162                 name_len = strlen(param[i].name);
163                 if (g_ascii_strncasecmp(buf, param[i].name, name_len))
164                         continue;
165                 if (buf[name_len] != '=')
166                         continue;
167                 value = buf + name_len + 1;
168                 /* debug_print("%s = %s\n", param[i].name, value); */
169
170                 switch (param[i].type) {
171                 case P_STRING:
172                 {
173                         gchar *tmp = NULL;
174
175                         if (*value) {
176                                 if (g_utf8_validate(value, -1, NULL))
177                                         tmp = g_strdup(value);
178                                 else {
179                                         tmp = conv_codeset_strdup(value,
180                                                     conv_get_locale_charset_str_no_utf8(),
181                                                     CS_INTERNAL);
182                                 }
183                         } else {
184                                 tmp = g_strdup("");
185                         }
186                         if (!tmp) {
187                                 g_warning("Failed to convert character set.");
188                                 tmp = g_strdup(value);
189                         }
190                         g_free(*((gchar **)param[i].data));
191                         *((gchar **)param[i].data) = tmp;
192                         break;
193                 }
194                 case P_INT:
195                         *((gint *)param[i].data) =
196                                 (gint)atoi(value);
197                         break;
198                 case P_BOOL:
199                         *((gboolean *)param[i].data) =
200                                 (*value == '0' || *value == '\0')
201                                         ? FALSE : TRUE;
202                         break;
203                 case P_ENUM:
204                         *((DummyEnum *)param[i].data) =
205                                 (DummyEnum)atoi(value);
206                         break;
207                 case P_USHORT:
208                         *((gushort *)param[i].data) =
209                                 (gushort)atoi(value);
210                         break;
211                 case P_COLOR:
212                         if (gdk_color_parse(value, &color)) {
213                                 *((gulong *)param[i].data) = RGB_FROM_GDK_COLOR(color); 
214                         }
215                         else 
216                                 /* be compatible and accept ints */
217                                 *((gulong *)param[i].data) = strtoul(value, 0, 10); 
218                         break;
219                 case P_PASSWORD:
220                         g_free(*((gchar **)param[i].data));
221                         if (value[0] == '!') {
222                                 gchar *tmp, buf[1024];
223                                 gsize len;
224
225                                 tmp = g_base64_decode(&value[1], &len);
226                                 g_strlcat(buf, tmp, 1024);
227                                 g_free(tmp);
228                                 buf[len] = '\0';
229                                 passcrypt_decrypt(buf, len);
230                                 *((gchar **)param[i].data) =
231                                         *buf ? g_strdup(buf) : NULL;
232                         } else {
233                                 *((gchar **)param[i].data) =
234                                         *value ? g_strdup(value) : NULL;
235                         }
236                         break;
237                 default:
238                         break;
239                 }
240         }
241 }
242
243 #define TRY(func) \
244 if (!(func)) \
245 { \
246         g_warning("Failed to write configuration to file\n"); \
247         if (orig_fp) fclose(orig_fp); \
248         prefs_file_close_revert(pfile); \
249         g_free(rcpath); \
250         g_free(block_label); \
251         return; \
252 } \
253
254 void prefs_write_config(PrefParam *param, const gchar *label,
255                         const gchar *rcfile)
256 {
257         FILE *orig_fp;
258         PrefFile *pfile;
259         gchar *rcpath;
260         gchar buf[PREFSBUFSIZE];
261         gchar *block_label = NULL;
262         gboolean block_matched = FALSE;
263
264         cm_return_if_fail(param != NULL);
265         cm_return_if_fail(label != NULL);
266         cm_return_if_fail(rcfile != NULL);
267
268         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, rcfile, NULL);
269         if ((orig_fp = g_fopen(rcpath, "rb")) == NULL) {
270                 if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
271         }
272
273         if ((pfile = prefs_write_open(rcpath)) == NULL) {
274                 g_warning("Failed to write configuration to file\n");
275                 if (orig_fp) fclose(orig_fp);
276                 g_free(rcpath);
277                 return;
278         }
279
280         block_label = g_strdup_printf("[%s]", label);
281
282         /* search aiming block */
283         if (orig_fp) {
284                 while (fgets(buf, sizeof(buf), orig_fp) != NULL) {
285                         gint val;
286
287                         val = strncmp(buf, block_label, strlen(block_label));
288                         if (val == 0) {
289                                 debug_print("Found %s\n", block_label);
290                                 block_matched = TRUE;
291                                 break;
292                         } else
293                                 TRY(fputs(buf, pfile->fp) != EOF);
294                 }
295         }
296
297         TRY(fprintf(pfile->fp, "%s\n", block_label) > 0);
298
299         /* write all param data to file */
300         TRY(prefs_write_param(param, pfile->fp) == 0);
301
302         if (block_matched) {
303                 gboolean in_dup_block = FALSE;
304                 while (fgets(buf, sizeof(buf), orig_fp) != NULL) {
305                         /* next block */
306                         if (buf[0] == '[') {
307                                 TRY(fputc('\n', pfile->fp) != EOF &&
308                                     fputs(buf, pfile->fp)  != EOF);
309                                 break;
310                         }
311                 }
312                 while (fgets(buf, sizeof(buf), orig_fp) != NULL) {
313                         if (buf[0] == '[') {
314                                 if (!strncmp(buf, block_label,
315                                                 strlen(block_label)))
316                                         in_dup_block = TRUE;
317                                 else
318                                         in_dup_block = FALSE;
319                         }
320                         if (!in_dup_block)
321                                 TRY(fputs(buf, pfile->fp) != EOF);
322                 }
323         }
324
325         g_free(block_label);
326         block_label = NULL;
327
328         if (orig_fp) fclose(orig_fp);
329         if (prefs_file_close(pfile) < 0)
330                 g_warning("Failed to write configuration to file\n");
331         g_free(rcpath);
332
333         debug_print("Configuration is saved.\n");
334 }
335
336 gint prefs_write_param(PrefParam *param, FILE *fp)
337 {
338         gint i;
339         gchar buf[PREFSBUFSIZE];
340
341         for (i = 0; param[i].name != NULL; i++) {
342                 switch (param[i].type) {
343                 case P_STRING:
344                 {
345                         gchar *tmp = NULL;
346
347                         if (*((gchar **)param[i].data)) {
348                                 if (g_utf8_validate(*((gchar **)param[i].data), -1, NULL))
349                                         tmp = g_strdup(*((gchar **)param[i].data));
350                                 else {
351                                         tmp = conv_codeset_strdup(*((gchar **)param[i].data),
352                                                 conv_get_locale_charset_str_no_utf8(),
353                                                 CS_INTERNAL);
354                                         if (!tmp)
355                                                 tmp = g_strdup(*((gchar **)param[i].data));
356                                 }
357                         }
358
359                         g_snprintf(buf, sizeof(buf), "%s=%s\n", param[i].name,
360                                    tmp ? tmp : "");
361
362                         g_free(tmp);
363                         break;
364                 }
365                 case P_INT:
366                         g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
367                                    *((gint *)param[i].data));
368                         break;
369                 case P_BOOL:
370                         g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
371                                    *((gboolean *)param[i].data));
372                         break;
373                 case P_ENUM:
374                         g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
375                                    *((DummyEnum *)param[i].data));
376                         break;
377                 case P_USHORT:
378                         g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
379                                    *((gushort *)param[i].data));
380                         break;
381                 case P_COLOR:
382                         g_snprintf(buf, sizeof buf,  "%s=#%6.6lx\n", param[i].name,
383                                    *((gulong *) param[i].data));
384                         break;
385                 case P_PASSWORD:
386                         {
387                                 gchar *tmp = NULL, *tmp2 = NULL;
388
389                                 tmp = *((gchar **)param[i].data);
390                                 if (tmp) {
391                                         gint len;
392
393                                         tmp = g_strdup(tmp);
394                                         len = strlen(tmp);
395                                         passcrypt_encrypt(tmp, len);
396                                         tmp2 = g_base64_encode(tmp, len);
397                                         g_free(tmp);
398                                         tmp = tmp2;
399                                 }
400                                 g_snprintf(buf, sizeof(buf), "%s=!%s\n", param[i].name,
401                                            tmp ?
402                                            tmp : "");
403                                 g_free(tmp);
404                         }
405                         break;
406                 default:
407                         /* unrecognized, fail */
408                         debug_print("Unrecognized parameter type\n");
409                         return -1;
410                 }
411
412                 if (buf[0] != '\0') {
413                         if (fputs(buf, fp) == EOF) {
414                                 perror("fputs");
415                                 return -1;
416                         }
417                 }
418         }
419
420         return 0;
421 }
422
423 void prefs_set_default(PrefParam *param)
424 {
425         gint i;
426         GdkColor color;
427
428         cm_return_if_fail(param != NULL);
429
430         for (i = 0; param[i].name != NULL; i++) {
431                 if (!param[i].data) continue;
432
433                 switch (param[i].type) {
434                 case P_STRING:
435                         g_free(*((gchar **)param[i].data));
436                         if (param[i].defval != NULL) {
437                                 if (!strncasecmp(param[i].defval, "ENV_", 4)) {
438                                         const gchar *envstr;
439                                         gchar *tmp;
440
441                                         envstr = g_getenv(param[i].defval + 4);
442                                         tmp = envstr && *envstr ?
443                                                 conv_codeset_strdup(envstr,
444                                                                     conv_get_locale_charset_str(),
445                                                                     CS_INTERNAL)
446                                                 : g_strdup("");
447                                         if (!tmp) {
448                                                 g_warning("Failed to convert character set.");
449                                                 tmp = g_strdup(envstr);
450                                         }
451                                         *((gchar **)param[i].data) = tmp;
452                                 } else if (param[i].defval[0] == '~')
453                                         *((gchar **)param[i].data) =
454                                                 g_strconcat(get_home_dir(),
455                                                             param[i].defval + 1,
456                                                             NULL);
457                                 else 
458                                         *((gchar **)param[i].data) =
459                                                 g_strdup(param[i].defval);
460                         } else
461                                 *((gchar **)param[i].data) = NULL;
462                         break;
463                 case P_PASSWORD:
464                         g_free(*((gchar **)param[i].data));
465                         if (param[i].defval != NULL) {
466                                 if (param[i].defval[0] != '\0')
467                                         *((gchar **)param[i].data) =
468                                                 g_strdup(param[i].defval);
469                                 else
470                                         *((gchar **)param[i].data) = NULL;
471                         } else
472                                 *((gchar **)param[i].data) = NULL;
473                         break;
474                 case P_INT:
475                         if (param[i].defval != NULL)
476                                 *((gint *)param[i].data) =
477                                         (gint)atoi(param[i].defval);
478                         else
479                                 *((gint *)param[i].data) = 0;
480                         break;
481                 case P_BOOL:
482                         if (param[i].defval != NULL) {
483                                 if (!g_ascii_strcasecmp(param[i].defval, "TRUE"))
484                                         *((gboolean *)param[i].data) = TRUE;
485                                 else
486                                         *((gboolean *)param[i].data) =
487                                                 atoi(param[i].defval) ? TRUE : FALSE;
488                         } else
489                                 *((gboolean *)param[i].data) = FALSE;
490                         break;
491                 case P_ENUM:
492                         if (param[i].defval != NULL)
493                                 *((DummyEnum*)param[i].data) =
494                                         (DummyEnum)atoi(param[i].defval);
495                         else
496                                 *((DummyEnum *)param[i].data) = 0;
497                         break;
498                 case P_USHORT:
499                         if (param[i].defval != NULL)
500                                 *((gushort *)param[i].data) =
501                                         (gushort)atoi(param[i].defval);
502                         else
503                                 *((gushort *)param[i].data) = 0;
504                         break;
505                 case P_COLOR:
506                         if (param[i].defval != NULL && gdk_color_parse(param[i].defval, &color))
507                                 *((gulong *)param[i].data) =
508                                         RGB_FROM_GDK_COLOR(color);
509                         else if (param[i].defval)
510                                 /* be compatible and accept ints */
511                                 *((gulong *)param[i].data) = strtoul(param[i].defval, 0, 10); 
512                         else
513                                 *((gulong *)param[i].data) = 0; 
514                         break;
515                 default:
516                         break;
517                 }
518         }
519 }
520
521 void prefs_free(PrefParam *param)
522 {
523         gint i;
524
525         cm_return_if_fail(param != NULL);
526
527         for (i = 0; param[i].name != NULL; i++) {
528                 if (!param[i].data) continue;
529
530                 switch (param[i].type) {
531                 case P_STRING:
532                 case P_PASSWORD:
533                         g_free(*((gchar **)param[i].data));
534                         break;
535                 default:
536                         break;
537                 }
538         }
539 }
540
541 void prefs_button_toggled(GtkToggleButton *toggle_btn, GtkWidget *widget)
542 {
543         gboolean is_active;
544
545         is_active = gtk_toggle_button_get_active(toggle_btn);
546         gtk_widget_set_sensitive(widget, is_active);
547 }
548
549 void prefs_button_toggled_reverse(GtkToggleButton *toggle_btn, GtkWidget *widget)
550 {
551         gboolean is_active;
552
553         is_active = gtk_toggle_button_get_active(toggle_btn);
554         gtk_widget_set_sensitive(widget, !is_active);
555 }
556
557 void prefs_set_dialog(PrefParam *param)
558 {
559         gint i;
560
561         for (i = 0; param[i].name != NULL; i++) {
562                 if (param[i].widget_set_func)
563                         param[i].widget_set_func(&param[i]);
564         }
565 }
566
567 void prefs_set_data_from_dialog(PrefParam *param)
568 {
569         gint i;
570
571         for (i = 0; param[i].name != NULL; i++) {
572                 if (param[i].data_set_func)
573                         param[i].data_set_func(&param[i]);
574         }
575 }
576
577 void prefs_set_dialog_to_default(PrefParam *param)
578 {
579         gint       i;
580         PrefParam  tmpparam;
581         gchar     *str_data = NULL;
582         gint       int_data;
583         gushort    ushort_data;
584         gboolean   bool_data;
585         DummyEnum  enum_data;
586
587         for (i = 0; param[i].name != NULL; i++) {
588                 if (!param[i].widget_set_func) continue;
589
590                 tmpparam = param[i];
591
592                 switch (tmpparam.type) {
593                 case P_STRING:
594                         if (tmpparam.defval) {
595                                 if (!g_ascii_strncasecmp(tmpparam.defval, "ENV_", 4)) {
596                                         str_data = g_strdup(g_getenv(param[i].defval + 4));
597                                         tmpparam.data = &str_data;
598                                         break;
599                                 } else if (tmpparam.defval[0] == '~') {
600                                         str_data =
601                                                 g_strconcat(get_home_dir(),
602                                                             param[i].defval + 1,
603                                                             NULL);
604                                         tmpparam.data = &str_data;
605                                         break;
606                                 }
607                         }
608                         tmpparam.data = &tmpparam.defval;
609                         break;
610                 case P_PASSWORD:
611                         tmpparam.data = &tmpparam.defval;
612                         break;
613                 case P_INT:
614                         if (tmpparam.defval)
615                                 int_data = atoi(tmpparam.defval);
616                         else
617                                 int_data = 0;
618                         tmpparam.data = &int_data;
619                         break;
620                 case P_USHORT:
621                         if (tmpparam.defval)
622                                 ushort_data = atoi(tmpparam.defval);
623                         else
624                                 ushort_data = 0;
625                         tmpparam.data = &ushort_data;
626                         break;
627                 case P_BOOL:
628                         if (tmpparam.defval) {
629                                 if (!g_ascii_strcasecmp(tmpparam.defval, "TRUE"))
630                                         bool_data = TRUE;
631                                 else
632                                         bool_data = atoi(tmpparam.defval)
633                                                 ? TRUE : FALSE;
634                         } else
635                                 bool_data = FALSE;
636                         tmpparam.data = &bool_data;
637                         break;
638                 case P_ENUM:
639                         if (tmpparam.defval)
640                                 enum_data = (DummyEnum)atoi(tmpparam.defval);
641                         else
642                                 enum_data = 0;
643                         tmpparam.data = &enum_data;
644                         break;
645                 case P_OTHER:
646                 default:
647                         break;
648                 }
649                 tmpparam.widget_set_func(&tmpparam);
650                 g_free(str_data);
651                 str_data = NULL;
652         }
653 }
654
655 void prefs_set_data_from_entry(PrefParam *pparam)
656 {
657         gchar **str;
658         const gchar *entry_str;
659
660         cm_return_if_fail(*pparam->widget != NULL);
661
662         entry_str = gtk_entry_get_text(GTK_ENTRY(*pparam->widget));
663
664         switch (pparam->type) {
665         case P_STRING:
666         case P_PASSWORD:
667                 str = (gchar **)pparam->data;
668                 g_free(*str);
669                 *str = entry_str[0] ? g_strdup(entry_str) : NULL;
670                 break;
671         case P_USHORT:
672                 *((gushort *)pparam->data) = atoi(entry_str);
673                 break;
674         case P_INT:
675                 *((gint *)pparam->data) = atoi(entry_str);
676                 break;
677         default:
678                 g_warning("Invalid PrefType for GtkEntry widget: %d\n",
679                           pparam->type);
680         }
681 }
682
683 void prefs_set_escaped_data_from_entry(PrefParam *pparam)
684 {
685         gchar **str;
686
687         cm_return_if_fail(*pparam->widget != NULL);
688
689         switch (pparam->type) {
690         case P_STRING:
691                 str = (gchar **)pparam->data;
692                 g_free(*str);
693                 *str = pref_get_pref_from_entry(GTK_ENTRY(*pparam->widget));
694                 break;
695         default:
696                 g_warning("Invalid escaped PrefType for GtkEntry widget: %d\n",
697                           pparam->type);
698         }
699 }
700
701 void prefs_set_entry(PrefParam *pparam)
702 {
703         gchar **str;
704
705         cm_return_if_fail(*pparam->widget != NULL);
706
707         switch (pparam->type) {
708         case P_STRING:
709         case P_PASSWORD:
710                 str = (gchar **)pparam->data;
711                 gtk_entry_set_text(GTK_ENTRY(*pparam->widget),
712                                    *str ? *str : "");
713                 break;
714         case P_INT:
715                 gtk_entry_set_text(GTK_ENTRY(*pparam->widget),
716                                    itos(*((gint *)pparam->data)));
717                 break;
718         case P_USHORT:
719                 gtk_entry_set_text(GTK_ENTRY(*pparam->widget),
720                                    itos(*((gushort *)pparam->data)));
721                 break;
722         default:
723                 g_warning("Invalid PrefType for GtkEntry widget: %d\n",
724                           pparam->type);
725         }
726 }
727
728 void prefs_set_entry_from_escaped(PrefParam *pparam)
729 {
730         gchar **str;
731
732         cm_return_if_fail(*pparam->widget != NULL);
733
734         switch (pparam->type) {
735         case P_STRING:
736                 str = (gchar **)pparam->data;
737                 pref_set_entry_from_pref(GTK_ENTRY(*pparam->widget),
738                                    *str ? *str : "");
739                 break;
740         default:
741                 g_warning("Invalid escaped PrefType for GtkEntry widget: %d\n",
742                           pparam->type);
743         }
744 }
745
746 void prefs_set_data_from_text(PrefParam *pparam)
747 {
748         gchar **str;
749         gchar *text = NULL, *tp = NULL;
750         gchar *tmp, *tmpp;
751
752         cm_return_if_fail(*pparam->widget != NULL);
753
754         switch (pparam->type) {
755         case P_STRING:
756         case P_PASSWORD:
757                 str = (gchar **)pparam->data;
758                 g_free(*str);
759                 if (GTK_IS_EDITABLE(*pparam->widget)) {   /* need? */
760                         tp = text = gtk_editable_get_chars
761                                         (GTK_EDITABLE(*pparam->widget), 0, -1);
762                 } else if (GTK_IS_TEXT_VIEW(*pparam->widget)) {
763                         GtkTextView *textview = GTK_TEXT_VIEW(*pparam->widget);
764                         GtkTextBuffer *buffer = gtk_text_view_get_buffer(textview);
765                         GtkTextIter start, end;
766                         gtk_text_buffer_get_start_iter(buffer, &start);
767                         gtk_text_buffer_get_iter_at_offset(buffer, &end, -1);
768                         tp = text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
769                 }
770
771                 cm_return_if_fail (tp && text);
772
773                 if (text[0] == '\0') {
774                         *str = NULL;
775                         g_free(text);
776                         break;
777                 }
778
779                 Xalloca(tmpp = tmp, strlen(text) * 2 + 1,
780                         { *str = NULL; break; });
781                 while (*tp) {
782                         if (*tp == '\n') {
783                                 *tmpp++ = '\\';
784                                 *tmpp++ = 'n';
785                                 tp++;
786                         } else
787                                 *tmpp++ = *tp++;
788                 }
789                 *tmpp = '\0';
790                 *str = g_strdup(tmp);
791                 g_free(text);
792                 break;
793         default:
794                 g_warning("Invalid PrefType for GtkText widget: %d\n",
795                           pparam->type);
796         }
797 }
798
799 void prefs_set_escaped_data_from_text(PrefParam *pparam)
800 {
801         gchar **str;
802
803         cm_return_if_fail(*pparam->widget != NULL);
804
805         switch (pparam->type) {
806         case P_STRING:
807                 str = (gchar **)pparam->data;
808                 g_free(*str);
809                 *str = pref_get_pref_from_textview(GTK_TEXT_VIEW(*pparam->widget));
810                 break;
811         default:
812                 g_warning("Invalid escaped PrefType for GtkText widget: %d\n",
813                           pparam->type);
814         }
815 }
816
817 void prefs_set_text(PrefParam *pparam)
818 {
819         gchar *buf, *sp, *bufp;
820         gchar **str;
821         GtkTextView *text;
822         GtkTextBuffer *buffer;
823         GtkTextIter iter;
824
825         cm_return_if_fail(*pparam->widget != NULL);
826
827         switch (pparam->type) {
828         case P_STRING:
829         case P_PASSWORD:
830                 str = (gchar **)pparam->data;
831                 if (*str) {
832                         bufp = buf = alloca(strlen(*str) + 1);
833                         if (!buf) buf = "";
834                         else {
835                                 sp = *str;
836                                 while (*sp) {
837                                         if (*sp == '\\' && *(sp + 1) == 'n') {
838                                                 *bufp++ = '\n';
839                                                 sp += 2;
840                                         } else
841                                                 *bufp++ = *sp++;
842                                 }
843                                 *bufp = '\0';
844                         }
845                 } else
846                         buf = "";
847
848                 text = GTK_TEXT_VIEW(*pparam->widget);
849                 buffer = gtk_text_view_get_buffer(text);
850                 gtk_text_buffer_set_text(buffer, "", -1);
851                 gtk_text_buffer_get_start_iter(buffer, &iter);
852                 gtk_text_buffer_insert(buffer, &iter, buf, -1);
853                 break;
854         default:
855                 g_warning("Invalid PrefType for GtkTextView widget: %d\n",
856                           pparam->type);
857         }
858 }
859
860 void prefs_set_text_from_escaped(PrefParam *pparam)
861 {
862         gchar **str;
863
864         cm_return_if_fail(*pparam->widget != NULL);
865
866         switch (pparam->type) {
867         case P_STRING:
868                 str = (gchar **)pparam->data;
869                 pref_set_textview_from_pref(GTK_TEXT_VIEW(*pparam->widget),
870                                  *str ? *str : "");
871                 break;
872         default:
873                 g_warning("Invalid escaped PrefType for GtkTextView widget: %d\n",
874                           pparam->type);
875         }
876 }
877
878 void prefs_set_data_from_toggle(PrefParam *pparam)
879 {
880         cm_return_if_fail(pparam->type == P_BOOL);
881         cm_return_if_fail(*pparam->widget != NULL);
882         
883         *((gboolean *)pparam->data) =
884                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(*pparam->widget));
885 }
886
887 void prefs_set_toggle(PrefParam *pparam)
888 {
889         cm_return_if_fail(pparam->type == P_BOOL);
890         cm_return_if_fail(*pparam->widget != NULL);
891
892         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(*pparam->widget),
893                                      *((gboolean *)pparam->data));
894 }
895
896 void prefs_set_data_from_spinbtn(PrefParam *pparam)
897 {
898         cm_return_if_fail(*pparam->widget != NULL);
899
900         switch (pparam->type) {
901         case P_INT:
902                 *((gint *)pparam->data) =
903                         gtk_spin_button_get_value_as_int
904                         (GTK_SPIN_BUTTON(*pparam->widget));
905                 break;
906         case P_USHORT:
907                 *((gushort *)pparam->data) =
908                         (gushort)gtk_spin_button_get_value_as_int
909                         (GTK_SPIN_BUTTON(*pparam->widget));
910                 break;
911         default:
912                 g_warning("Invalid PrefType for GtkSpinButton widget: %d\n",
913                           pparam->type);
914         }
915 }
916
917 void prefs_set_spinbtn(PrefParam *pparam)
918 {
919         cm_return_if_fail(*pparam->widget != NULL);
920
921         switch (pparam->type) {
922         case P_INT:
923                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(*pparam->widget),
924                                           (gfloat)*((gint *)pparam->data));
925                 break;
926         case P_USHORT:
927                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(*pparam->widget),
928                                           (gfloat)*((gushort *)pparam->data));
929                 break;
930         default:
931                 g_warning("Invalid PrefType for GtkSpinButton widget: %d\n",
932                           pparam->type);
933         }
934 }
935
936 static GSList *prefs_pages = NULL;
937
938 void prefs_gtk_open(void)
939 {
940         prefswindow_open(_("Preferences"), prefs_pages, NULL,
941                         &prefs_common.prefswin_width, &prefs_common.prefswin_height,
942                         NULL, NULL);
943 }
944
945 void prefs_gtk_register_page(PrefsPage *page)
946 {
947         prefs_pages = g_slist_append(prefs_pages, page);
948 }
949
950 void prefs_gtk_unregister_page(PrefsPage *page)
951 {
952         prefs_pages = g_slist_remove(prefs_pages, page);
953 }
954
955 static void prefs_destroy_whole_cache(gpointer to_free)
956 {       
957         GHashTable *table = (GHashTable *)to_free;
958         g_hash_table_destroy(table);
959 }
960
961 static void prefs_destroy_file_cache(gpointer to_free)
962 {       
963         GHashTable *table = (GHashTable *)to_free;
964         g_hash_table_destroy(table);
965 }
966
967 static int prefs_cache_sections(GHashTable *file_cache, const gchar *rcfile)
968 {
969         FILE *fp = NULL;
970         gchar buf[PREFSBUFSIZE];
971         GHashTable *section_cache = NULL;
972
973         if (rcfile)
974                 fp = g_fopen(rcfile, "rb");
975         if (!fp) {
976                 debug_print("cache: %s: %s\n", rcfile?rcfile:"(null)", strerror(errno));
977                 return -1;
978         }
979         
980 #ifdef HAVE_FGETS_UNLOCKED
981         flockfile(fp);
982 #endif
983         
984         while (SC_FGETS(buf, sizeof(buf), fp) != NULL) {
985                 strretchomp(buf);
986                 if (buf[0] == '\0')
987                         continue;
988                 if (buf[0] == '#')
989                         continue; /* comment */
990                 if (buf[0] == '[') { /* new section */
991                         gchar *blockname = g_strdup(buf+1);
992
993                         if (strrchr(blockname, ']'))
994                                 *strrchr(blockname, ']') = '\0';
995
996                         if ((section_cache = g_hash_table_lookup(file_cache, blockname)) == NULL) {
997                                 debug_print("new section '%s'\n", blockname);
998                                 section_cache = g_hash_table_new_full(g_str_hash, g_str_equal,
999                                                 g_free, NULL);
1000                                 g_hash_table_insert(file_cache, 
1001                                         blockname, section_cache);
1002                         } else {
1003                                 debug_print("section '%s' already done\n", blockname);
1004                                 g_free(blockname);
1005                                 section_cache = NULL;
1006                                 continue;
1007                         }
1008                 } else {
1009                         if (!section_cache) {
1010                                 debug_print("skipping stuff %s with no section\n", buf);
1011                                 continue;
1012                         } else {
1013                                 gchar *pref;
1014                                 
1015                                 if (!strchr(buf, '=')) {
1016                                         /* plugins do differently */
1017                                         continue;
1018                                 }
1019                                 pref = g_strdup(buf);
1020                                 
1021                                 //debug_print("new pref '%s'\n", pref);
1022                                 g_hash_table_insert(section_cache, pref, GINT_TO_POINTER(1));
1023                         }
1024                 }
1025         }
1026 #ifdef HAVE_FGETS_UNLOCKED
1027         funlockfile(fp);
1028 #endif
1029         fclose(fp);
1030         return 0;
1031 }
1032
1033 static int prefs_cache(const gchar *rcfile)
1034 {
1035         GHashTable *file_cache = g_hash_table_new_full(g_str_hash, g_str_equal, 
1036                                         g_free, prefs_destroy_file_cache);
1037         
1038         debug_print("new file '%s'\n", rcfile?rcfile:"(null)");
1039         g_hash_table_insert(whole_cache, g_strdup(rcfile), file_cache);
1040         
1041         return prefs_cache_sections(file_cache, rcfile);
1042 }
1043
1044 void prefs_prepare_cache(void)
1045 {
1046         gchar *clawsrc = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
1047         gchar *folderitemrc = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, FOLDERITEM_RC, NULL);
1048         gchar *accountrc = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, ACCOUNT_RC, NULL);
1049         
1050         if (whole_cache == NULL) {
1051                 whole_cache = g_hash_table_new_full(g_str_hash, g_str_equal,
1052                                 g_free, prefs_destroy_whole_cache);
1053         } else {
1054                 debug_print("already cached\n");
1055                 g_free(clawsrc);
1056                 g_free(folderitemrc);
1057                 g_free(accountrc);
1058                 return;
1059         }
1060         if (prefs_cache(clawsrc) < 0 ||
1061             prefs_cache(folderitemrc) < 0 ||
1062             prefs_cache(accountrc) < 0)
1063                 prefs_destroy_cache();
1064
1065         g_free(clawsrc);
1066         g_free(folderitemrc);
1067         g_free(accountrc);
1068 }
1069
1070 void prefs_destroy_cache(void)
1071 {
1072         if (!whole_cache) {
1073                 debug_print("no cache\n");
1074                 return;
1075         }
1076         debug_print("destroying cache\n");
1077         g_hash_table_destroy(whole_cache);
1078         whole_cache = NULL;
1079         return;
1080 }
1081
1082 static void prefs_parse_cache(gpointer key, gpointer value, gpointer user_data)
1083 {
1084         gchar *pref = (gchar *)key;
1085
1086         PrefParam *param = (PrefParam *)user_data;
1087         
1088         prefs_config_parse_one_line(param, pref);
1089 }
1090
1091 static gboolean prefs_read_config_from_cache(PrefParam *param, const gchar *label,
1092                                const gchar *rcfile) 
1093 {
1094         GHashTable *sections_table = NULL;
1095         GHashTable *values_table = NULL;
1096         sections_table = g_hash_table_lookup(whole_cache, rcfile);
1097         
1098         if (sections_table == NULL) {
1099                 g_warning("Can't find %s in the whole cache\n", rcfile?rcfile:"(null)");
1100                 return FALSE;
1101         }
1102         values_table = g_hash_table_lookup(sections_table, label);
1103         
1104         if (values_table == NULL) {
1105                 debug_print("no '%s' section in '%s' cache\n", label?label:"(null)", rcfile?rcfile:"(null)");
1106                 return TRUE;
1107         }
1108         g_hash_table_foreach(values_table, prefs_parse_cache, param);
1109         return TRUE;
1110 }