summaryrefslogtreecommitdiff
path: root/src/prefs_ui.c
diff options
context:
space:
mode:
authorSimeon Simeonov2018-02-26 11:23:00 +0100
committerSimeon Simeonov2018-02-26 11:23:00 +0100
commit0b3cbf57875fd692e4ba0b336fefa4bee1ed00dc (patch)
treeaf916a30553c78ce9d4f2d8658656a175c5b6921 /src/prefs_ui.c
Initial commit for sylpheed 3.7.0
Diffstat (limited to 'src/prefs_ui.c')
-rw-r--r--src/prefs_ui.c578
1 files changed, 578 insertions, 0 deletions
diff --git a/src/prefs_ui.c b/src/prefs_ui.c
new file mode 100644
index 0000000..a3a8f74
--- /dev/null
+++ b/src/prefs_ui.c
@@ -0,0 +1,578 @@
1/*
2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2017 Hiroyuki Yamamoto
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 2 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, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 */
19
20#ifdef HAVE_CONFIG_H
21# include "config.h"
22#endif
23
24#include <glib.h>
25#include <glib/gi18n.h>
26#include <gtk/gtk.h>
27#include <stdio.h>
28#include <stdlib.h>
29#include <string.h>
30#include <unistd.h>
31#include <errno.h>
32
33#include "prefs.h"
34#include "prefs_ui.h"
35#include "menu.h"
36#include "codeconv.h"
37#include "utils.h"
38#include "gtkutils.h"
39
40typedef enum
41{
42 DUMMY_PARAM
43} DummyEnum;
44
45void prefs_dialog_create(PrefsDialog *dialog)
46{
47 GtkWidget *window;
48 GtkWidget *vbox;
49 GtkWidget *notebook;
50
51 GtkWidget *confirm_area;
52 GtkWidget *ok_btn;
53 GtkWidget *cancel_btn;
54 GtkWidget *apply_btn;
55
56 g_return_if_fail(dialog != NULL);
57
58 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
59 gtk_container_set_border_width (GTK_CONTAINER (window), 6);
60 gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
61 gtk_window_set_modal (GTK_WINDOW (window), TRUE);
62 gtk_window_set_policy (GTK_WINDOW(window), FALSE, TRUE, FALSE);
63
64 vbox = gtk_vbox_new (FALSE, 6);
65 gtk_widget_show(vbox);
66 gtk_container_add (GTK_CONTAINER (window), vbox);
67
68 notebook = gtk_notebook_new ();
69 gtk_widget_show(notebook);
70 gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
71 gtk_container_set_border_width (GTK_CONTAINER (notebook), 2);
72 /* GTK_WIDGET_UNSET_FLAGS (notebook, GTK_CAN_FOCUS); */
73 gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
74
75 gtkut_stock_button_set_create(&confirm_area,
76 &ok_btn, GTK_STOCK_OK,
77 &cancel_btn, GTK_STOCK_CANCEL,
78 &apply_btn, GTK_STOCK_APPLY);
79 gtk_widget_show(confirm_area);
80 gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
81 gtk_widget_grab_default(ok_btn);
82
83 dialog->window = window;
84 dialog->notebook = notebook;
85 dialog->confirm_area = confirm_area;
86 dialog->ok_btn = ok_btn;
87 dialog->cancel_btn = cancel_btn;
88 dialog->apply_btn = apply_btn;
89}
90
91void prefs_dialog_destroy(PrefsDialog *dialog)
92{
93 gtk_widget_destroy(dialog->window);
94 dialog->window = NULL;
95 dialog->notebook = NULL;
96 dialog->ok_btn = NULL;
97 dialog->cancel_btn = NULL;
98 dialog->apply_btn = NULL;
99}
100
101void prefs_button_toggled(GtkToggleButton *toggle_btn, GtkWidget *widget)
102{
103 gboolean is_active;
104
105 is_active = gtk_toggle_button_get_active(toggle_btn);
106 gtk_widget_set_sensitive(widget, is_active);
107}
108
109void prefs_button_toggled_rev(GtkToggleButton *toggle_btn, GtkWidget *widget)
110{
111 gboolean is_active;
112
113 is_active = gtk_toggle_button_get_active(toggle_btn);
114 gtk_widget_set_sensitive(widget, !is_active);
115}
116
117void prefs_register_ui(PrefParam *param, PrefsUIData *ui_data)
118{
119 GHashTable *param_table;
120 PrefParam *param_;
121 gint i;
122
123 param_table = prefs_param_table_get(param);
124
125 for (i = 0; ui_data[i].name != NULL; i++) {
126 param_ = g_hash_table_lookup(param_table, ui_data[i].name);
127 if (param_) {
128 param_->ui_data = &ui_data[i];
129 }
130 }
131
132 prefs_param_table_destroy(param_table);
133}
134
135void prefs_set_dialog(PrefParam *param)
136{
137 PrefsUIData *ui_data;
138 gint i;
139
140 for (i = 0; param[i].name != NULL; i++) {
141 ui_data = (PrefsUIData *)param[i].ui_data;
142 if (ui_data && ui_data->widget_set_func)
143 ui_data->widget_set_func(&param[i]);
144 }
145}
146
147void prefs_set_data_from_dialog(PrefParam *param)
148{
149 PrefsUIData *ui_data;
150 gint i;
151
152 for (i = 0; param[i].name != NULL; i++) {
153 ui_data = (PrefsUIData *)param[i].ui_data;
154 if (ui_data && ui_data->data_set_func)
155 ui_data->data_set_func(&param[i]);
156 }
157}
158
159void prefs_set_dialog_to_default(PrefParam *param)
160{
161 gint i;
162 PrefsUIData *ui_data;
163 PrefParam tmpparam;
164 gchar *str_data = NULL;
165 gint int_data;
166 gushort ushort_data;
167 gboolean bool_data;
168 DummyEnum enum_data;
169
170 for (i = 0; param[i].name != NULL; i++) {
171 ui_data = (PrefsUIData *)param[i].ui_data;
172 if (!ui_data || !ui_data->widget_set_func) continue;
173
174 tmpparam = param[i];
175
176 switch (tmpparam.type) {
177 case P_STRING:
178 if (tmpparam.defval) {
179 if (!g_ascii_strncasecmp
180 (tmpparam.defval, "ENV_", 4)) {
181 str_data = g_strdup
182 (g_getenv(param[i].defval + 4));
183 tmpparam.data = &str_data;
184 break;
185 } else if (tmpparam.defval[0] == '~') {
186 str_data =
187#ifdef G_OS_WIN32
188 g_strconcat(get_rc_dir(),
189#else
190 g_strconcat(get_home_dir(),
191#endif
192 param[i].defval + 1,
193 NULL);
194 tmpparam.data = &str_data;
195 break;
196 }
197 }
198 tmpparam.data = &tmpparam.defval;
199 break;
200 case P_INT:
201 if (tmpparam.defval)
202 int_data = atoi(tmpparam.defval);
203 else
204 int_data = 0;
205 tmpparam.data = &int_data;
206 break;
207 case P_USHORT:
208 if (tmpparam.defval)
209 ushort_data = atoi(tmpparam.defval);
210 else
211 ushort_data = 0;
212 tmpparam.data = &ushort_data;
213 break;
214 case P_BOOL:
215 if (tmpparam.defval) {
216 if (!g_ascii_strcasecmp(tmpparam.defval, "TRUE"))
217 bool_data = TRUE;
218 else
219 bool_data = atoi(tmpparam.defval)
220 ? TRUE : FALSE;
221 } else
222 bool_data = FALSE;
223 tmpparam.data = &bool_data;
224 break;
225 case P_ENUM:
226 if (tmpparam.defval)
227 enum_data = (DummyEnum)atoi(tmpparam.defval);
228 else
229 enum_data = 0;
230 tmpparam.data = &enum_data;
231 break;
232 case P_OTHER:
233 break;
234 }
235 ui_data->widget_set_func(&tmpparam);
236 g_free(str_data);
237 str_data = NULL;
238 }
239}
240
241void prefs_set_data_from_entry(PrefParam *pparam)
242{
243 PrefsUIData *ui_data;
244 gchar **str;
245 const gchar *entry_str;
246
247 ui_data = (PrefsUIData *)pparam->ui_data;
248 g_return_if_fail(ui_data != NULL);
249 g_return_if_fail(*ui_data->widget != NULL);
250
251 entry_str = gtk_entry_get_text(GTK_ENTRY(*ui_data->widget));
252
253 switch (pparam->type) {
254 case P_STRING:
255 str = (gchar **)pparam->data;
256 g_free(*str);
257 *str = entry_str[0] ? g_strdup(entry_str) : NULL;
258 break;
259 case P_USHORT:
260 *((gushort *)pparam->data) = atoi(entry_str);
261 break;
262 case P_INT:
263 *((gint *)pparam->data) = atoi(entry_str);
264 break;
265 default:
266 g_warning("Invalid PrefType for GtkEntry widget: %d\n",
267 pparam->type);
268 }
269}
270
271void prefs_set_entry(PrefParam *pparam)
272{
273 PrefsUIData *ui_data;
274 gchar **str;
275
276 ui_data = (PrefsUIData *)pparam->ui_data;
277 g_return_if_fail(ui_data != NULL);
278 g_return_if_fail(*ui_data->widget != NULL);
279
280 switch (pparam->type) {
281 case P_STRING:
282 str = (gchar **)pparam->data;
283 gtk_entry_set_text(GTK_ENTRY(*ui_data->widget),
284 *str ? *str : "");
285 break;
286 case P_INT:
287 gtk_entry_set_text(GTK_ENTRY(*ui_data->widget),
288 itos(*((gint *)pparam->data)));
289 break;
290 case P_USHORT:
291 gtk_entry_set_text(GTK_ENTRY(*ui_data->widget),
292 itos(*((gushort *)pparam->data)));
293 break;
294 default:
295 g_warning("Invalid PrefType for GtkEntry widget: %d\n",
296 pparam->type);
297 }
298}
299
300gchar *prefs_get_escaped_str_from_text(GtkWidget *widget)
301{
302 gchar *text = NULL, *tp = NULL;
303 gchar *str, *p;
304
305 g_return_val_if_fail(widget != NULL, NULL);
306
307 if (GTK_IS_EDITABLE(widget)) {
308 tp = text = gtk_editable_get_chars
309 (GTK_EDITABLE(widget), 0, -1);
310 } else if (GTK_IS_TEXT_VIEW(widget)) {
311 GtkTextView *textview = GTK_TEXT_VIEW(widget);
312 GtkTextBuffer *buffer;
313 GtkTextIter start, end;
314
315 buffer = gtk_text_view_get_buffer(textview);
316 gtk_text_buffer_get_start_iter(buffer, &start);
317 gtk_text_buffer_get_iter_at_offset(buffer, &end, -1);
318 tp = text = gtk_text_buffer_get_text
319 (buffer, &start, &end, FALSE);
320 }
321
322 g_return_val_if_fail(tp != NULL && text != NULL, NULL);
323
324 if (text[0] == '\0') {
325 g_free(text);
326 return NULL;
327 }
328
329 p = str = g_malloc(strlen(text) * 2 + 1);
330 while (*tp) {
331 if (*tp == '\n') {
332 *p++ = '\\';
333 *p++ = 'n';
334 tp++;
335 } else
336 *p++ = *tp++;
337 }
338 *p = '\0';
339 g_free(text);
340
341 return str;
342}
343
344void prefs_set_data_from_text(PrefParam *pparam)
345{
346 PrefsUIData *ui_data;
347 gchar **str;
348
349 ui_data = (PrefsUIData *)pparam->ui_data;
350 g_return_if_fail(ui_data != NULL);
351 g_return_if_fail(*ui_data->widget != NULL);
352 g_return_if_fail(GTK_IS_EDITABLE(*ui_data->widget) ||
353 GTK_IS_TEXT_VIEW(*ui_data->widget));
354
355 switch (pparam->type) {
356 case P_STRING:
357 str = (gchar **)pparam->data;
358 g_free(*str);
359 *str = prefs_get_escaped_str_from_text(*ui_data->widget);
360 break;
361 default:
362 g_warning("Invalid PrefType for GtkTextView widget: %d\n",
363 pparam->type);
364 }
365}
366
367void prefs_set_escaped_str_to_text(GtkWidget *widget, const gchar *str)
368{
369 gchar *buf, *bufp;
370 const gchar *sp;
371 GtkTextView *text;
372 GtkTextBuffer *buffer;
373 GtkTextIter iter;
374
375 g_return_if_fail(widget != NULL);
376
377 if (str) {
378 bufp = buf = g_malloc(strlen(str) + 1);
379 sp = str;
380 while (*sp) {
381 if (*sp == '\\' && *(sp + 1) == 'n') {
382 *bufp++ = '\n';
383 sp += 2;
384 } else
385 *bufp++ = *sp++;
386 }
387 *bufp = '\0';
388 } else
389 buf = g_strdup("");
390
391 text = GTK_TEXT_VIEW(widget);
392 buffer = gtk_text_view_get_buffer(text);
393 gtk_text_buffer_set_text(buffer, "", 0);
394 gtk_text_buffer_get_start_iter(buffer, &iter);
395 gtk_text_buffer_insert(buffer, &iter, buf, -1);
396
397 g_free(buf);
398}
399
400void prefs_set_text(PrefParam *pparam)
401{
402 PrefsUIData *ui_data;
403 gchar **str;
404
405 ui_data = (PrefsUIData *)pparam->ui_data;
406 g_return_if_fail(ui_data != NULL);
407 g_return_if_fail(*ui_data->widget != NULL);
408
409 switch (pparam->type) {
410 case P_STRING:
411 str = (gchar **)pparam->data;
412 prefs_set_escaped_str_to_text(*ui_data->widget, *str);
413 break;
414 default:
415 g_warning("Invalid PrefType for GtkTextView widget: %d\n",
416 pparam->type);
417 }
418}
419
420void prefs_set_data_from_toggle(PrefParam *pparam)
421{
422 PrefsUIData *ui_data;
423
424 ui_data = (PrefsUIData *)pparam->ui_data;
425 g_return_if_fail(pparam->type == P_BOOL);
426 g_return_if_fail(ui_data != NULL);
427 g_return_if_fail(*ui_data->widget != NULL);
428
429 *((gboolean *)pparam->data) =
430 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(*ui_data->widget));
431}
432
433void prefs_set_toggle(PrefParam *pparam)
434{
435 PrefsUIData *ui_data;
436
437 ui_data = (PrefsUIData *)pparam->ui_data;
438 g_return_if_fail(pparam->type == P_BOOL);
439 g_return_if_fail(ui_data != NULL);
440 g_return_if_fail(*ui_data->widget != NULL);
441
442 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(*ui_data->widget),
443 *((gboolean *)pparam->data));
444}
445
446void prefs_set_data_from_spinbtn(PrefParam *pparam)
447{
448 PrefsUIData *ui_data;
449
450 ui_data = (PrefsUIData *)pparam->ui_data;
451 g_return_if_fail(ui_data != NULL);
452 g_return_if_fail(*ui_data->widget != NULL);
453
454 switch (pparam->type) {
455 case P_INT:
456 *((gint *)pparam->data) =
457 gtk_spin_button_get_value_as_int
458 (GTK_SPIN_BUTTON(*ui_data->widget));
459 break;
460 case P_USHORT:
461 *((gushort *)pparam->data) =
462 (gushort)gtk_spin_button_get_value_as_int
463 (GTK_SPIN_BUTTON(*ui_data->widget));
464 break;
465 default:
466 g_warning("Invalid PrefType for GtkSpinButton widget: %d\n",
467 pparam->type);
468 }
469}
470
471void prefs_set_spinbtn(PrefParam *pparam)
472{
473 PrefsUIData *ui_data;
474
475 ui_data = (PrefsUIData *)pparam->ui_data;
476 g_return_if_fail(ui_data != NULL);
477 g_return_if_fail(*ui_data->widget != NULL);
478
479 switch (pparam->type) {
480 case P_INT:
481 gtk_spin_button_set_value(GTK_SPIN_BUTTON(*ui_data->widget),
482 (gfloat)*((gint *)pparam->data));
483 break;
484 case P_USHORT:
485 gtk_spin_button_set_value(GTK_SPIN_BUTTON(*ui_data->widget),
486 (gfloat)*((gushort *)pparam->data));
487 break;
488 default:
489 g_warning("Invalid PrefType for GtkSpinButton widget: %d\n",
490 pparam->type);
491 }
492}
493
494void prefs_set_data_from_fontbtn(PrefParam *pparam)
495{
496 PrefsUIData *ui_data;
497 gchar **str;
498 const gchar *font_str;
499
500 ui_data = (PrefsUIData *)pparam->ui_data;
501 g_return_if_fail(ui_data != NULL);
502 g_return_if_fail(*ui_data->widget != NULL);
503
504 font_str = gtk_font_button_get_font_name
505 (GTK_FONT_BUTTON(*ui_data->widget));
506
507 switch (pparam->type) {
508 case P_STRING:
509 str = (gchar **)pparam->data;
510 g_free(*str);
511 *str = font_str[0] ? g_strdup(font_str) : NULL;
512 break;
513 default:
514 g_warning("Invalid PrefType for GtkFontButton widget: %d\n",
515 pparam->type);
516 }
517}
518
519void prefs_set_fontbtn(PrefParam *pparam)
520{
521 PrefsUIData *ui_data;
522 gchar **str;
523
524 ui_data = (PrefsUIData *)pparam->ui_data;
525 g_return_if_fail(ui_data != NULL);
526 g_return_if_fail(*ui_data->widget != NULL);
527
528 switch (pparam->type) {
529 case P_STRING:
530 str = (gchar **)pparam->data;
531 gtk_font_button_set_font_name(GTK_FONT_BUTTON(*ui_data->widget),
532 *str ? *str : "");
533 break;
534 default:
535 g_warning("Invalid PrefType for GtkFontButton widget: %d\n",
536 pparam->type);
537 }
538}
539
540void prefs_set_data_from_optmenu(PrefParam *pparam)
541{
542 PrefsUIData *ui_data;
543 GtkWidget *menu;
544 GtkWidget *menuitem;
545
546 ui_data = (PrefsUIData *)pparam->ui_data;
547 g_return_if_fail(ui_data != NULL);
548 g_return_if_fail(*ui_data->widget != NULL);
549
550 menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(*ui_data->widget));
551 menuitem = gtk_menu_get_active(GTK_MENU(menu));
552 *((DummyEnum *)pparam->data) = GPOINTER_TO_INT
553 (g_object_get_data(G_OBJECT(menuitem), MENU_VAL_ID));
554}
555
556void prefs_set_optmenu(PrefParam *pparam)
557{
558 PrefsUIData *ui_data;
559 DummyEnum val = *((DummyEnum *)pparam->data);
560 GtkOptionMenu *optmenu;
561 gint index;
562
563 ui_data = (PrefsUIData *)pparam->ui_data;
564 g_return_if_fail(ui_data != NULL);
565 g_return_if_fail(*ui_data->widget != NULL);
566
567 optmenu = GTK_OPTION_MENU(*ui_data->widget);
568 g_return_if_fail(optmenu != NULL);
569
570 index = menu_find_option_menu_index(optmenu, GINT_TO_POINTER(val),
571 NULL);
572 if (index >= 0)
573 gtk_option_menu_set_history(optmenu, index);
574 else {
575 gtk_option_menu_set_history(optmenu, 0);
576 prefs_set_data_from_optmenu(pparam);
577 }
578}
generated by cgit v1.3 (git 2.53.0) at 2026-09-26 13:19:48 +0000