/*->c.status */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <ctype.h>
#include <time.h>

#include "h.os"
#include "h.wimp"


#include "h.wos"
#include "h.main"
#include "h.ram"
#include "h.mym"
#include "h.pr"
#include "h.trans"

#include "h.swinos"
#include "h.serial"
#include "h.serialdev"
#include "h.timex"

#include "h.vax"

#include "h.vtdef"
#include "h.vtlo"


#include "h.vxdef"
#include "h.vxkey"

#include "h.dir"

#include "h.xext"

#include "h.mnpx"

#include "h.script"



/***************************************************************************/
/*

 Code to handle line settings

*/
/***************************************************************************/


int databits=8;
int stopbits=1;
int paritybits=0;

int txbitrate=9600;
int rxbitrate=9600;

int txbyterate=960;
int rxbyterate=960;

int filter;
int flow;
int answer;



/***************************************************************************/


int swi13(int swi,int r0,int r1,int r2)
{
 os_regset rx;
 rx.r[0]=r0;
 rx.r[1]=r1;
 rx.r[2]=r2;
 os_swix(swi,&rx);
 return(rx.r[1]);
}


/*****************************************************************************/
/* below talks to modem driver, above talks to hardware                      */


/* call driver routines to read current values */

void driverread(void)
{
 int div;

 if(active)
 {
  if(!xexec("modem_readbits",NULL,NULL,&databits))
                                  databits=swi13(Hearsay_DataBits,0,0,0);


  if(!xexec("modem_readstop",NULL,NULL,&stopbits))
                                  stopbits=swi13(Hearsay_StopBits,0,0,0);


  if(!xexec("modem_readparity",NULL,NULL,&paritybits))
                                  paritybits=swi13(Hearsay_ParityBits,0,0,0);


  if(!xexec("modem_readrxrate",NULL,NULL,&rxbitrate))
  {
   rxbitrate=swi13(Hearsay_RxRate,0,0,0);
  }

  if(!xexec("modem_readtxrate",NULL,NULL,&txbitrate))
  {
   txbitrate=swi13(Hearsay_TxRate,0,0,0);
  }

  if(!xexec("modem_readanswer",NULL,NULL,&answer)) answer=0;
 }

 div=databits+stopbits+paritybits;
 if(!div) div=10;
 rxbyterate=rxbitrate/div;
 txbyterate=txbitrate/div;
}


void driversetrxrate(int rate)
{
 if(!active) rxbitrate=rate;
 else
 if(!xexec("modem_setrxrate",NULL,&rate,NULL))
                                            swi13(Hearsay_RxRate,0,rate,1);
}

void driversettxrate(int rate)
{
 if(!active) txbitrate=rate;
 else
 if(!xexec("modem_settxrate",NULL,&rate,NULL))
                                            swi13(Hearsay_TxRate,0,rate,1);
}

void driversetbits(int bits)
{
 if(!active) databits=bits;
 else
 if(!xexec("modem_setbits",NULL,&bits,NULL))
                                            swi13(Hearsay_DataBits,0,bits,1);
}


void driversetstop(int stop)
{
 if(!active) stopbits=stop;
 else
 if(!xexec("modem_setstop",NULL,&stop,NULL)) 
                                            swi13(Hearsay_StopBits,0,stop,1);
}


void driversetparity(int parity)
{
 if(!active) paritybits=parity;
 else
 if(!xexec("modem_setparity",NULL,&parity,NULL))
                                          swi13(Hearsay_ParityBits,0,parity,1);
}



void driversetflow(int nflow)
{
 if(!active) flow=nflow;
 else
 if(!xexec("modem_setflow",NULL,&nflow,NULL))
                                          swi13(Hearsay_Flow,0,nflow,1);
}


int driverreadflow(void)
{
 int nflow;

 if(!active) nflow=flow;
 else
 if(!xexec("modem_readflow",NULL,NULL,&nflow))
                                         nflow=swi13(Hearsay_Flow,0,0,0);
 return(nflow);
}


void driversetanswer(int answer)
{
 xexec("modem_setanswer",NULL,&answer,NULL);
}


int drivertonedial(int tonedial)
{
 int r0;

 if(active && xexec("modem_tonedial",NULL,&tonedial,&r0)) return(r0);
 else                                                     return(tonedial);
}


int modemonline(void)
{
 int r0;

 if(!active) return(0);
 else
 if(xexec("modem_online",NULL,NULL,&r0)) return(r0);
 else                                    return(1);
}


/*****************************************************************************/
                    /* Hi level - what we set off the menus */


void setrxrate(int rate)
{
 driversetrxrate(rate);
 updateratesdisplay();
}


void settxrate(int rate)
{
 driversettxrate(rate);
 updateratesdisplay();
}


void setparitybits(int paritybits)
{
 driversetparity(paritybits);
 updateratesdisplay();
}


void setdatabits(int databits)
{
 driversetbits(databits);
 updateratesdisplay();
}


void setstopbits(int stopbits)
{
 driversetstop(stopbits);
 updateratesdisplay();
}


void setflow(int type)
{
 driversetflow(type);
 flow=driverreadflow();
 updateratesdisplay();
}


void setanswer(int ao)
{
 driversetanswer(ao);
 updateratesdisplay();
}


void setfilter(int sfilter)
{
 filter=sfilter;
}



/*****************************************************************************/

int statusrate;
int statusbits;
int statusmode;         /* 0 for main menu, 1 for teledir */



void setstatus(void)
{
 int rxrate=rxbitrate;
 int txrate=txbitrate;
 int stop=stopbits;
 int parity=paritybits;
 int data=databits;


 switch(statusrate)
 {

/*  case  0:
          rxrate=txrate=300;
          break;

  case  1:
          rxrate=1200;
          txrate=75;
          setanswer(0);
          break;

  case  2:
          rxrate=75;
          txrate=1200;
          setanswer(1);
          break; */


  case  0:
          rxrate=txrate=38400;
          break;

  case  1:
          rxrate=txrate=57600;
          break;

  case  2:
          rxrate=txrate=115200;
          break;

  case  3:
          rxrate=txrate=1200;
          break;

  case  4:
          rxrate=txrate=2400;
          break;

  case  5:
          rxrate=txrate=9600;
          break;

  case  6:
          rxrate=txrate=19200;
          break;
 }

 switch(statusbits)
 {
  case  7:
          data=7;
          stop=1;
          parity=1;
          break;

  case  8:
          data=8;
          stop=1;
          parity=0;
          break;
 }

 if(statusmode)  tdstatus(txrate,rxrate,data,stop,parity);
 else
 {
  settxrate(txrate);
  setrxrate(rxrate);
  setdatabits(data);
  setstopbits(stop);
  setparitybits(parity);
 }
}






void statusicon(int icon)
{
 switch(icon)
 {
  case  0:
  case  1:
  case  2:
  case  3:
  case  4:
  case  5:
  case  6:
          if(statusrate!=-1) deselect(whandle[STATUS],statusrate);
          statusrate=icon;
          select(whandle[STATUS],statusrate);
          break;

  case  7:
  case  8:
          if(statusbits!=-1) deselect(whandle[STATUS],statusbits);
          statusbits=icon;
          select(whandle[STATUS],statusbits);
          break;

  case  9:
          setstatus();
          zapmenu();
          break;
 }
}




int dynamsettingsx(int txrate,int rxrate,int sysdata,int sysparity,int stop)
{
 int i;
 int handle=createwindow(STATUS);

 statusrate=-1;
 statusbits=-1;

/*

 if(txrate==300   && rxrate==300)    statusrate=0;
 if(txrate==75    && rxrate==1200)   statusrate=1;
 if(txrate==1200  && rxrate==75)     statusrate=2;

*/

 if(txrate==38400 && rxrate==38400)   statusrate=0;
 if(txrate==57600 && rxrate==57600)   statusrate=1;
 if(txrate==115200 && rxrate==115200) statusrate=2;
 if(txrate==1200  && rxrate==1200)    statusrate=3;
 if(txrate==2400  && rxrate==2400)    statusrate=4;
 if(txrate==9600  && rxrate==9600)    statusrate=5;
 if(txrate==19200 && rxrate==19200)   statusrate=6;

 if(sysdata==8 && sysparity==0 && stop==1) statusbits=8;
 if(sysdata==7 && sysparity==1 && stop==1) statusbits=7;

 for(i=0;i<7;i++) selectst(handle,i,statusrate==i);

 selectst(handle,8,statusbits==8);
 selectst(handle,7,statusbits==7);

 return(handle);
}



int dynamsettings(void)
{
 statusmode=0;
 return(dynamsettingsx(txbitrate,rxbitrate,databits,paritybits,stopbits));
}


int dynamsettingsz(int txrate,int rxrate,int sysdata,int sysparity,
                                                     int stop,int entry)
{
 statusmode=entry;
 return(dynamsettingsx(txrate,rxrate,sysdata,sysparity,stop));
}



void popquicksetup(void)
{
 int handle;

 handle=dynamsettings();
 menuwindow(handle);
}


/*****************************************************************************/

#ifdef NEVER

void setpoptxrate(void)
{
 untickmenu(txrate_menu);
 tick(txrate_menu,bitrate2int(txbitrate));
}


void decodetxrate(int m2)
{
 int rate;

 if((rate=sdevdecoderate(m2))!=0) settxrate(rate);
 else
 if(m2>=0 && m2<MAXRATES) settxrate(bitratemap[m2]);
}


void setpoprxrate(void)
{
 untickmenu(rxrate_menu);
 tick(rxrate_menu,bitrate2int(rxbitrate));
}


void decoderxrate(int m2)
{
 int rate;

 if((rate=sdevdecoderate(m2))!=0) setrxrate(rate);
 else
 if(m2>=0 && m2<MAXRATES) setrxrate(bitratemap[m2]);
}



void decodeflow(int m2)
{
 switch(m2)
 {
  case 0:
         setflow(0);
         break;

  case 1:
         setflow(1);
         break;

  case 2:
         setflow(2);
         break;
 }
}



void setpopflow(void)
{
 tickst(flow_menu,0,flow==0);
 tickst(flow_menu,1,flow==1);
 tickst(flow_menu,2,flow==2);
}



void setpopdata(void)
{
 tickst(datab_menu,0,databits==7);
 tickst(datab_menu,1,databits==8);
 untickmenu(parity_menu);
 tick(parity_menu,paritybits);
 tickst(stopb_menu,0,stopbits==1);
 tickst(stopb_menu,1,stopbits==2);
}


void setpopsettings(void)
{
 setpoprxrate();
 setpoptxrate();
 setpopdata();
 setpopflow();
 tickst(line_menu,7,filter);
 tickst(line_menu,8,answer);
}



void decodesettings(int m1,int m2,int m3,int m4)
{
 switch(m1)
 {
  case 1:
         decodetxrate(m2);
         break;

  case 2:
         decoderxrate(m2);
         break;

  case 3:
         if(m2==1 || m2==0) setdatabits(m2+7);
         break;

  case 4:
         if(m2>=0 && m2<5)  setparitybits(m2);
         break;

  case 5:
         if(m2==1 || m2==0) setstopbits(m2+1);
         break;

  case 6:
         decodeflow(m2);
         break;

  case 7:
         setfilter(!filter);
         break;

  case 8:
         setanswer(!answer);
         break;

 }

 m3=m3;
 m4=m4;
}

#endif


static int tempfilter;
static int tempanswer;
static int temptxrate;
static int temprxrate;
static int tempdatabits;
static int tempstopbits;
static int tempparitybits;
static int tempflow;


/*
static char * flownames[3]={"None","RTS/CTS","Xon/Xoff"};
static char * paritynames[5]={"None","Even","Odd","Mark","Space"};
*/

static char * flownames[3]={"ST0","ST1","ST2"};
static char * paritynames[5]={"ST3","ST4","ST5","ST6","ST7"};



static void setpopflow(void)
{
 tickst(flow_menu,0,tempflow==0);
 tickst(flow_menu,1,tempflow==1);
 tickst(flow_menu,2,tempflow==2);
}

static void writeflow(void)
{
 writeicon(whandle[TSETUP],16,transtoken(flownames[tempflow]));
}

void decodeflow(int m2)
{
 switch(m2)
 {
  case 0:
  case 1:
  case 2:
         tempflow=m2;
         break;
 }
 setpopflow();
 writeflow();
}

static void popflow(void)
{
 setpopflow();
 popmenu(flow_menu);
}



static void setpopdata(void)
{
 tickst(datab_menu,0,tempdatabits==7);
 tickst(datab_menu,1,tempdatabits==8);
}

static void writedata(void)
{
 writeiconf(whandle[TSETUP],7,"%d",tempdatabits);
}

void decodedata(int m2)
{
 if(m2==0) tempdatabits=7;
 else      tempdatabits=8;
 writedata();
 setpopdata();
}

static void popdata(void)
{
 setpopdata();
 popmenu(datab_menu);
}




static void setpopparity(void)
{
 untickmenu(parity_menu);
 tick(parity_menu,tempparitybits);
}

static void writeparity(void)
{
 writeicon(whandle[TSETUP],10,transtoken(paritynames[tempparitybits]));
}

void decodeparity(int m2)
{
 if(m2>=0 && m2<5)  tempparitybits=m2;
 writeparity();
 setpopparity();
}

static void popparity(void)
{
 setpopparity();
 popmenu(parity_menu);
}




static void setpopstopbits(void)
{
 tickst(stopb_menu,0,tempstopbits==1);
 tickst(stopb_menu,1,tempstopbits==2);
}

static void writestop(void)
{
 writeiconf(whandle[TSETUP],13,"%d",tempstopbits);
}

void decodestop(int m2)
{
 if(m2==0) tempstopbits=1;
 else      tempstopbits=2;
 writestop();
 setpopstopbits();
}

static void popstop(void)
{
 setpopstopbits();
 popmenu(stopb_menu);
}




static void writetxrate(void)
{
 writeiconf(whandle[TSETUP],1,"%d",temptxrate);
}

static int setpoptxrate(void)
{
 if(sdevrates(temptxrate))
 {
  setrammenu(decodetxrate);
  return(1);
 }
 else
 {
  untickmenu(txrate_menu);
  tick(txrate_menu,bitrate2int(temptxrate));
  return(0);
 }
}

os_error * decodetxrate(int m2)
{
 int rate;

 if((rate=sdevdecoderate(m2))!=0) temptxrate=rate;
 else
 if(m2>=0 && m2<MAXRATES) temptxrate=bitratemap[m2];

 setpoptxrate();
 writetxrate();

 return(NULL);
}


static void poptxrate(void)
{
 if(setpoptxrate()) popmenu((int*)myrambuff);
 else               popmenu(txrate_menu);
}



static int setpoprxrate(void)
{
 if(sdevrates(temprxrate))
 {
  setrammenu(decoderxrate);
  return(1);
 }
 else
 {
  untickmenu(rxrate_menu);
  tick(rxrate_menu,bitrate2int(temprxrate));
  return(0);
 }
}

static void writerxrate(void)
{
 writeiconf(whandle[TSETUP],4,"%d",temprxrate);
}

os_error * decoderxrate(int m2)
{
 int rate;

 if((rate=sdevdecoderate(m2))!=0) temprxrate=rate;
 else
 if(m2>=0 && m2<MAXRATES) temprxrate=bitratemap[m2];

 writerxrate();
 setpoprxrate();

 return(NULL);
}


static void poprxrate(void)
{
 if(setpoprxrate()) popmenu((int*)myrambuff);
 else               popmenu(rxrate_menu);
}



void setupicon(void)
{
 int handle=whandle[TSETUP];

 switch(icon)
 {
  case 18:
          selectst(handle,18,tempfilter^=1);
          break;
  case 19:
          selectst(handle,19,tempanswer^=1);
          break;

   case 2:
          poptxrate();
          break;

   case 5:
          poprxrate();
          break;

   case 8:
          popdata();
          break;

   case 11:
           popparity();
           break;

   case 14:
           popstop();
           break;

   case 17:
           popflow();
           break;


  case 20:  /* OK */
          driversetrxrate(temprxrate);
          driversettxrate(temptxrate);
          driversetparity(tempparitybits);
          driversetbits(tempdatabits);
          driversetstop(tempstopbits);
          driversetflow(tempflow);
          flow=driverreadflow();
          driversetanswer(tempanswer);
          updateratesdisplay();
          filter=tempfilter;

  case 21:  /* Cancel */
          closedownt(TSETUP);
          break;
 }
}


void opensetup(void)
{
 int handle;

 if(whandle[TSETUP])
 {
  forward(whandle[TSETUP]);
 }
 else
 {
  handle=createwindow(TSETUP);
  if(!handle) return;

  tempfilter=filter;
  tempanswer=answer;
  temptxrate=txbitrate;
  temprxrate=rxbitrate;
  tempdatabits=databits;
  tempstopbits=stopbits;
  tempparitybits=paritybits;
  tempflow=flow;

  writeflow();
  writestop();
  writeparity();
  writedata();
  writerxrate();
  writetxrate();

  selectst(handle,18,tempfilter);
  selectst(handle,19,tempanswer);
  popup(handle,0);
 }
}



void decodesettings(int m1,int m2,int m3,int m4)
{
 if(m1==1) opensetup();

 m2=m2;
 m3=m3;
 m4=m4;
}


/*****************************************************************************/

char ratedisplay[24];

/* update baud rate display in terminals */

void updateratesdisplay(void)
{
 driverread();

 if(txbitrate>=100000 || rxbitrate>=100000)
 sprintf(ratedisplay,"%4dK/%dK  %d%c%d",txbitrate/1000,rxbitrate/1000,
                               databits,"NEOMS"[paritybits],stopbits);
 else
 sprintf(ratedisplay,"%5d/%-5d %d%c%d",txbitrate,rxbitrate,
                               databits,"NEOMS"[paritybits],stopbits);
 vxwriterates();
 vtwriterates();
 vtwritex();
}


char * onlinestr[2]={"STAT04","STAT03"};
char * onlinedisplay;
char   onlinetimedisplay[12];

int  online;                  /* THE FLAG */
int  onlinetime;              /* time we went on line */
int  onlinectime;             /* time online time was last updated */

static int units;             /* units used */
static int secleft;           /* seconds left in the current unit */
static int lastband;
static int onlineevent;       /* clean on/off event for logging   */


static int brate[MAXBAND][3]=
{
 24000,8500,6000,
 8525,3615,2700,
 5300,3200,2395,
 3990,2560,1920,
 1140,761,761
};



/* script interface void setband(int band,int rate1,int rate2,int rate3); */

void setband(int fp)
{
 int i;
 int band=stack[fp]-1;

 if(band>=0 && band<MAXBAND)
 {
  for(i=0;i<3;i++) brate[band][i]=stack[fp+1+i];
 }
}


/* setcurband(int band) */

void setcurband(int fp)
{
 band=stack[fp];
}




int rtcoff;
int day;


int bcd(int bcdb,char * times)
{
 bcdb=times[bcdb];
 return((bcdb & 0xF)+((bcdb & 0xF0)>>4)*10);
}



void bootrtc(void)
{
 int hh,mm,ss;
 char times[25];

 times[0]=1;
 os_word(14,&times[0]);

 day=bcd(3,times);
 hh =bcd(4,times);
 mm =bcd(5,times);
 ss =bcd(6,times);

 rtcoff=hh*360000+mm*6000+ss*100-clock();
}



int unitsize(int hour)
{
 int tz;

 if(day==1 || day==7) tz=0;
 else if(hour<8)      tz=0;
 else if(hour<9)      tz=1;
 else if(hour<13)     tz=2;
 else if(hour<18)     tz=1;
 else                 tz=0;

 return(brate[band-1][tz]);
}




void onlinezero(void)
{
 int mline;

 if(zerotime>onlinectime)
 {
  mline=modemonline();
  if(mline && online)
  {
   if(band==-1)
   {
    writehms(onlinetimedisplay,(zerotime+rtcoff));
   }
   else
   if(band==0)
   {
    writehms(onlinetimedisplay,(zerotime-onlinetime));
   }
   else
   {
    int unitsi;
    int units2;
    int diff;
    int hour;

    hour=(zerotime+rtcoff)/(100*60*60);
    if(hour==24)
    {
     bootrtc();
     hour=0;
     day++;
     if(day==8) day=1;
    }

    unitsi=unitsize(hour);
    diff=zerotime-lastband;
    if(secleft>diff) secleft-=diff;
    else
    {
     diff-=secleft;
     secleft=unitsi;
     units+=1+(units2=diff/unitsi);
     secleft-=(diff-units2*unitsi);
    }
    sprintf(onlinetimedisplay,"%-3d:%4d",units,secleft/100);
    lastband=zerotime;
   }

   onlinectime=zerotime+100;
   vtwritetime();
   vxwritetime();
  }
  else
  if(mline && !online) goonline();
  else
  if(!mline && online)
  {
   /* writetolog("Offline.\n"); */
   gooffline();
  }
 }
}



void onlinechange(void)
{
 int mline;
 mline=modemonline();

 if(mline && !online) goonline();
 else
 if(!mline && online) gooffline();
}


void goonline(void)
{
 online=1;
 onlinedisplay=transtoken(onlinestr[online]);
 updateratesdisplay();
 vtwriteonline();
 vxwriteonline();
 onlinetime=zerotime;

 secleft=0;
 units=0;
 onlineevent=1;
 lastband=zerotime;
 bootrtc();

 addzeroevent(ONZERO);

 xexec("sys_online",sysname,&online,NULL);
                                
 if(inlinktype==2) mnplinkneg();

 writetolog("{LOG02}",sysname);
}



void gooffline(void)
{
 online=0;
 onlinedisplay=transtoken(onlinestr[online]);
 updateratesdisplay();
 vtwriteonline();
 vxwriteonline();
 remzeroevent(ONZERO);

 xexec("sys_online",sysname,&online,NULL);

 if(onlineevent)
 {
  if(band>0) writetolog("{LOG00}\n",sysname,(zerotime-onlinetime)/100,units);
  else       writetolog("{LOG01}\n",sysname,(zerotime-onlinetime)/100);
  onlineevent=0;
 }
}



void xonlinechange(int fp)
{
 if(stack[fp]) goonline();
 else          gooffline();
}



void onlinestart(void)
{
 online=0;
 onlinectime=onlinetime=0;
 onlinedisplay=transtoken(onlinestr[online]);
 strcpy(onlinetimedisplay,"00:00:00");
}




/*****************************************************************************/

int shortbreaktime=25;
int longbreaktime=350;

int conactive;


void commsfnclosewindow(void)
{
 if(whandle[COMMSFN]) wimp_close_wind(whandle[COMMSFN]);
}


void commsfnopenwindow(void)
{
 int handle;
 int w;
 int h;

 if(vtopen || vxopen || tekopen)
 {
  handle=whandle[COMMSFN];
  if(handle)
  {
   getw(handle);
   w=x1-x0;
   h=y1-y0;

   if(vtopen) getw(whandle[VTERM]);
   else
   if(vxopen) getw(whandle[VDATA]);
   else       getw(whandle[TEK]);

   /* was open(handle,x0,y1-h-hscrlbar,x0+w,y1-hscrlbar,0,0,bhandle); */
   open(handle,x1-w,y1-h,x1,y1,0,0,bhandle);
  }
 }
}


int setconactive(char * why)
{
 int handle;

 why=transtoken(why);

 if(!conactive)
 {
  handle=createwindow(COMMSFN);
  if(handle) writeicon(handle,1,why);
  commsfnopenwindow();
  conactive=1;
  return(0);
 }
 else return(1);
}


void clearconactive(void)
{
 if(whandle[COMMSFN]) closedownt(COMMSFN);
 conactive=0;
}


void commsicon(void)
{
 if(!icon)
 {
  xexec("modem_interrupt",NULL,NULL,NULL);
  zruns=0;
  znoerror=1;
 }
}

/*****************************************************************************/


int diallo(char * number,int doprefix)
{
 char temp[PREFIXLEN+NUMLEN];
 int  code;

 code=1;

 if(!setconactive("CON0")) /* Dialling */
 {
  if(prefix && doprefix)
  {
   scrunch(0);
   strcpy(temp,prefixstring);
   scrunch(1);
  }
  else                   *temp=0;
  strcat(temp,number);

  code=xexec("modem_dial",temp,NULL,NULL);

  clearconactive();
 }

 return(code);
}


void dial(char * number)
{
 if(!conactive)
 {
  strcpy(sysname,number);
  diallo(number,1);
  /* if(online) writetolog("Online to %s.\n",number); */
 }
}


void xdial(int fp)
{
 char number[64];
 strcpy(number,stringptr(stack[fp]));
 dial(number);
}


void connect(void)
{
 if(!setconactive("CON1")) /* Connect */
 {
  xexec("modem_connect",NULL,NULL,NULL);
/*  writetolog("Connect.\n"); */
  strcpy(sysname,transtoken("CON2"));  /* Direct connection */
  clearconactive();
 }
}


void xconnect(int fp)
{
 fp=0;
 connect();
}



void disconnect(void)
{
 if(!setconactive("CON3"))  /* Disconnect */
 {
  if(inlinktype==2) mnplinktrash();

  xexec("modem_disconnect",NULL,NULL,NULL);
 /* writetolog("Disconnect.\n"); */
  clearconactive();
 }
}


void xdisconnect(int fp)
{
 fp=0;
 disconnect();
}


void talk2modem(void)
{
 if(!setconactive("CON4")) /*Talk to modem */
 {
  xexec("modem_talk",NULL,NULL,NULL);
  clearconactive();
 }
}


void xtalk2modem(int fp)
{
 fp=0;
 talk2modem();
}


void reconnect(void)
{
 if(!setconactive("CON5")) /* Reconnect */
 {
  xexec("modem_reconnect",NULL,NULL,NULL);
  clearconactive();
 }
}

void xreconnect(int fp)
{
 fp=0;
 reconnect();
}


void shortbreak(void)
{
 if(!setconactive("CON6"))   /* Short break */
 {
  xexec("modem_break",NULL,&shortbreaktime,NULL);
  clearconactive();
 }
}



void longbreak(void)
{
 if(!setconactive("CON7")) /* Long break */
 {
  xexec("modem_break",NULL,&longbreaktime,NULL);
  clearconactive();
 }
}



void xautoanswer(int fp)
{
 int rings;

 if(!setconactive("CON8")) /* Auto answer */
 {
  rings=stack[fp];
  xexec("modem_autoanswer",NULL,&rings,NULL);
  clearconactive();
 }
}



/*****************************************************************************/


static int newdatatime;
static int newdatastate;

void newdatazero(void)
{
 if(zerotime>newdatatime)
 {
  sethearsayicon(newdatastate^=1);
  newdatatime=zerotime+100;
 }
}


void setnewdata(int on)
{
 if(on)
 {
  addzeroevent(NDATAZERO);
 }
 else
 {
  remzeroevent(NDATAZERO);
  if(newdatastate) sethearsayicon(0);
 }
}



static char title[32];


char * terminalname(char * tname)
{
 static char ttitle[64];

 sprintf(ttitle,"%s (%s)",title,tname);

 return(ttitle);
}


void sethearsaytitle(int fp)
{
 strcpy(title,stringptr(stack[fp]));
 sethearsayicontext(title);
}


