/* preferences.c */ 


#include "ml.h"


struct prefinfo {
  char *name;
  int  type;
  void *loc;
};

Boolean default_true  = TRUE;
Boolean default_false = FALSE;

Menu preferences_menu[] = {
  { NULL, "accept", NUL_TERM, 
      pref_accept, NULL, 0, NULL, NULL, BTN_ON },
  { NULL, "cancel", NUL_TERM, 
      pref_cancel, NULL, 0, NULL, NULL, BTN_ON },
  { NULL, "HELP", NUL_TERM, 
      pref_help, NULL, 0, NULL, NULL, BTN_ON },
};

Menu preferences2_menu[] = {
  { NULL, "accept", NUL_TERM, 
      pref2_accept, NULL, 0, NULL, NULL, BTN_ON },
  { NULL, "cancel", NUL_TERM, 
      pref2_cancel, NULL, 0, NULL, NULL, BTN_ON },
  { NULL, "HELP", NUL_TERM,
      pref2_help, NULL, 0, NULL, NULL, BTN_ON },
};


static XtResource x_resources[] = {
  { "defaultConfig","DefaultConfig",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,defaultConfig),
      XtRImmediate, (void*) DEFAULT_CONFIG
  },
  { "smtp_server","Smtp_server",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,smtp_server),
      XtRImmediate, (void *) EMPTYSTR },
  { "nntp_server","Nntp_server",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,nntp_server),
      XtRImmediate, (void *) EMPTYSTR },
  { "default_domain","Default_domain",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,default_domain),
      XtRImmediate, (void *) EMPTYSTR },
  { "default_cc","Default_cc",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,default_cc),
      XtRImmediate, (void *) EMPTYSTR },
  { "default_bcc","Default_bcc",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,default_bcc),
      XtRImmediate, (void *) EMPTYSTR },
  { "default_mailbox","Default_mailbox",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,default_mailbox),
      XtRImmediate, (void*) INBOX },
  { "default_mailbox_pattern","Default_mailbox_pattern",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,default_mailbox_pattern),
      XtRImmediate, (void*) MAILBOXDEFAULTPATTERN },
  { "default_file_pattern","Default_file_pattern",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,default_file_pattern),
      XtRImmediate, (void*) FILEALLPATTERN },
  { "sendlog","Sendlog",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,sendlog),
      XtRImmediate, (void*) EMPTYSTR },
  { "netCheckCommand","NetCheckCommand",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,netCheckCommand),
      XtRImmediate, (void*) EMPTYSTR },
  { "netStartCommand","NetStartCommand",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,netStartCommand),
      XtRImmediate, (void*) EMPTYSTR },
  { "netCheckDelay", "NetCheckDelay",
      XtRInt, sizeof(int),
      XtOffset(Preferences*,netCheckDelay),
      XtRString, (void*) DEFAULT_NETCHECK },
  { "header_set","Header_set",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,header_set),
      XtRImmediate, (void*) DEFAULTHEADERS },
  { "default_savebox","Default_savebox",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,default_savebox),
      XtRImmediate, (void*) EMPTYSTR },
  { "default_action","Default_action",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,default_action),
      XtRImmediate, (void*) EMPTYSTR },
  { "viewline_format","Viewline_format",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,viewline_format),
      XtRImmediate, (void*) VIEWLINE_FORMAT_STR },
  { "attribution_format","Attribution_format",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,attribution_format),
      XtRImmediate, (void*) ATTRIBUTION_FORMAT_STR },
  { "url_command","Url_command",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,url_command),
      XtRImmediate, (void*) EMPTYSTR },
  { "newMailProg","NewMailProg",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,newMailProg),
      XtRImmediate, (void*) EMPTYSTR },
  { "folder_path","Folder_path",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,folder_path),
      XtRImmediate, (void*) INBOX },
  { "charset","Charset",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,charset),
      XtRImmediate, (void*) US_ASCII_STR },
  { "language","Language",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,language),
      XtRImmediate, (void*) EMPTYSTR },
  { "help_directory", "Help_directory",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,help_directory),
      XtRImmediate, (void*) DEFAULT_LIBDIR },
  { "mime_directory", "Mime_directory",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,mime_directory),
      XtRImmediate, (void*) DEFAULT_LIBDIR },
  { "ispellCommand", "IspellCommand",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,ispellCommand),
      XtRImmediate, (void*) ISPELL_COMMAND },
  { "smartReply", "SmartReply",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,smart_reply),
      XtRImmediate, (void*) EMPTYSTR },
  { "signature_file", "Signature_file",
      XtRString, sizeof(char *),
      XtOffset(Preferences*, signature_file),
      XtRImmediate, (void *) EMPTYSTR },
  { "print_command", "Print_command",
      XtRString, sizeof(char *),
      XtOffset(Preferences*, print_command),
      XtRImmediate, (void *) EMPTYSTR },
  { "reply_address", "Reply_address",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,reply_address),
      XtRImmediate, (void*) EMPTYSTR },
  { "reply_prefix", "Reply_prefix",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,reply_prefix),
      XtRImmediate, (void*) DEFAULTINSERT_STR },
  { "mail_sort", "Mail_sort",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,mail_sort),
      XtRImmediate, (void*) NORMALSTR },
  { "news_sort", "News_sort",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,news_sort),
      XtRImmediate, (void*) NORMALSTR },
  { "check_interval", "Check_interval",
      XtRInt, sizeof(int),
      XtOffset(Preferences*,check_interval),
      XtRString, (void*) DEFAULT_RESOURCE_CHECK_INT },
  { "mail_prefetch", "Mail_prefetch",
      XtRInt, sizeof(int),
      XtOffset(Preferences*,mail_prefetch),
      XtRString, (void*) DEFAULT_PREFETCH },
  { "news_prefetch", "News_prefetch",
      XtRInt, sizeof(int),
      XtOffset(Preferences*,news_prefetch),
      XtRString, (void*) DEFAULT_PREFETCH },
  { "mail_background", "Mail_background",
      XtRInt, sizeof(int),
      XtOffset(Preferences*,mail_background),
      XtRString, (void*) DEFAULT_BGTIME },
  { "news_background", "News_background",
      XtRInt, sizeof(int),
      XtOffset(Preferences*,news_background),
      XtRString, (void*) DEFAULT_BGTIME },
  { "mail_fetch", "Mail_fetch",
      XtRInt, sizeof(int),
      XtOffset(Preferences*,mail_fetch),
      XtRString, (void*) DEFAULT_FETCH },
  { "news_fetch", "News_fetch",
      XtRInt, sizeof(int),
      XtOffset(Preferences*,news_fetch),
      XtRString, (void*) DEFAULT_FETCH },
  { "note_save", "Note_save",
      XtRInt, sizeof(int),
      XtOffset(Preferences*,note_save),
      XtRString, (void*) DEFAULT_RESOURCE_NOTE_SAVE },
  { "auto_open", "Auto_open",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, auto_open),
      XtRBoolean, (void*) &default_false },
  { "tear_off", "Tear_off",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, tear_off),
      XtRBoolean, (void*) &default_false },
  { "mime_ask", "mime_ask",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, mime_ask),
      XtRBoolean, (void*) &default_true },
  { "logit", "Logit",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, logit),
      XtRBoolean, (void*) &default_false },
  { "useIspell", "UseIspell",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, useIspell),
      XtRBoolean, (void*) &default_false },
  { "word_wrap", "Word_wrap",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, word_wrap),
      XtRBoolean, (void*) &default_true },
  { "keep_open", "Keep_open",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, keep_open),
      XtRBoolean, (void*) &default_false },
  { "developer_debug", "Developer_debug",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, developer_debug),
      XtRBoolean, (void*) &default_false },
  { "hide_empty", "Hide_empty",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, hide_empty),
      XtRBoolean, (void*) &default_false },
  { "local_defs", "Local_defs",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, local_defs),
      XtRBoolean, (void*) &default_false },
  { "new_news", "New_news",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, new_news),
      XtRBoolean, (void*) &default_false },
  { "send_eight", "Send_eight",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, send_eight),
      XtRBoolean, (void*) &default_false },
  { "log_full", "Log_full",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, log_full),
      XtRBoolean, (void*) &default_false },
  { "decode_all", "decode_all",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, decode_all),
      XtRBoolean, (void*) &default_false },
  { "alert_new", "alert_new",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, alert_new),
      XtRBoolean, (void*) &default_true },
  { "confirmDestroy", "ConfirmDestroy",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, confirmDestroy),
      XtRBoolean, (void*) &default_true },
  { "keep_open", "keep_open",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, keep_open),
      XtRBoolean, (void*) &default_false },
  { "newMailBeep", "NewMailBeep",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, newMailBeep),
      XtRBoolean, (void*) &default_true },
  { "keepOnServer", "KeepOnServer",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, keepOnServer),
      XtRBoolean, (void*) &default_false },
  { "autoPlace", "AutoPlace",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, autoPlace),
      XtRBoolean, (void*) &default_true },
  { "showLog", "ShowLog",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, showLog),
      XtRBoolean, (void*) &default_false },
  { "authLogin", "AuthLogin",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, authLogin),
      XtRBoolean, (void*) &default_true },
  { "defaults_installed", "Defaults_installed",
      XtRBoolean, sizeof (Boolean),
      XtOffset(Preferences*, defaults_installed),
      XtRBoolean, (void*) &default_false },
  { "defaults_version", "Defaults_version",
      XtRString, sizeof(char *),
      XtOffset(Preferences*,defaults_version),
      XtRImmediate, (void*) NO_DEFAULTS_VERSION },
};

struct prefinfo prefs[] = {
  { "defaultConfig",
      PREF_TYPE_STR,
      &preferences.defaultConfig,
  },
  { "smtp_server",
      PREF_TYPE_STR,
      &preferences.smtp_server,
  },
  { "default_domain",
      PREF_TYPE_STR,
      &preferences.default_domain,
  },
  { "folder_path",
      PREF_TYPE_STR,
      &preferences.folder_path,
  },
  { "default_action",
      PREF_TYPE_STR,
      &preferences.default_action,
  },
  { "default_cc",
      PREF_TYPE_STR,
      &preferences.default_cc,
  },
  { "default_bcc",
      PREF_TYPE_STR,
      &preferences.default_bcc,
  },
  { "sendlog",
      PREF_TYPE_STR,
      &preferences.sendlog,
  },
  { "url_command",
      PREF_TYPE_STR,
      &preferences.url_command,
  },
  { "newMailProg",
      PREF_TYPE_STR,
      &preferences.newMailProg,
  },
  { "nntp_server",
      PREF_TYPE_STR,
      &preferences.nntp_server,
  },
  { "default_mailbox",
      PREF_TYPE_STR,
      &preferences.default_mailbox,
  },
  { "default_savebox",
      PREF_TYPE_STR,
      &preferences.default_savebox,
  },
  { "help_directory",
      PREF_TYPE_STR,
      &preferences.help_directory,
  },
  { "header_set",
      PREF_TYPE_STR,
      &preferences.header_set,
  },
  { "viewline_format",
      PREF_TYPE_STR,
      &preferences.viewline_format,
  },
  { "attribution_format",
      PREF_TYPE_STR,
      &preferences.attribution_format,
  },
  { "mime_directory",
      PREF_TYPE_STR,
      &preferences.mime_directory,
  },
  { "reply_address",
      PREF_TYPE_STR,
      &preferences.reply_address,
  },
  { "print_command",
      PREF_TYPE_STR,
      &preferences.print_command,
  },
  { "signature_file",
      PREF_TYPE_STR,
      &preferences.signature_file,
  },
  { "charset",
      PREF_TYPE_STR,
      &preferences.charset,
  },
  { "language",
      PREF_TYPE_STR,
      &preferences.language,
  },
  { "mail_sort",
      PREF_TYPE_STR,
      &preferences.mail_sort,
  },
  { "news_sort",
      PREF_TYPE_STR,
      &preferences.news_sort,
  },
  { "check_interval",
      PREF_TYPE_INT,
      &preferences.check_interval,
  },
  { "mail_prefetch",
      PREF_TYPE_INT,
      &preferences.mail_prefetch,
  },
  { "news_prefetch",
      PREF_TYPE_INT,
      &preferences.news_prefetch,
  },
  { "mail_background",
      PREF_TYPE_INT,
      &preferences.mail_background,
  },
  { "news_background",
      PREF_TYPE_INT,
      &preferences.news_background,
  },
  { "mail_fetch",
      PREF_TYPE_INT,
      &preferences.mail_fetch,
  },
  { "news_fetch",
      PREF_TYPE_INT,
      &preferences.news_fetch,
  },
  { "note_save",
      PREF_TYPE_INT,
      &preferences.note_save,
  },
  { "smtp_debug",
      PREF_TYPE_BOOL,
      &preferences.smtp_debug,
  },
  { "useIspell",
      PREF_TYPE_BOOL,
      &preferences.useIspell,
  },
  { "auto_open",
      PREF_TYPE_BOOL,
      &preferences.auto_open,
  },
  { "tear_off",
      PREF_TYPE_BOOL,
      &preferences.tear_off,
  },
  { "mime_ask",
      PREF_TYPE_BOOL,
      &preferences.mime_ask,
  },
  { "log_full",
      PREF_TYPE_BOOL,
      &preferences.log_full,
  },
  { "send_eight",
      PREF_TYPE_BOOL,
      &preferences.send_eight,
  },
  { "confirmDestroy",
      PREF_TYPE_BOOL,
      &preferences.confirmDestroy,
  },
  { "decode_all",
      PREF_TYPE_BOOL,
      &preferences.decode_all,
  },
  { "alert_new",
      PREF_TYPE_BOOL,
      &preferences.alert_new,
  },
  { "developer_debug",
      PREF_TYPE_BOOL,
      &preferences.developer_debug,
  },
  { "hide_empty",
      PREF_TYPE_BOOL,
      &preferences.hide_empty,
  },
  { "keep_open",
      PREF_TYPE_BOOL,
      &preferences.keep_open,
  },
  { "logit",
      PREF_TYPE_BOOL,
      &preferences.logit,
  },
  { "word_wrap",
      PREF_TYPE_BOOL,
      &preferences.word_wrap,
  },
  { "newMailBeep",
      PREF_TYPE_BOOL,
      &preferences.newMailBeep,
  },
  { "keepOnServer",
      PREF_TYPE_BOOL,
      &preferences.keepOnServer,
  },
  { "autoPlace",
      PREF_TYPE_BOOL,
      &preferences.autoPlace,
  },
  { "showLog",
      PREF_TYPE_BOOL,
      &preferences.showLog,
  },
  { "authLogin",
      PREF_TYPE_BOOL,
      &preferences.authLogin,
  },
};


#ifdef __STDC__
int load_defaults(void)
#else
int load_defaults()
#endif
{
  FILE * fp;
  char * filename;
  char buf[FILEBUFFLEN];
  char *ptr;
  int cnt;
  char **t;
  int *i;
  Boolean *b;
  float *f;

  int total = XtNumber(prefs);

  /* Put all string resources into allocated space */

  for(cnt = 0; cnt < total; cnt ++) 
    if(prefs[cnt].type == PREF_TYPE_STR) {
      t = (char **) prefs[cnt].loc; 
      *t = cpystr(*t);
    }

  filename = (char *) fs_get(strlen(session->cachedir) 
		    + strlen(PREFSFILE) + strlen(local_auth.hostname) + 8);

  sprintf(filename,"%s/%s.%s", session->cachedir,
	  PREFSFILE, local_auth.hostname);

  if((fp = fopen(filename,"r")) == NULL) {
    sprintf(filename,"%s/%s", session->cachedir, PREFSFILE);
    if((fp = fopen(filename,"r")) == NULL) {
      /* One last try... */
      sprintf(filename,"%s/%s",local_auth.homedir,OLDPREFSFILE);
      if((fp = fopen(filename,"r")) == NULL) {
	free(filename);
	return(SYSCALL_FAILURE);
      }
    }
  }

  while((fgets(buf,sizeof(buf),fp)) != NULL) {
    buf[strlen(buf)-1] = NUL_TERM;
    /* skip over junk */
    if(*buf == '#' || *buf == '!' || *buf == NUL_TERM)
      continue;

    if((strcmp(buf,BEGIN_ADDRESS_STR)) == STRMATCH) {
      load_address_book(fp);
      continue;
    }
    if((strcmp(buf,BEGIN_FILTER_STR)) == STRMATCH) {
      load_filters(fp);
      continue;
    }
    if((strcmp(buf,BEGIN_FILTER_MAP_STR)) == STRMATCH) {
      load_filter_maps(fp);
      continue;
    }
    if((strcmp(buf,BEGIN_SERVERS_STR)) == STRMATCH) {
      load_server_tables(fp);
      continue;
    }
    if((strcmp(buf,BEGIN_BUTTONS_STR)) == STRMATCH) {
      load_button_tables(fp);
      continue;
    }

    ptr = strchr(buf,COLONCHAR);
    if(ptr == NULL)
      continue;
    *ptr = NUL_TERM;
    ptr ++;
                       /* if no value is set,
			* skip it, and allow the X defaults
			* to override
			*/
    if(*ptr == NUL_TERM)
      continue;
    for(cnt = 0; cnt < total; cnt ++) {
      if(strcmp(prefs[cnt].name,buf) != STRMATCH)
	continue;

      t = (char **) prefs[cnt].loc;
      i = (int *) prefs[cnt].loc;
      b = (Boolean *) prefs[cnt].loc;
      f = (float *) prefs[cnt].loc;
      
      switch(prefs[cnt].type) {
      case PREF_TYPE_INT:
	*i = atoi(ptr);
	break;
      case PREF_TYPE_STR:
	while(isspace((*(unsigned char *)ptr)))
	  ptr ++;
	free(*t);
	*t = cpystr(ptr);
	break;
      case PREF_TYPE_BOOL:
	while(isspace(*ptr))
	  ptr ++;
	if((strcasecmp(ptr,MLGetLocalized(XtNstrTrue,StrTrue))) == STRMATCH)
	  *b = TRUE;
	else
	  *b = FALSE;
	break;
      case PREF_TYPE_FLOAT:
	*f = (float) atof(ptr);
	break;
      default:
	break;
      }
    }
  }

  fclose(fp);
  free(filename);
  return(SYSCALL_SUCCESS);
}

#ifdef __STDC__
void save_defaults(void)
#else
void save_defaults()
#endif
{
  FILE * fp;
  char * filename;
  char * backup;
  int cnt;
  char **t;
  int *i;
  Boolean *b;
  float *f;
  char *strue =  MLGetLocalized(XtNstrTrue,StrTrue);
  char *sfalse = MLGetLocalized(XtNstrFalse,StrFalse);
  int total = XtNumber(prefs);

  sane_defaults();   /* Don't save garbage */

  filename = (char *) fs_get(strlen(session->cachedir)
		    + strlen(PREFSFILE) + strlen(local_auth.hostname) + 8);

  sprintf(filename,"%s/%s.%s", session->cachedir,
	  PREFSFILE, local_auth.hostname);

  if(access(filename,W_OK)) 
    sprintf(filename,"%s/%s", session->cachedir, PREFSFILE);

  backup = (char *) fs_get(strlen(filename) + strlen(".bak") + 8);
  strcpy(backup,filename);
  strcat(backup,".bak");

  rename(filename,backup);

  fs_give((void **) &backup);

  if((fp = fopen(filename,"w")) == NULL) {
    mm_log(MLGetLocalized(XtNmsgPrefSaveFail,MsgPrefSaveFail),WARN);
    free(filename);
    return;
  }

  (void) chmod(filename,S_IRWXU);

  fprintf(fp,"# ML Preferences:\n\n");

  for(cnt = 0; cnt < total; cnt ++) {

    t = (char **) prefs[cnt].loc;
    i = (int *) prefs[cnt].loc;
    b = (Boolean *) prefs[cnt].loc;
    f = (float *) prefs[cnt].loc;

    switch(prefs[cnt].type) {
    case PREF_TYPE_INT:
      fprintf(fp,"%s:\t\t%d\n",prefs[cnt].name,*i);
      break;
    case PREF_TYPE_STR:
      fprintf(fp,"%s:\t\t%s\n",prefs[cnt].name,*t);
      break;
    case PREF_TYPE_BOOL:
      fprintf(fp,"%s:\t\t%s\n",prefs[cnt].name,(*b) 
	      ? strue : sfalse);
      break;
    case PREF_TYPE_FLOAT:
      fprintf(fp,"%s:\t\t%f\n",prefs[cnt].name,*f);
      break;
    default:
      break;
    }
  }

  save_address_book(fp);
  save_filters(fp);
  save_filter_maps(fp);
  save_server_tables(fp);

  if((fclose(fp)) == SYSCALL_SUCCESS)
    mm_log(MLGetLocalized(XtNmsgPrefSaved,MsgPrefSaved),NIL);
  else
    mm_log(MLGetLocalized(XtNmsgPrefSaveFail,MsgPrefSaveFail),WARN);
  free(filename);
  return;
}

#ifdef __STDC__
void get_resources(Widget w)
#else
void get_resources(w)
     Widget w;
#endif
{
  XtGetApplicationResources(w, 
			    (char*) &preferences,
			    x_resources, 
			    XtNumber(x_resources),
			    NULL, 
			    0);
  return;
}


#ifdef __STDC__
void sane_defaults(void)
#else
void sane_defaults()
#endif
{
  char buf[FILEBUFFLEN];

  if(*(preferences.reply_address) == NUL_TERM) {
    fs_give((void **) &preferences.reply_address);
    sprintf(buf,"%s <%s@%s>",
	    local_auth.fullname,local_auth.username,local_auth.hostname);
    preferences.reply_address = cpystr(buf);
  }
  if(*(preferences.smtp_server) == NUL_TERM) {
    fs_give((void **) &preferences.smtp_server);
    preferences.smtp_server = cpystr(local_auth.hostname);
  }
  if(*(preferences.folder_path) == NUL_TERM) {
    fs_give((void **) &preferences.folder_path);
    preferences.folder_path = cpystr(local_auth.homedir);
  }
  if(*(preferences.charset) == NUL_TERM) {
    fs_give((void **) &preferences.charset);
    preferences.charset = cpystr(US_ASCII_STR);
  }

  if(*(preferences.defaultConfig) == NUL_TERM) {
    fs_give((void **) &preferences.defaultConfig);
    preferences.defaultConfig = cpystr(MLGetLocalized(XtNstrDefault,
						      StrDefault));
  }
  reset_header_set();

  if(session->servers == NULL)
    set_default_server_config();
}

#ifdef __STDC__
void reset_header_set(void)
#else
void reset_header_set()
#endif
{
  char **newset = NULL;
  char *newstr = NULL;

  if((preferences.header_set == NULL) || (*preferences.header_set == NUL_TERM))
    return;

  newset = init_array(preferences.header_set,&newstr);
  if(newset == (char **) NULL)
    return;

  if(session->header_set != (char **) NULL) {
    free((char *) session->header_set);
    session->header_set = NULL;
  }
  session->header_set = newset;

  if(session->header_str != NULL) {
    free(session->header_str);
    session->header_str = NULL;
  }
  session->header_str = newstr;
  return;
}

#ifdef __STDC__
char **init_array(char *string, char **newstr)
#else
char ** init_array(string, newstr)
     char * string;
     char **newstr;
#endif
{
  int number_entries = 0;
  int valid = 0;
  char * p;
  char ** base = NULL;
  
  if((string == NULL) || (*string == '\0'))
    return((char **) NULL);

  *newstr = cpystr(string); 
               
                  /* calculate the number of entries we'll need
                   * by counting commas.
                   */

  for(p = *newstr; *p != '\0'; p ++) {
    if(isalnum(*p))
      valid = 1;
    if(*p == ',')
      number_entries ++;
  }
  if(valid)
    number_entries ++;
  if(!number_entries) 
    return((char **) NULL);

                 /* Grab some array space from memory */

  base = (char **) fs_get((unsigned) (number_entries + 1) * sizeof(char *));

                /* now parse the copy of the resource string,
                 * zeroing out whitespace and commas, and putting
                 * "words" into the array, i.e. anything starting
                 * with an alphanumeric character.
                 */

  p = *newstr;
  number_entries = 0;
  valid = 0;
  while(*p != '\0') {
    if( isspace(*p) || *p == ',') {
      *p = '\0';
      valid = 0;
      p ++;
      continue;
    }
    if(isalnum(*p)) {
      if(valid == 0) {
	valid = 1;
	base[number_entries] = p;
	number_entries ++;
      }
      p ++;
      continue;
    }
    p++;
  }
  base[number_entries] = NULL;
  return((char **) base);
}

#ifdef __STDC__
int load_filters(FILE *fp)
#else
int load_filters(fp)
     FILE *fp;
#endif
{
  char buffer[FILEBUFFLEN];
  char *ptr;

  Filter *prev = NULL;
  Filter *filter;

  while((fgets(buffer,sizeof(buffer),fp)) != NULL) {
    buffer[strlen(buffer)-1] = '\0';

    if((strcmp(buffer,END_FILTER_STR)) == STRMATCH)
      return(0);
    
    filter = new_filter();

    filter->archived = TRUE;
    filter->filter_type = FILTER_TYPE_USER;

    filter->name = cpystr(buffer);
    if(fgets(buffer,sizeof(buffer),fp)) {
      buffer[strlen(buffer)-1] = '\0';
      ptr = buffer;
      if(*buffer == '/') {
	filter->representation = sortstr_to_rep(buffer + 1);
	ptr = strchr(buffer,SPACECHAR);
	if(ptr)
	  ptr ++;
      }
      if(ptr)
	filter->action = cpystr(ptr);
      else
	filter->action = cpystr(EMPTYSTR);
    }
    else
      filter->action = cpystr(EMPTYSTR);

    if(fgets(buffer,sizeof(buffer),fp)) {
      buffer[strlen(buffer)-1] = '\0';
      filter->text = cpystr(buffer);
    }
    else
      filter->text = cpystr(EMPTYSTR);

    if(*filter->text == NUL_TERM) {
      free_filter(filter);
      continue;
    }

    if(session->filters)
      for(prev = session->filters; prev->next; prev = prev->next)
	;

    if(prev == NULL) {
      session->filters = filter;
      filter->prev = NULL;
    }
    else {
      filter->prev = prev;
      prev->next = filter;
    }
  }
  return(0);
}

#ifdef __STDC__
int save_filters(FILE *fp)
#else
int save_filters(fp)
     FILE *fp;
#endif
{
  Filter *filter;

  fprintf(fp,"\n%s\n",BEGIN_FILTER_STR);
  for(filter = session->filters; filter; filter = filter->next) {
    fprintf(fp,"%s\n",(filter->name)   ? filter->name    : EMPTYSTR); 
    fprintf(fp,"/%s %s\n",rep_to_sortstr(filter->representation),
	    (filter->action) ? filter->action : EMPTYSTR); 
    fprintf(fp,"%s\n",(filter->text)   ? filter->text : EMPTYSTR); 
  }
  fprintf(fp,"%s\n",END_FILTER_STR);
  return(0);
}

#ifdef __STDC__
int save_filter_maps(FILE *fp)
#else
int save_filter_maps(fp)
     FILE *fp;
#endif
{
  Filter_Map *filter_map;

  fprintf(fp,"\n%s\n",BEGIN_FILTER_MAP_STR);
  for(filter_map = session->filter_map; 
      filter_map; filter_map = filter_map->next) {
    fprintf(fp,"%s\n",(filter_map->mailboxname)   
	    ? filter_map->mailboxname : EMPTYSTR); 
    fprintf(fp,"%s\n",(filter_map->filename) 
	    ? filter_map->filename : EMPTYSTR); 
  }
  fprintf(fp,"%s\n",END_FILTER_MAP_STR);
  return(0);
}

#ifdef __STDC__
int load_filter_maps(FILE *fp)
#else
int load_filter_maps(fp)
     FILE *fp;
#endif
{
  char buffer[FILEBUFFLEN];
  char *ptr = NULL;
  Filter_Map *prev = NULL;
  Filter_Map *filter_map;

  while((fgets(buffer,sizeof(buffer),fp)) != NULL) {
    buffer[strlen(buffer)-1] = '\0';

    if((strcmp(buffer,END_FILTER_MAP_STR)) == STRMATCH)
      return(0);
    
    filter_map = new_filter_map();

    filter_map->mailboxname = cpystr(buffer);
    if(fgets(buffer,sizeof(buffer),fp)) {
      buffer[strlen(buffer)-1] = '\0';
      filter_map->filename = cpystr(buffer);
    }
    else
      filter_map->filename = cpystr(EMPTYSTR);

    ptr = strrchr(buffer,'.');
    if(ptr) {
      ptr ++;
      filter_map->sequence = atoi(ptr);
    }

    if(session->filter_map)
      for(prev = session->filter_map; prev->next; prev = prev->next)
	;

    if(prev == NULL) 
      session->filter_map = filter_map;
    else
      prev->next = filter_map;
  }
  return(0);
}



#ifdef __STDC__
int save_button_tables(FILE *fp)
#else
int save_button_tables(fp)
     FILE *fp;
#endif
{
  return(0);
}

#ifdef __STDC__
int load_button_tables(FILE *fp)
#else
int load_button_tables(fp)
     FILE *fp;
#endif
{
  char buffer[FILEBUFFLEN];

  while((fgets(buffer,sizeof(buffer),fp)) != NULL) {
    buffer[strlen(buffer)-1] = NUL_TERM;
    if((strcmp(buffer,END_BUTTONS_STR)) == STRMATCH)
      return(0);
  }
}

XtResource Localized[] =
{
    { NULL, NULL, XtRString, sizeof(String), 0, XtRString, NULL },

};

#ifdef __STDC__
char *MLGetLocalized(char *Ntag,char *Fallback)
#else
char *MLGetLocalized(Ntag,Fallback)
     char *Ntag;
     char *Fallback;
#endif
{
  String Result;
  char *tmp = NULL;
  Localized[0].resource_name = Ntag;
  tmp = cpystr(Ntag);
  tmp[0] = toupper(tmp[0]);
  Localized[0].resource_class = tmp;
  XtGetApplicationResources(session->shell, (XtPointer) &Result,
			    Localized, 1, NULL, 0);
  free(tmp);
  return((Result) ? Result : Fallback);
}









#ifdef __STDC__
void main_preferences(Widget w, XtPointer zilch, XtPointer xp)
#else
void main_preferences(w,zilch,xp)
     Widget w;
     XtPointer zilch;
     XtPointer xp;
#endif
{
  
  Arg args[ARGLISTSIZE];
  int n = 0;
  Widget form, menubar, label1, label2;
  XtTranslations translations;
  Prefst *prefst;

  if(! session->prefst) {
    prefst = (Prefst *) fs_get(sizeof(Prefst));
    session->prefst = prefst;
    prefst->is_realized = FALSE;
  }
  else
    prefst = session->prefst;

  if(prefst->is_realized == TRUE) {
    de_iconify(prefst->shell);
    return;
  }

  if(preferences.autoPlace == TRUE) {
    XtSetArg(args[n], XtNx, -1000); n ++;
    XtSetArg(args[n], XtNy, -1000); n ++;
  }

  XtSetArg (args[n], XmNdeleteResponse, XmDO_NOTHING); n ++;              
  prefst->shell = XtCreatePopupShell("prefs",
				     topLevelShellWidgetClass, 
				     session->shell,
				     args, n); 
  n = 0;
  AddDestroyCallback (prefst->shell);
  setup_editres(prefst->shell);

  if(ml_icon != (Pixmap) None)
    XtVaSetValues(prefst->shell,
		  XmNiconPixmap,ml_icon,
		  NULL);

  form = XmCreateForm(prefst->shell, "form", args, n ); n = 0;

  XtSetArg(args[n], XmNtopAttachment,   XmATTACH_FORM); n ++;
  XtSetArg(args[n], XmNleftAttachment,  XmATTACH_FORM); n ++;
  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n ++;
  menubar = XmCreateMenuBar(form, "menubar", args, n); n = 0;
  XtManageChild(menubar);

  create_buttons(NULL, menubar, preferences_menu,
		 XtNumber(preferences_menu),
		 BTN_ON, (XtPointer) prefst, 
		 ROOTMENULEVEL);

  label1 = create_label(form,menubar,"mailconfig_lbl");

  prefst->confname =
    create_text_field(form, label1, 
		      "confname", 
		      preferences.defaultConfig,
		      0, NULL, NULL);


  prefst->prntcmd =
    create_text_field(form, prefst->confname, 
		      "prntcmd",
		      preferences.print_command,
		      0, NULL, NULL);



  prefst->fldrpath =
    create_text_field(form, prefst->prntcmd,
		      "fldrpath", 
		      preferences.folder_path,
		      0, NULL, NULL);

  prefst->helpdir =
    create_text_field(form, prefst->fldrpath,
		      "helpdir", 
		      preferences.help_directory,
		      0, NULL, NULL);

  prefst->mimedir =
    create_text_field(form, prefst->helpdir,
		      "mimedir",
		      preferences.mime_directory,
		      0, NULL, NULL);

  prefst->savebox =
    create_text_field(form, prefst->mimedir, 
		      "savebox", 
		      preferences.default_savebox,
		      0, NULL, NULL);

  prefst->charset =
    create_text_field(form, prefst->savebox,
		      "charset",
		      preferences.charset,
		      0, NULL, NULL);

  prefst->headset =
    create_text_field(form, prefst->charset,
		      "headset", 
		      preferences.header_set,
		      0, NULL, NULL);

  prefst->viewline =
    create_text_field(form, prefst->headset,
		      "viewline", 
		      preferences.viewline_format,
		      0, NULL, NULL);

  prefst->attribution =
    create_text_field(form, prefst->viewline,
		      "attribution", 
		      preferences.attribution_format,
		      0, NULL, NULL);

  prefst->dflact =
    create_text_field(form, prefst->attribution, 
		      "dflact",
		      preferences.default_action,
		      0, NULL, NULL);

  prefst->urlcomm =
    create_text_field(form, prefst->dflact, 
		      "urlcomm",
		      preferences.url_command,
		      0, NULL, NULL );

  prefst->newmail =
    create_text_field(form, prefst->urlcomm, 
		      "newmail",
		      preferences.newMailProg,
		      0, NULL, NULL );


  XtManageChild(form);
  XtManageChild(prefst->shell);
  XtPopup(prefst->shell, XtGrabNone);
  position_popup_widget(prefst->shell, FALSE);
  prefst->is_realized = TRUE;
  return;
}


#ifdef __STDC__
void main_more_preferences(Widget w, XtPointer zilch, XtPointer xp)
#else
void main_more_preferences(w,zilch,xp)
     Widget w;
     XtPointer zilch;
     XtPointer xp;
#endif
{
  
  Arg args[ARGLISTSIZE];
  char tmp[FILEBUFFLEN];
  XtTranslations translations;
  char *strue =  MLGetLocalized(XtNstrTrue,StrTrue);
  char *sfalse = MLGetLocalized(XtNstrFalse,StrFalse);
  int n = 0;
  Widget form, menubar, label1, label2, label3;
  Pref2st *pref2st;

  if(! session->pref2st) {
    pref2st = (Pref2st *) fs_get(sizeof(Pref2st));
    session->pref2st = pref2st;
    pref2st->is_realized = FALSE;
  }
  else
    pref2st = session->pref2st;

  if(pref2st->is_realized == TRUE) {
    de_iconify(pref2st->shell);
    return;
  }

  if(preferences.autoPlace == TRUE) {
    XtSetArg(args[n], XtNx, -1000); n ++;
    XtSetArg(args[n], XtNy, -1000); n ++;
  }

  XtSetArg (args[n], XmNdeleteResponse, XmDO_NOTHING); n++;      

  pref2st->shell = XtCreatePopupShell("prefs",
				      topLevelShellWidgetClass, 
				      session->shell,
				      args, n); 

  n = 0;
  AddDestroyCallback (pref2st->shell);
  setup_editres(pref2st->shell);

  if(ml_icon != (Pixmap) None)
    XtVaSetValues(pref2st->shell,
		  XmNiconPixmap,ml_icon,
		  NULL);



  form = XmCreateForm(pref2st->shell, "form", args, n ); n = 0;

  XtSetArg(args[n], XmNtopAttachment,   XmATTACH_FORM); n ++;
  XtSetArg(args[n], XmNleftAttachment,  XmATTACH_FORM); n ++;
  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n ++;
  menubar = XmCreateMenuBar(form, "menubar", args, n); n = 0;
  XtManageChild(menubar);

  create_buttons(NULL, menubar, preferences2_menu,
		 XtNumber(preferences2_menu),
		 BTN_ON, (XtPointer) pref2st, 
		 ROOTMENULEVEL);




  sprintf(tmp,"%u",preferences.check_interval);

  pref2st->check =
    create_text_field(form, menubar,
		      "check", 
		      tmp,
		      0, NULL, NULL);
  
  sprintf(tmp,"%u",preferences.note_save);

  pref2st->notesave =
    create_text_field(form, pref2st->check,
		      "notesave", 
		      tmp,
		      0, NULL, NULL);

  label1 = create_label(form, pref2st->notesave,"prefetch_lbl");


  sprintf(tmp,"%u", preferences.mail_prefetch);

  pref2st->mailfetch =
    create_text_field(form, label1,
		      "mailfetch",
		      tmp,
		      0, NULL, NULL );

  sprintf(tmp,"%u", preferences.mail_fetch);

  pref2st->mailcnt =
    create_text_field(form, pref2st->mailfetch,
		      "mailcnt",
		      tmp, 
		      0, NULL, NULL );

  sprintf(tmp,"%u", preferences.mail_background);

  pref2st->mailtime =
    create_text_field(form, pref2st->mailcnt,
		      "mailtime",
		      tmp, 
		      0, NULL, NULL );

  sprintf(tmp,"%u", preferences.news_prefetch);

  pref2st->newsfetch =
    create_text_field(form, pref2st->mailtime,
		      "newsfetch",
		      tmp, 
		      0, NULL, NULL );

  sprintf(tmp,"%u", preferences.news_fetch);

  pref2st->newscnt =
    create_text_field(form, pref2st->newsfetch,
		      "newscnt",
		      tmp, 
		      0, NULL, NULL );

  sprintf(tmp,"%u", preferences.news_background);

  pref2st->newstime =
    create_text_field(form, pref2st->newscnt,
		      "newstime",
		      tmp, 
		      0, NULL, NULL );


  label2 = create_label(form,pref2st->newstime,"sorts_lbl");

  pref2st->mailsort = 
    create_text_field(form, label2,
		      "mailsort",
		      preferences.mail_sort, 
		      0, NULL, NULL );

  pref2st->newssort = 
    create_text_field(form, pref2st->mailsort,
		      "newssort",
		      preferences.news_sort, 
		      0, NULL, NULL );

  label3 = create_label(form, pref2st->newssort,"toggles_lbl");


  sprintf(tmp,"%s", (preferences.auto_open == TRUE) ? strue : sfalse );

  pref2st->aopen =
    create_text_field(form, label3,
		      "aopen", 
		      tmp,
		      0, NULL, NULL);

  sprintf(tmp,"%s", (preferences.useIspell == TRUE) ? strue : sfalse );

  pref2st->ispell =
    create_text_field(form, pref2st->aopen,
		      "ispell",
		      tmp,
		      0, NULL, NULL);


  sprintf(tmp,"%s", (preferences.tear_off == TRUE) ? strue : sfalse );

  pref2st->tearoff =
    create_text_field(form, pref2st->ispell,
		      "tearoff", 
		      tmp,
		      0, NULL, NULL);


  sprintf(tmp,"%s", (preferences.mime_ask == TRUE) ? strue : sfalse );

  pref2st->mimeask =
    create_text_field(form, pref2st->tearoff,
		      "mimeask", 
		      tmp,
		      0, NULL, NULL);

  sprintf(tmp,"%s", (preferences.decode_all == TRUE) ? strue : sfalse );

  pref2st->decodeall =
    create_text_field(form, pref2st->mimeask,
		      "decodeall", 
		      tmp,
		      0, NULL, NULL);


  sprintf(tmp,"%s", (preferences.alert_new == TRUE) ? strue : sfalse );

  pref2st->alert_new =
    create_text_field(form, pref2st->decodeall,
		      "alertnew", 
		      tmp,
		      0, NULL, NULL);

  sprintf(tmp,"%s", (preferences.newMailBeep == TRUE) ? strue : sfalse );

  pref2st->newMailBeep =
    create_text_field(form, pref2st->alert_new,
		      "mailbeep", 
		      tmp,
		      0, NULL, NULL);

  sprintf(tmp,"%s", (preferences.keepOnServer == TRUE) ? strue : sfalse );

  pref2st->keepOnServer =
    create_text_field(form, pref2st->newMailBeep,
		      "keeponserver", 
		      tmp,
		      0, NULL, NULL);

  sprintf(tmp,"%s", (preferences.autoPlace == TRUE) ? strue : sfalse );

  pref2st->autoPlace =
    create_text_field(form, pref2st->keepOnServer,
		      "autoplace", 
		      tmp,
		      0, NULL, NULL);

  sprintf(tmp,"%s", (preferences.showLog == TRUE) ? strue : sfalse );

  pref2st->showLog =
    create_text_field(form, pref2st->autoPlace,
		      "showlog", 
		      tmp,
		      0, NULL, NULL);


  sprintf(tmp,"%s", (preferences.hide_empty == TRUE) ? strue : sfalse );

  pref2st->hideview =
    create_text_field(form, pref2st->showLog,
		      "hideview", 
		      tmp,
		      0, (XtPointer) pref2_accept, (XtPointer) pref2st);


  XtManageChild(form);
  XtManageChild(pref2st->shell);
  XtPopup(pref2st->shell, XtGrabNone);
  position_popup_widget(pref2st->shell, FALSE);
  pref2st->is_realized = TRUE;
  return;
}


#ifdef __STDC__
void pref_accept(Widget w, Prefst *prefst, XtPointer xp)
#else
void pref_accept(w,prefst,xp)
     Widget w;
     Prefst *prefst;
     XtPointer xp;
#endif
{
  XtPopdown(prefst->shell);
  push_cursor(WATCH_CURSOR);

  fs_give((void **) &preferences.defaultConfig);
  preferences.defaultConfig = GetTextField(prefst->confname);
  fs_give((void **) &preferences.print_command);
  preferences.print_command = GetTextField(prefst->prntcmd);
  fs_give((void **) &preferences.folder_path);
  preferences.folder_path = GetTextField(prefst->fldrpath);
  fs_give((void **) &preferences.help_directory);
  preferences.help_directory = GetTextField(prefst->helpdir);
  fs_give((void **) &preferences.mime_directory);
  preferences.mime_directory = GetTextField(prefst->mimedir);
  fs_give((void **) &preferences.default_savebox);
  preferences.default_savebox = GetTextField(prefst->savebox);
  fs_give((void **) &preferences.charset);
  preferences.charset = GetTextField(prefst->charset);
  fs_give((void **) &preferences.header_set);
  preferences.header_set = GetTextField(prefst->headset);
  fs_give((void **) &preferences.viewline_format);
  preferences.viewline_format = GetTextField(prefst->viewline);
  fs_give((void **) &preferences.attribution_format);
  preferences.attribution_format = GetTextField(prefst->attribution);
  fs_give((void **) &preferences.default_action);
  preferences.default_action = GetTextField(prefst->dflact);
  fs_give((void **) &preferences.url_command);
  preferences.url_command = GetTextField(prefst->urlcomm);
  fs_give((void **) &preferences.newMailProg);
  preferences.newMailProg = GetTextField(prefst->newmail);

  save_defaults();
  XtDestroyWidget(prefst->shell);
  prefst->is_realized = FALSE;

  pop_cursor();
  return;
}


#ifdef __STDC__
void pref2_accept(Widget w, Pref2st *pref2st, XtPointer xp)
#else
void pref2_accept(w,pref2st,xp)
     Widget w;
     Pref2st *pref2st;
     XtPointer xp;
#endif
{

  char *tmp;
  unsigned long n = 0;
  char *strue =  MLGetLocalized(XtNstrTrue,StrTrue);;

  XtPopdown(pref2st->shell);

  push_cursor(WATCH_CURSOR);

  tmp = GetTextField(pref2st->check);
  n = atoi(tmp);
  preferences.check_interval = n;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->notesave);
  n = atoi(tmp);
  preferences.note_save = n;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->mailfetch);
  n = atoi(tmp);
  preferences.mail_prefetch = n;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->mailcnt);
  n = atoi(tmp);
  if(n > 0)
    preferences.mail_fetch = n;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->mailtime);
  n = atoi(tmp);
  if(n > 0)
    preferences.mail_background = n;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->newsfetch);
  n = atoi(tmp);
  preferences.news_prefetch = n;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->newscnt);
  n = atoi(tmp);
  if(n > 0)
    preferences.news_fetch = n;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->newstime);
  n = atoi(tmp);
  if(n > 0)
    preferences.news_background = n;
  fs_give((void **) &tmp);

  fs_give((void **) &preferences.mail_sort);
  preferences.mail_sort = GetTextField(pref2st->mailsort);

  fs_give((void **) &preferences.news_sort);
  preferences.news_sort = GetTextField(pref2st->newssort);

  tmp = GetTextField(pref2st->aopen);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.auto_open = TRUE;
  else
    preferences.auto_open = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->ispell);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.useIspell = TRUE;
  else
    preferences.useIspell = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->tearoff);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.tear_off = TRUE;
  else
    preferences.tear_off = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->mimeask);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.mime_ask = TRUE;
  else
    preferences.mime_ask = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->decodeall);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.decode_all = TRUE;
  else
    preferences.decode_all = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->alert_new);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.alert_new = TRUE;
  else
    preferences.alert_new = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->newMailBeep);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.newMailBeep = TRUE;
  else
    preferences.newMailBeep = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->keepOnServer);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.keepOnServer = TRUE;
  else
    preferences.keepOnServer = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->autoPlace);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.autoPlace = TRUE;
  else
    preferences.autoPlace = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->showLog);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.showLog = TRUE;
  else
    preferences.showLog = FALSE;
  fs_give((void **) &tmp);

  tmp = GetTextField(pref2st->hideview);
  if((strcasecmp(tmp,strue)) == STRMATCH)
    preferences.hide_empty = TRUE;
  else
    preferences.hide_empty = FALSE;
  fs_give((void **) &tmp);

  save_defaults();

  XtDestroyWidget(pref2st->shell);
  pref2st->is_realized = FALSE;

  pop_cursor();
  return;
}


#ifdef __STDC__
void pref_cancel(Widget w, Prefst *prefst, XtPointer xp)
#else
void pref_cancel(w,prefst,xp)
     Widget w;
     Prefst *prefst;
     XtPointer xp;
#endif
{
  XtPopdown(prefst->shell);
  XtDestroyWidget(prefst->shell);
  prefst->is_realized = FALSE;
  return;
}

#ifdef __STDC__
void pref2_cancel(Widget w, Pref2st *pref2st, XtPointer xp)
#else
void pref2_cancel(w,pref2st,xp)
     Widget w;
     Pref2st *pref2st;
     XtPointer xp;
#endif
{
  XtPopdown(pref2st->shell);
  XtDestroyWidget(pref2st->shell);
  pref2st->is_realized = FALSE;
  return;
}

#ifdef __STDC__
void pref_help(Widget w, Prefst *prefst, XtPointer xp)
#else
void pref_help(w,prefst,xp)
     Widget w;
     Prefst *prefst;
     XtPointer xp;
#endif
{
  help(session->shell,PREFSHELPFILE);
  return;
}

#ifdef __STDC__
void pref2_help(Widget w, Pref2st *pref2st, XtPointer xp)
#else
void pref2_help(w,pref2st,xp)
     Widget w;
     Pref2st *pref2st;
     XtPointer xp;
#endif
{
  help(session->shell,PREFS2HELPFILE);
  return;
}