src/prefs_gtk.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2002 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 <gtk/gtk.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <errno.h>
  30
  31 #include "intl.h"
  32 #include "main.h"
  33 #include "prefs.h"
  34 #include "prefs_gtk.h"
  35 #include "utils.h"
  36 #include "gtkutils.h"
  37
  38 #define CL(x)   (((gulong) (x) >> (gulong) 8) & 0xFFUL)
  39 #define RGB_FROM_GDK_COLOR(c) \
  40         ((CL(c.red)   << (gulong) 16) | \
  41          (CL(c.green) << (gulong)  8) | \
  42          (CL(c.blue)))
  43
  44 typedef enum
  45 {
  46         DUMMY_PARAM
  47 } DummyEnum;
  48
  49 void prefs_read_config(PrefParam *param, const gchar *label,
  50                        const gchar *rcfile)
  51 {
  52         FILE *fp;
  53         gchar buf[PREFSBUFSIZE];
  54         gchar *rcpath;
  55         gchar *block_label;
  56
  57         g_return_if_fail(param != NULL);
  58         g_return_if_fail(label != NULL);
  59         g_return_if_fail(rcfile != NULL);
  60
  61         debug_print("Reading configuration...\n");
  62
  63         prefs_set_default(param);
  64
  65         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, rcfile, NULL);
  66         if ((fp = fopen(rcpath, "rb")) == NULL) {
  67                 if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
  68                 g_free(rcpath);
  69                 return;
  70         }
  71         g_free(rcpath);
  72
  73         block_label = g_strdup_printf("[%s]", label);
  74
  75         /* search aiming block */
  76         while (fgets(buf, sizeof(buf), fp) != NULL) {
  77                 gint val;
  78
  79                 val = strncmp(buf, block_label, strlen(block_label));
  80                 if (val == 0) {
  81                         debug_print("Found %s\n", block_label);
  82                         break;
  83                 }
  84         }
  85         g_free(block_label);
  86
  87         while (fgets(buf, sizeof(buf), fp) != NULL) {
  88                 strretchomp(buf);
  89                 /* reached next block */
  90                 if (buf[0] == '[') break;
  91
  92                 prefs_config_parse_one_line(param, buf);
  93         }
  94
  95         debug_print("Finished reading configuration.\n");
  96         fclose(fp);
  97 }
  98
  99 void prefs_config_parse_one_line(PrefParam *param, const gchar *buf)
 100 {
 101         gint i;
 102         gint name_len;
 103         const gchar *value;
 104         GdkColor color;
 105
 106         for (i = 0; param[i].name != NULL; i++) {
 107                 name_len = strlen(param[i].name);
 108                 if (strncasecmp(buf, param[i].name, name_len))
 109                         continue;
 110                 if (buf[name_len] != '=')
 111                         continue;
 112                 value = buf + name_len + 1;
 113                 /* debug_print("%s = %s\n", param[i].name, value); */
 114
 115                 switch (param[i].type) {
 116                 case P_STRING:
 117                         g_free(*((gchar **)param[i].data));
 118                         *((gchar **)param[i].data) =
 119                                 *value ? g_strdup(value) : NULL;
 120                         break;
 121                 case P_INT:
 122                         *((gint *)param[i].data) =
 123                                 (gint)atoi(value);
 124                         break;
 125                 case P_BOOL:
 126                         *((gboolean *)param[i].data) =
 127                                 (*value == '0' || *value == '\0')
 128                                         ? FALSE : TRUE;
 129                         break;
 130                 case P_ENUM:
 131                         *((DummyEnum *)param[i].data) =
 132                                 (DummyEnum)atoi(value);
 133                         break;
 134                 case P_USHORT:
 135                         *((gushort *)param[i].data) =
 136                                 (gushort)atoi(value);
 137                         break;
 138                 case P_COLOR:
 139                         if (gdk_color_parse(value, &color))
 140                                 *((gulong *)param[i].data) = RGB_FROM_GDK_COLOR(color);
 141                         else
 142                                 /* be compatible and accept ints */
 143                                 *((gulong *)param[i].data) = strtoul(value, 0, 10);
 144                         break;
 145                 default:
 146                         break;
 147                 }
 148         }
 149 }
 150
 151 #define TRY(func) \
 152 if (!(func)) \
 153 { \
 154         g_warning("failed to write configuration to file\n"); \
 155         if (orig_fp) fclose(orig_fp); \
 156         prefs_file_close_revert(pfile); \
 157         g_free(rcpath); \
 158         g_free(block_label); \
 159         return; \
 160 } \
 161
 162 void prefs_save_config(PrefParam *param, const gchar *label,
 163                        const gchar *rcfile)
 164 {
 165         FILE *orig_fp;
 166         PrefFile *pfile;
 167         gchar *rcpath;
 168         gchar buf[PREFSBUFSIZE];
 169         gchar *block_label = NULL;
 170         gboolean block_matched = FALSE;
 171
 172         g_return_if_fail(param != NULL);
 173         g_return_if_fail(label != NULL);
 174         g_return_if_fail(rcfile != NULL);
 175
 176         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, rcfile, NULL);
 177         if ((orig_fp = fopen(rcpath, "rb")) == NULL) {
 178                 if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
 179         }
 180
 181         if ((pfile = prefs_write_open(rcpath)) == NULL) {
 182                 g_warning("failed to write configuration to file\n");
 183                 if (orig_fp) fclose(orig_fp);
 184                 g_free(rcpath);
 185                 return;
 186         }
 187
 188         block_label = g_strdup_printf("[%s]", label);
 189
 190         /* search aiming block */
 191         if (orig_fp) {
 192                 while (fgets(buf, sizeof(buf), orig_fp) != NULL) {
 193                         gint val;
 194
 195                         val = strncmp(buf, block_label, strlen(block_label));
 196                         if (val == 0) {
 197                                 debug_print("Found %s\n", block_label);
 198                                 block_matched = TRUE;
 199                                 break;
 200                         } else
 201                                 TRY(fputs(buf, pfile->fp) != EOF);
 202                 }
 203         }
 204
 205         TRY(fprintf(pfile->fp, "%s\n", block_label) > 0);
 206         g_free(block_label);
 207         block_label = NULL;
 208
 209         /* write all param data to file */
 210         TRY(prefs_write_param(param, pfile->fp) == 0);
 211
 212         if (block_matched) {
 213                 while (fgets(buf, sizeof(buf), orig_fp) != NULL) {
 214                         /* next block */
 215                         if (buf[0] == '[') {
 216                                 TRY(fputc('\n', pfile->fp) != EOF &&
 217                                     fputs(buf, pfile->fp)  != EOF);
 218                                 break;
 219                         }
 220                 }
 221                 while (fgets(buf, sizeof(buf), orig_fp) != NULL)
 222                         TRY(fputs(buf, pfile->fp) != EOF);
 223         }
 224
 225         if (orig_fp) fclose(orig_fp);
 226         if (prefs_file_close(pfile) < 0)
 227                 g_warning("failed to write configuration to file\n");
 228         g_free(rcpath);
 229
 230         debug_print("Configuration is saved.\n");
 231 }
 232
 233 gint prefs_write_param(PrefParam *param, FILE *fp)
 234 {
 235         gint i;
 236         gchar buf[PREFSBUFSIZE];
 237
 238         for (i = 0; param[i].name != NULL; i++) {
 239                 switch (param[i].type) {
 240                 case P_STRING:
 241                         g_snprintf(buf, sizeof(buf), "%s=%s\n", param[i].name,
 242                                    *((gchar **)param[i].data) ?
 243                                    *((gchar **)param[i].data) : "");
 244                         break;
 245                 case P_INT:
 246                         g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
 247                                    *((gint *)param[i].data));
 248                         break;
 249                 case P_BOOL:
 250                         g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
 251                                    *((gboolean *)param[i].data));
 252                         break;
 253                 case P_ENUM:
 254                         g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
 255                                    *((DummyEnum *)param[i].data));
 256                         break;
 257                 case P_USHORT:
 258                         g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
 259                                    *((gushort *)param[i].data));
 260                         break;
 261                 case P_COLOR:
 262                         g_snprintf(buf, sizeof buf,  "%s=#%6.6lx\n", param[i].name,
 263                                    *((gulong *) param[i].data));
 264                         break;
 265                 default:
 266                         buf[0] = '\0';
 267                 }
 268
 269                 if (buf[0] != '\0') {
 270                         if (fputs(buf, fp) == EOF) {
 271                                 perror("fputs");
 272                                 return -1;
 273                         }
 274                 }
 275         }
 276
 277         return 0;
 278 }
 279
 280 void prefs_set_default(PrefParam *param)
 281 {
 282         gint i;
 283         GdkColor color;
 284
 285         g_return_if_fail(param != NULL);
 286
 287         for (i = 0; param[i].name != NULL; i++) {
 288                 if (!param[i].data) continue;
 289
 290                 switch (param[i].type) {
 291                 case P_STRING:
 292                         if (param[i].defval != NULL) {
 293                                 if (!strncasecmp(param[i].defval, "ENV_", 4))
 294                                         *((gchar **)param[i].data) =
 295                                                 g_strdup(g_getenv(param[i].defval + 4));
 296                                 else if (param[i].defval[0] == '~')
 297                                         *((gchar **)param[i].data) =
 298                                                 g_strconcat(get_home_dir(),
 299                                                             param[i].defval + 1,
 300                                                             NULL);
 301                                 else if (param[i].defval[0] != '\0')
 302                                         *((gchar **)param[i].data) =
 303                                                 g_strdup(param[i].defval);
 304                                 else
 305                                         *((gchar **)param[i].data) = NULL;
 306                         } else
 307                                 *((gchar **)param[i].data) = NULL;
 308                         break;
 309                 case P_INT:
 310                         if (param[i].defval != NULL)
 311                                 *((gint *)param[i].data) =
 312                                         (gint)atoi(param[i].defval);
 313                         else
 314                                 *((gint *)param[i].data) = 0;
 315                         break;
 316                 case P_BOOL:
 317                         if (param[i].defval != NULL) {
 318                                 if (!strcasecmp(param[i].defval, "TRUE"))
 319                                         *((gboolean *)param[i].data) = TRUE;
 320                                 else
 321                                         *((gboolean *)param[i].data) =
 322                                                 atoi(param[i].defval) ? TRUE : FALSE;
 323                         } else
 324                                 *((gboolean *)param[i].data) = FALSE;
 325                         break;
 326                 case P_ENUM:
 327                         if (param[i].defval != NULL)
 328                                 *((DummyEnum*)param[i].data) =
 329                                         (DummyEnum)atoi(param[i].defval);
 330                         else
 331                                 *((DummyEnum *)param[i].data) = 0;
 332                         break;
 333                 case P_USHORT:
 334                         if (param[i].defval != NULL)
 335                                 *((gushort *)param[i].data) =
 336                                         (gushort)atoi(param[i].defval);
 337                         else
 338                                 *((gushort *)param[i].data) = 0;
 339                         break;
 340                 case P_COLOR:
 341                         if (param[i].defval != NULL && gdk_color_parse(param[i].defval, &color))
 342                                 *((gulong *)param[i].data) =
 343                                         RGB_FROM_GDK_COLOR(color);
 344                         else if (param[i].defval)
 345                                 /* be compatible and accept ints */
 346                                 *((gulong *)param[i].data) = strtoul(param[i].defval, 0, 10);
 347                         else
 348                                 *((gulong *)param[i].data) = 0;
 349                         break;
 350                 default:
 351                         break;
 352                 }
 353         }
 354 }
 355
 356 void prefs_free(PrefParam *param)
 357 {
 358         gint i;
 359
 360         g_return_if_fail(param != NULL);
 361
 362         for (i = 0; param[i].name != NULL; i++) {
 363                 if (!param[i].data) continue;
 364
 365                 switch (param[i].type) {
 366                 case P_STRING:
 367                         g_free(*((gchar **)param[i].data));
 368                         break;
 369                 default:
 370                         break;
 371                 }
 372         }
 373 }
 374
 375 void prefs_dialog_create(PrefsDialog *dialog)
 376 {
 377         GtkWidget *window;
 378         GtkWidget *vbox;
 379         GtkWidget *notebook;
 380
 381         GtkWidget *confirm_area;
 382         GtkWidget *ok_btn;
 383         GtkWidget *cancel_btn;
 384         GtkWidget *apply_btn;
 385
 386         g_return_if_fail(dialog != NULL);
 387
 388         window = gtk_window_new (GTK_WINDOW_DIALOG);
 389         gtk_container_set_border_width (GTK_CONTAINER (window), 8);
 390         gtk_window_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 391         gtk_window_set_modal (GTK_WINDOW (window), TRUE);
 392         gtk_window_set_policy (GTK_WINDOW(window), FALSE, TRUE, FALSE);
 393
 394         vbox = gtk_vbox_new (FALSE, 6);
 395         gtk_widget_show(vbox);
 396         gtk_container_add (GTK_CONTAINER (window), vbox);
 397
 398         notebook = gtk_notebook_new ();
 399         gtk_widget_show(notebook);
 400         gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
 401         gtk_container_set_border_width (GTK_CONTAINER (notebook), 2);
 402         /* GTK_WIDGET_UNSET_FLAGS (notebook, GTK_CAN_FOCUS); */
 403         gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
 404
 405         gtk_notebook_popup_enable (GTK_NOTEBOOK (notebook));
 406
 407         gtkut_button_set_create(&confirm_area,
 408                                 &ok_btn,        _("OK"),
 409                                 &cancel_btn,    _("Cancel"),
 410                                 &apply_btn,     _("Apply"));
 411         gtk_widget_show(confirm_area);
 412         gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
 413         gtk_widget_grab_default(ok_btn);
 414
 415         dialog->window     = window;
 416         dialog->notebook   = notebook;
 417         dialog->ok_btn     = ok_btn;
 418         dialog->cancel_btn = cancel_btn;
 419         dialog->apply_btn  = apply_btn;
 420 }
 421
 422 void prefs_dialog_destroy(PrefsDialog *dialog)
 423 {
 424         gtk_widget_destroy(dialog->window);
 425         dialog->window     = NULL;
 426         dialog->notebook   = NULL;
 427         dialog->ok_btn     = NULL;
 428         dialog->cancel_btn = NULL;
 429         dialog->apply_btn  = NULL;
 430 }
 431
 432 void prefs_button_toggled(GtkToggleButton *toggle_btn, GtkWidget *widget)
 433 {
 434         gboolean is_active;
 435
 436         is_active = gtk_toggle_button_get_active(toggle_btn);
 437         gtk_widget_set_sensitive(widget, is_active);
 438 }
 439
 440 void prefs_set_dialog(PrefParam *param)
 441 {
 442         gint i;
 443
 444         for (i = 0; param[i].name != NULL; i++) {
 445                 if (param[i].widget_set_func)
 446                         param[i].widget_set_func(&param[i]);
 447         }
 448 }
 449
 450 void prefs_set_data_from_dialog(PrefParam *param)
 451 {
 452         gint i;
 453
 454         for (i = 0; param[i].name != NULL; i++) {
 455                 if (param[i].data_set_func)
 456                         param[i].data_set_func(&param[i]);
 457         }
 458 }
 459
 460 void prefs_set_dialog_to_default(PrefParam *param)
 461 {
 462         gint       i;
 463         PrefParam  tmpparam;
 464         gchar     *str_data = NULL;
 465         gint       int_data;
 466         gushort    ushort_data;
 467         gboolean   bool_data;
 468         DummyEnum  enum_data;
 469
 470         for (i = 0; param[i].name != NULL; i++) {
 471                 if (!param[i].widget_set_func) continue;
 472
 473                 tmpparam = param[i];
 474
 475                 switch (tmpparam.type) {
 476                 case P_STRING:
 477                         if (tmpparam.defval) {
 478                                 if (!strncasecmp(tmpparam.defval, "ENV_", 4)) {
 479                                         str_data = g_strdup(g_getenv(param[i].defval + 4));
 480                                         tmpparam.data = &str_data;
 481                                         break;
 482                                 } else if (tmpparam.defval[0] == '~') {
 483                                         str_data =
 484                                                 g_strconcat(get_home_dir(),
 485                                                             param[i].defval + 1,
 486                                                             NULL);
 487                                         tmpparam.data = &str_data;
 488                                         break;
 489                                 }
 490                         }
 491                         tmpparam.data = &tmpparam.defval;
 492                         break;
 493                 case P_INT:
 494                         if (tmpparam.defval)
 495                                 int_data = atoi(tmpparam.defval);
 496                         else
 497                                 int_data = 0;
 498                         tmpparam.data = &int_data;
 499                         break;
 500                 case P_USHORT:
 501                         if (tmpparam.defval)
 502                                 ushort_data = atoi(tmpparam.defval);
 503                         else
 504                                 ushort_data = 0;
 505                         tmpparam.data = &ushort_data;
 506                         break;
 507                 case P_BOOL:
 508                         if (tmpparam.defval) {
 509                                 if (!strcasecmp(tmpparam.defval, "TRUE"))
 510                                         bool_data = TRUE;
 511                                 else
 512                                         bool_data = atoi(tmpparam.defval)
 513                                                 ? TRUE : FALSE;
 514                         } else
 515                                 bool_data = FALSE;
 516                         tmpparam.data = &bool_data;
 517                         break;
 518                 case P_ENUM:
 519                         if (tmpparam.defval)
 520                                 enum_data = (DummyEnum)atoi(tmpparam.defval);
 521                         else
 522                                 enum_data = 0;
 523                         tmpparam.data = &enum_data;
 524                         break;
 525                 case P_OTHER:
 526                 default:
 527                         break;
 528                 }
 529                 tmpparam.widget_set_func(&tmpparam);
 530                 g_free(str_data);
 531                 str_data = NULL;
 532         }
 533 }
 534
 535 void prefs_set_data_from_entry(PrefParam *pparam)
 536 {
 537         gchar **str, *entry_str;
 538
 539         g_return_if_fail(*pparam->widget != NULL);
 540
 541         entry_str = gtk_entry_get_text(GTK_ENTRY(*pparam->widget));
 542
 543         switch (pparam->type) {
 544         case P_STRING:
 545                 str = (gchar **)pparam->data;
 546                 g_free(*str);
 547                 *str = entry_str[0] ? g_strdup(entry_str) : NULL;
 548                 break;
 549         case P_USHORT:
 550                 *((gushort *)pparam->data) = atoi(entry_str);
 551                 break;
 552         case P_INT:
 553                 *((gint *)pparam->data) = atoi(entry_str);
 554                 break;
 555         default:
 556                 g_warning("Invalid PrefType for GtkEntry widget: %d\n",
 557                           pparam->type);
 558         }
 559 }
 560
 561 void prefs_set_entry(PrefParam *pparam)
 562 {
 563         gchar **str;
 564
 565         g_return_if_fail(*pparam->widget != NULL);
 566
 567         switch (pparam->type) {
 568         case P_STRING:
 569                 str = (gchar **)pparam->data;
 570                 gtk_entry_set_text(GTK_ENTRY(*pparam->widget),
 571                                    *str ? *str : "");
 572                 break;
 573         case P_INT:
 574                 gtk_entry_set_text(GTK_ENTRY(*pparam->widget),
 575                                    itos(*((gint *)pparam->data)));
 576                 break;
 577         case P_USHORT:
 578                 gtk_entry_set_text(GTK_ENTRY(*pparam->widget),
 579                                    itos(*((gushort *)pparam->data)));
 580                 break;
 581         default:
 582                 g_warning("Invalid PrefType for GtkEntry widget: %d\n",
 583                           pparam->type);
 584         }
 585 }
 586
 587 void prefs_set_data_from_text(PrefParam *pparam)
 588 {
 589         gchar **str;
 590         gchar *text, *tp;
 591         gchar *tmp, *tmpp;
 592
 593         g_return_if_fail(*pparam->widget != NULL);
 594
 595         switch (pparam->type) {
 596         case P_STRING:
 597                 str = (gchar **)pparam->data;
 598                 g_free(*str);
 599                 tp = text = gtk_editable_get_chars
 600                         (GTK_EDITABLE(*pparam->widget), 0, -1);
 601                 if (text[0] == '\0') {
 602                         *str = NULL;
 603                         g_free(text);
 604                         break;
 605                 }
 606
 607                 Xalloca(tmpp = tmp, strlen(text) * 2 + 1,
 608                         { *str = NULL; break; });
 609                 while (*tp) {
 610                         if (*tp == '\n') {
 611                                 *tmpp++ = '\\';
 612                                 *tmpp++ = 'n';
 613                                 tp++;
 614                         } else
 615                                 *tmpp++ = *tp++;
 616                 }
 617                 *tmpp = '\0';
 618                 *str = g_strdup(tmp);
 619                 g_free(text);
 620                 break;
 621         default:
 622                 g_warning("Invalid PrefType for GtkText widget: %d\n",
 623                           pparam->type);
 624         }
 625 }
 626
 627 void prefs_set_text(PrefParam *pparam)
 628 {
 629         gchar *buf, *sp, *bufp;
 630         gchar **str;
 631         GtkText *text;
 632
 633         g_return_if_fail(*pparam->widget != NULL);
 634
 635         switch (pparam->type) {
 636         case P_STRING:
 637                 str = (gchar **)pparam->data;
 638                 if (*str) {
 639                         bufp = buf = alloca(strlen(*str) + 1);
 640                         if (!buf) buf = "";
 641                         else {
 642                                 sp = *str;
 643                                 while (*sp) {
 644                                         if (*sp == '\\' && *(sp + 1) == 'n') {
 645                                                 *bufp++ = '\n';
 646                                                 sp += 2;
 647                                         } else
 648                                                 *bufp++ = *sp++;
 649                                 }
 650                                 *bufp = '\0';
 651                         }
 652                 } else
 653                         buf = "";
 654
 655                 text = GTK_TEXT(*pparam->widget);
 656                 gtk_text_set_point(text, 0);
 657                 gtk_text_forward_delete(text, gtk_text_get_length(text));
 658                 gtk_text_set_point(text, 0);
 659                 gtk_text_insert(text, NULL, NULL, NULL, buf, -1);
 660                 break;
 661         default:
 662                 g_warning("Invalid PrefType for GtkText widget: %d\n",
 663                           pparam->type);
 664         }
 665 }
 666
 667 void prefs_set_data_from_toggle(PrefParam *pparam)
 668 {
 669         g_return_if_fail(pparam->type == P_BOOL);
 670         g_return_if_fail(*pparam->widget != NULL);
 671
 672         *((gboolean *)pparam->data) =
 673                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(*pparam->widget));
 674 }
 675
 676 void prefs_set_toggle(PrefParam *pparam)
 677 {
 678         g_return_if_fail(pparam->type == P_BOOL);
 679         g_return_if_fail(*pparam->widget != NULL);
 680
 681         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(*pparam->widget),
 682                                      *((gboolean *)pparam->data));
 683 }
 684
 685 void prefs_set_data_from_spinbtn(PrefParam *pparam)
 686 {
 687         g_return_if_fail(*pparam->widget != NULL);
 688
 689         switch (pparam->type) {
 690         case P_INT:
 691                 *((gint *)pparam->data) =
 692                         gtk_spin_button_get_value_as_int
 693                         (GTK_SPIN_BUTTON(*pparam->widget));
 694                 break;
 695         case P_USHORT:
 696                 *((gushort *)pparam->data) =
 697                         (gushort)gtk_spin_button_get_value_as_int
 698                         (GTK_SPIN_BUTTON(*pparam->widget));
 699                 break;
 700         default:
 701                 g_warning("Invalid PrefType for GtkSpinButton widget: %d\n",
 702                           pparam->type);
 703         }
 704 }
 705
 706 void prefs_set_spinbtn(PrefParam *pparam)
 707 {
 708         g_return_if_fail(*pparam->widget != NULL);
 709
 710         switch (pparam->type) {
 711         case P_INT:
 712                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(*pparam->widget),
 713                                           (gfloat)*((gint *)pparam->data));
 714                 break;
 715         case P_USHORT:
 716                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(*pparam->widget),
 717                                           (gfloat)*((gushort *)pparam->data));
 718                 break;
 719         default:
 720                 g_warning("Invalid PrefType for GtkSpinButton widget: %d\n",
 721                           pparam->type);
 722         }
 723 }
 724
 725 static GSList *prefs_pages = NULL;
 726
 727 void prefs_gtk_open()
 728 {
 729         prefswindow_open(prefs_pages, NULL);
 730 }
 731
 732 void prefs_gtk_register_page(PrefsPage *page)
 733 {
 734         prefs_pages = g_slist_append(prefs_pages, page);
 735 }
 736
 737 void prefs_gtk_unregister_page(PrefsPage *page)
 738 {
 739         prefs_pages = g_slist_remove(prefs_pages, page);
 740 }