//  ------------------------------------------------------------------
//  GoldED+
//  Copyright (C) 1990-1999 Odinn Sorensen
//  Copyright (C) 1999-2000 Alexander S. Aganichev
//  ------------------------------------------------------------------
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License as
//  published by the Free Software Foundation; either version 2 of the
//  License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
//  MA 02111-1307 USA
//  ------------------------------------------------------------------
//  $Id$
//  ------------------------------------------------------------------
//  Configuration functions, part 6.
//  ------------------------------------------------------------------

#include <golded.h>
#include <gcprot.h>


//  ------------------------------------------------------------------

extern char* val;


//  ------------------------------------------------------------------

void CfgMsglistfirst() {

  bool flag = make_bool(GetYesno(val));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_MSGLISTFIRST, flag);
  else
    CFG->msglistfirst = flag;
}

//  ------------------------------------------------------------------

void CfgMsglistheader() {

  bool flag = make_bool(GetYesno(val));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_MSGLISTHEADER, flag);
  else
    CFG->msglistheader = flag;
}

//  ------------------------------------------------------------------

void CfgMsglistwidesubj() {

  bool flag = make_bool(GetYesno(val));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_MSGLISTWIDESUBJ, flag);
  else
    CFG->msglistwidesubj = flag;
}

//  ------------------------------------------------------------------

void CfgNamesfile() {

  strcpy(CFG->namesfile, val);
}

//  ------------------------------------------------------------------

void CfgNickname() {
  
  Name buf;
  
  strxcpy(buf, val, sizeof(buf));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_NICKNAME, buf, strlen(buf)+1);
  else
    strcpy(CFG->nickname, buf);
}
  
//  ------------------------------------------------------------------

void CfgNetname() {
  
  Name buf;
  
  strxcpy(buf, StripQuotes(val), sizeof(buf));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_NETNAME, buf, strlen(buf)+1);
  else
    strcpy(CFG->netname, buf);
}
  
//  ------------------------------------------------------------------

void CfgNodelist() {

  // Only used by GoldNODE
}

//  ------------------------------------------------------------------

void CfgNodepath() {

  MapPath(PathCopy(CFG->nodepath, val));
}

//  ------------------------------------------------------------------

void CfgNodepathfd() {

  MapPath(PathCopy(CFG->nodepathfd, val));
}

//  ------------------------------------------------------------------

void CfgNodepathv7() {

  MapPath(PathCopy(CFG->nodepathv7, val));
}

//  ------------------------------------------------------------------

extern char v7nodeflags[16][9];

void CfgNodev7flags() {

  GTok t;
  char* flagstring = t.First(val);
  char* flagvals = t.Next();
  uint flagval;
  if(g_tolower(*flagvals) == 'b')
    flagval = atoi(flagvals+1);
  else {
    flagval = atoi(flagvals);
    switch(flagval) {
      case    32: flagval =  5; break;
      case    64: flagval =  6; break;
      case   128: flagval =  7; break;
      case   256: flagval =  8; break;
      case   512: flagval =  9; break;
      case  1024: flagval = 10; break;
      case  2048: flagval = 11; break;
      case  8192: flagval = 13; break;
      case 16384: flagval = 14; break;
      default:    flagval = 0;
    }
  }
  if(flagval)
    strcpy(stpcpy(v7nodeflags[flagval], flagstring), ",");
}

//  ------------------------------------------------------------------

extern char v7modemtype[8][9];

void CfgNodev7modem() {

  GTok t;
  char* modemstring = t.First(val);
  char* modemvals = t.Next();
  int modemval;
  if(g_tolower(*modemvals) == 'b')
    modemval = atoi(modemvals+1);
  else {
    modemval = atoi(modemvals);
    switch(modemval) {
      case   1: modemval = 0; break;
      case   2: modemval = 1; break;
      case   4: modemval = 2; break;
      case   8: modemval = 3; break;
      case  16: modemval = 4; break;
      case  32: modemval = 5; break;
      case  64: modemval = 6; break;
      case 128: modemval = 7; break;
      default:  modemval = -1;
    }
  }
  if(modemval >= 0)
    strcat(stpcpy(v7modemtype[modemval], modemstring), ",");
}

//  ------------------------------------------------------------------

void CfgOrganization() {

  INam buf;
  strxcpy(buf, val, sizeof(buf));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_ORGANIZATION, buf, strlen(buf)+1);
  else
    strcpy(CFG->organization, buf);
}

//  ------------------------------------------------------------------

void CfgOrigin(const char* v)  { char buf[256]; val = strxcpy(buf, v, sizeof(buf)); CfgOrigin(); }
void CfgOrigin() {

  if(not strblank(val)) {
    StripQuotes(val);
    if(cfgingroup)
      CFG->grp.AddItm(GRP_ORIGIN, val, strlen(val)+1);
    else
      CFG->origin.push_back(val);
  }
}

//  ------------------------------------------------------------------

void CfgOutboundpath() {

  PathCopy(CFG->outboundpath, val);
}

//  ------------------------------------------------------------------

void CfgOutputfile() {

  Path buf;
  strxcpy(buf, val, sizeof(buf));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_OUTPUTFILE, buf, strlen(buf)+1);
  else
    strcpy(CFG->outputfile, buf);
}

void CfgPathreportfile() {

  PathCopy(CFG->pathreportfile, val);
}

//  ------------------------------------------------------------------

void CfgPcboardpath(const char *path, bool force) {

  if(force or strblank(CFG->pcboardpath))
    MapPath(PathCopy(CFG->pcboardpath, path));
}

void CfgPcboardpath() {

  CfgPcboardpath(val, true);
}

//  ------------------------------------------------------------------

void CfgPcboarduserno() {

  CFG->pcboarduserno = atoi(val);
}

//  ------------------------------------------------------------------

void CfgPeekurloptions() {

  if(striinc("SORT", val))
    CFG->peekurloptions |= PEEK_SORT;
  if(striinc("FROMTOP", val))
    CFG->peekurloptions |= PEEK_FROMTOP;
  if(striinc("NOTFROMTOP", val))
    CFG->peekurloptions &= ~PEEK_FROMTOP;
}

//  ------------------------------------------------------------------

void CfgPersonalmail() {

  if(striinc("STARTUP", val))
    CFG->personalmail |= PM_STARTUP;
  if(striinc("NOTSTARTUP", val))
    CFG->personalmail &= ~PM_STARTUP;
  if(striinc("ALLNAMES", val))
    CFG->personalmail |= PM_ALLNAMES;
  if(striinc("NOTALLNAMES", val))
    CFG->personalmail &= ~PM_ALLNAMES;
  if(striinc("LISTONLY", val))
    CFG->personalmail |= PM_LISTONLY;
  if(striinc("NOTLISTONLY", val))
    CFG->personalmail &= ~PM_LISTONLY;
}

//  ------------------------------------------------------------------

void CfgPlay() {

  Path buf;
  strxcpy(buf, val, sizeof(buf));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_PLAY, buf, strlen(buf)+1);
  else
    FileToGPlay(&CFG->play, buf);
}

//  ------------------------------------------------------------------

void CfgPrintdevice() {

  strcpy(CFG->printdevice, val);
}

//  ------------------------------------------------------------------

void CfgPrintinit() {

  CvtPrnstr(CFG->printinit, val);
}

//  ------------------------------------------------------------------

void CfgPrintlength() {

  CFG->printlength = atoi(val);
}

//  ------------------------------------------------------------------

void CfgPrintmargin() {

  CFG->printmargin = atoi(val);
}

//  ------------------------------------------------------------------

void CfgPrintreset() {

  CvtPrnstr(CFG->printreset, val);
}

//  ------------------------------------------------------------------

void CfgQuotebuffile() {

  Path buf;
  strxcpy(buf, val, sizeof(buf));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_QUOTEBUFFILE, buf, strlen(buf)+1);
  else
    strcpy(CFG->quotebuffile, buf);
}

//  ------------------------------------------------------------------

void CfgQuotebufmode() {

  if(strieql(val, "ASK"))
    CFG->quotebufmode = QBUF_ASK;
  else if(strieql(val, "APPEND"))
    CFG->quotebufmode = QBUF_APPEND;
  else if(strieql(val, "OVERWRITE"))
    CFG->quotebufmode = QBUF_OVERWRITE;
}

//  ------------------------------------------------------------------

void CfgQuotechars() {

  char buf[11];
  strxcpy(buf, StripQuotes(val), sizeof(buf));
  if(cfgingroup)
    CFG->grp.AddItm(GRP_QUOTECHARS, buf, strlen(buf)+1);
  else
    strcpy(CFG->quotechars, buf);
}

//  ------------------------------------------------------------------

void CfgQuotectrl() {

  int ctrlinfo = CI_NONE;
  if(striinc("NO", val))
    ctrlinfo = CI_NONE;
  else if(striinc("YES", val))
    ctrlinfo = CI_TEAR|CI_ORIG;
  else {
    if(striinc("TEARLINE", val))
      ctrlinfo |= CI_TEAR;
    if(striinc("ORIGIN", val))
      ctrlinfo |= CI_ORIG;
  }
  if(cfgingroup)
    CFG->grp.AddItm(GRP_QUOTECTRL, ctrlinfo);
  else
    CFG->quotectrl = ctrlinfo;
}

//  ------------------------------------------------------------------

void CfgQuotemargin() {

  CFG->quotemargin = atoi(val);
}

//  ------------------------------------------------------------------