/*->c.vxmenu */

#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.bbc"
#include "h.flex"


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

#include "h.key"
#include "h.term"
#include "h.pr"

#include "h.vtfile"


#include "h.vxdef"

#include "h.vxkey"
#include "h.vxwimp"
#include "h.vxbuff"
#include "h.vxsend"
#include "h.vxprint"
#include "h.vxterm"

#include "h.vxmenu"



/***************************************************************************/
/*
 Code to handle Viewdata menus
*/
/*****************************************************************************/







/****************************************************************************/
/* buffer menus */


int vxbmenu;            /* the buffer number that the menu was popped on */


void setpopvxbmain(void)
{
 unshadest(vxbmain_menu,0,vxbuff[vxbmenu].noframes);
 unshadest(vxbmain_menu,1,vxbuff[vxbmenu].noframes);
 unshadest(vxbmain_menu,2,vxbuff[vxbmenu].noframes);
 tickst(vxbmain_menu,6,vxbuff[vxbmenu].tools);
}



void decodevxbmain(int m1,int m2,int m3)
{

 switch(m1)
 {
  case 0:
         vxbgoto(vxbmenu);
         break;

  case 1:
         vxbpaste(vxbmenu);
         break;

  case 2:
         vxbdelete(vxbmenu);
         break;

  case 3:                                  /* save buffer */

         break;

  case 4:                                  /* save as text */

         break;

  case 5:
         vxdeletebuffern(vxbmenu,1);
         if(!vxbuff[vxbmenu].inuse)   /* !!! special case buffer lost */
         {
        /*  repopf=0;
          return; */
         }
         break;

  case 6:
         vxtoggletools(vxbmenu);
         break;
 }

 m2=m3;

 setpopvxbmain();
}




void popvxbmain(void)
{
 vxbmenu=vxnb;
 setpopvxbmain();
 popmenu(vxbmain_menu);
}


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





/* sort out buffer menus */

void setpopvxbuff(void)
{
 int i;
 int j;

 unshadest(vxbuff_menu,0,vxnobuffers<MAXBUFF);
 unshadest(vxbuff_menu,1,vxnobuffers);
 unshadest(vxbuff_menu,2,vxnobuffers);
 unshadest(vxbuff_menu,3,vxnobuffers);
 unshadest(vxbuff_menu,4,vxnobuffers);

 j=0;
 for(i=0;i<MAXBUFF;i++)
 {
  if(vxbuff[i].inuse)
  {
   tickst(vxbuff_menu,j+5,i==vxcbuff);
   writemenu(vxbuff_menu,j+5,vxbuff[i].wname);
   j++;
  }
 }

 for(i=0;i<=vxnobuffers;i++)
 {
  menumakelastst(vxbuff_menu,4+i,i==vxnobuffers);
 }

}



void decodevxbuff(int m1,int m2)
{
 switch(m1)
 {

  case  0:    /* new buffer */
          vxnewbuffer(menuaddr(vxbname_menu,0));
          break;

  case  1:    /* save buffer as frame file */

          break;
   
  case  2:    /* save buffer as text file */

          break;

  case  3:    /* show buffer */
          vxshowbuffer();
          break;

  case  4:    /* delete buffer */
          vxdeletebuffer();
          break;

  default:
          if(m1>=5)
          {
           m1-=5;
           for(vxcbuff=0;vxcbuff<MAXBUFF;vxcbuff++)
           {
            if(vxbuff[vxcbuff].inuse) m1--;
            if(m1<0) break;
           }
           if(vxcbuff>=MAXBUFF) vxcbuff=-1;

           vxbupdatecurrent();
          }
          break;
 }

 m2=0;
}






void setpopvxfile(void)
{
 setpopvxbuff();

 unshadest(vxfile_menu,4,spfp==NULL);
 unshadest(vxfile_menu,5,spfp!=NULL);
 unshadest(vxfile_menu,6,spfp!=NULL);
 tickst(vxfile_menu,5,spoolflag);
 tickst(vxfile_menu,7,spconcode);
 tickst(vxfile_menu,8,vxinvert);
 tickst(vxfile_menu,9,vxhearsayff);
}



void decodevxfile(int m2,int m3,int m4)
{
 switch(m2)
 {
  case 0:                         /* -> buffer menu */
         decodevxbuff(m3,m4);
         break;

  case 1:                         /* save */
         break;


  case 2:                         /* save */
         break;


  case 3:                         /* save */
         break;


  case 4:                         /* open spool */
         break;

  case 5:                         /* toggle spool */
         spooltoggle();
         break;

  case 6:                         /* close spool file */
         spoolclose();
         break;

  case 7:                         /* toggle ctrl state */
         spoolcont();
         break;

  case 8:
         vxinvert^=1;
         break;

  case 9:
         vxhearsayff^=1;
         setvxframesize();
         break;
 }
}



void setpopvxact(void)
{
 int n;

 unshadest(vxact_menu,1,vxnobuffers && vxbuff[vxcbuff].noframes);
 unshadest(vxact_menu,2,vxnobuffers && vxbuff[vxcbuff].noframes);

 unshadest(vxact_menu,3,!minitel);
 unshadest(vxact_menu,4,!minitel);

 n=vxnobuffers?vxcframenumber(vxcbuff):0;

 sprintf(menuaddr(vxact_menu,1),transtoken("VX0"),n); /* Replace(%d) */
 sprintf(menuaddr(vxact_menu,2),transtoken("VX1"),n); /* Insert(%d) */
}



void decodevxact(int m2,int m3,int m4)
{

 switch(m2)
 {

  case 0:
         vxbcopy(vxcbuff);
         break;

  case 1:
         vxbinsert(vxcbuff);
         break;

  case 2:
         vxbreplace(vxcbuff);
         break;

  case 3:                         /* send frame */
         sendscreen();
         break;

  case 4:
         vxgombxref();
         break;
 }

 m2=m3=m4;
}

/*****************************************************************************/
/* Setup printer */


#ifdef NEVER

void setpopvxprinter(void)
{
 int i;

 for(i=1;i<4;i++) tickst(vxprint_menu,i,(vxdump+1)==i);

 tickst(vxprint_menu,4,vxpset.flags & PORT);

 writemenuf(vxxscale_menu,0,"%d%%",(vxpset.xmul*100)/vxpset.xdiv);
 writemenuf(vxyscale_menu,0,"%d%%",(vxpset.ymul*100)/vxpset.ydiv);
 gsprint(menuaddr(vxxcorner_menu,0),vxpset.cx,1);
 gsprint(menuaddr(vxycorner_menu,0),vxpset.cy,1);

 tickst(vxprint_menu,9,vxprintff);
}



void decodevxprinter(int m2,int m3,int m4)
{
 switch(m2)
 {
  case 0:
         printframe(&vscr);
         break;

  case 1:           /* text              */
  case 2:           /* negative graphics */
  case 3:           /* positive graphics */
         vxdump=m2-1;
         break;

  case 4:
         vxpset.flags^=PORT;
         break;

  case 5:               /* X scale */
         if(m3==0)
         {
          int temp;
          if(getmenuint(vxxscale_menu,0,&temp))
          {
           vxpset.xmul=temp;
           vxpset.xdiv=100;
          }
         }
         break;

  case 6:              /* Y scale */
         if(m3==0)
         {
          int temp;
          if(getmenuint(vxyscale_menu,0,&temp))
          {
           vxpset.ymul=temp;
           vxpset.ydiv=100;
          }
         }
         break;

  case 7:              /* Corner X */
         if(m3==0)
         {
          int temp;
          int minus;

          temp=scang(menuaddr(vxxcorner_menu,0),&minus);
          if(temp>=0)
          {
           vxpset.cx=minus?-temp:temp;
          }
         }
         break;

  case 8:              /* Corner Y */
         if(m3==0)
         {
          int temp;
          int minus;

          temp=scang(menuaddr(vxycorner_menu,0),&minus);
          if(temp>=0)
          {
           vxpset.cy=minus?-temp:temp;
          }
         }
         break;

  case 9:
         vxprintff^=1;
         break;
 }

 m3=m4;
}


#endif









              /* N L R D U */

static char entryiclst[4][5]=
{
          6,          0,           8,           8,            0,
          8,          6,           0,          10,            6,
         10,          0,          12,          12,            8,
         12,         10,           0,           0,           10,
};




void vxprintkey(int * key)
{
 int cicon;
 int j;
 int ch;

 ch=*key;

 switch(ch)
 {
       case 27:
               zapmenu();
               break;

       case CR:
               ch=CDOWN;

    case 0x18E:
    case 0x18F:
    case 0x19C:
    case 0x19D:
    case 0x19E:
    case 0x19F:
               ch&=0x18F;
               for(j=0;j<4;j++) if(entryiclst[j][0]==icon) break;
               cicon=entryiclst[j][(ch-0x18B)];
               if(cicon) iecarrot(whandle[VXPRINT],cicon);
               break;

    default:return;
 }
 *key=-1;
}






void vxprinticon(void)
{
 int handle=whandle[VXPRINT];
 int temp;
 int minus;

 switch(icon)
 {
  case  0:
  case  1:
  case  2:
          if(icon!=vxdump)
          {
           deselect(handle,vxdump);
           select(handle,icon);
           vxdump=icon;
          }
          break;

  case  3:
  case  4:
          if(icon==3 && !(vxpset.flags & PORT)) vxpset.flags|=PORT;
          else
          if(icon==4 &&  (vxpset.flags & PORT)) vxpset.flags&=~PORT;
          else break;
          selectst(handle,3,vxpset.flags & PORT);
          selectst(handle,4,!(vxpset.flags & PORT));
          break;

  case 13:
          selectst(handle,13,vxprintff^=1);
          break;

  case 14:
          if(geticonint(handle,6,&temp))  /* X scale */
          {
           vxpset.xmul=temp;
           vxpset.xdiv=100;
          }

          if(geticonint(handle,8,&temp))  /* Y scale */
          {
           vxpset.ymul=temp;
           vxpset.ydiv=100;
          }

          temp=scang(iconaddr(handle,10),&minus);   /* Corner X */
          if(temp>=0)
          {
           vxpset.cx=minus?-temp:temp;
          }

          temp=scang(iconaddr(handle,12),&minus);   /* Corner Y */
          if(temp>=0)
          {
           vxpset.cy=minus?-temp:temp;
          }

          zapmenu();
          printframe(&vscr);
          break;
 }
}


int vxprintsetup(void)
{
 int i;
 int handle=createwindow(VXPRINT);
 
 for(i=0;i<3;i++) selectst(handle,i,vxdump==i);
 selectst(handle,13,vxprintff);

 selectst(handle,3,vxpset.flags & PORT);
 selectst(handle,4,!(vxpset.flags & PORT));

 writeiconf(handle,6,"%d%%",(vxpset.xmul*100)/vxpset.xdiv);
 writeiconf(handle,8,"%d%%",(vxpset.ymul*100)/vxpset.ydiv);

 gsprint(iconaddr(handle,10),vxpset.cx,1);
 gsprint(iconaddr(handle,12),vxpset.cy,1);

 return(handle);
}


void popvxprint(void)
{
 int handle;
 handle=vxprintsetup();
 menuwindow(handle);
}



/*****************************************************************************/
/* Viewdata terminal set up menus */


#ifdef NEVER

/* Setup display */

void setpopvxdisplay(void)
{
 tickst(vxdisp_menu,0,vxkeypad);
 tickst(vxdisp_menu,2,vxblock);
 tickst(vxdisp_menu,1,vxcurs);
}



void  decodevxdisplay(int m3,int m4)
{
 switch(m3)
 {
  case 0:
         togglekeypad();
         break;

  case 2:
         vxblock^=1;
         break;

  case 1:
         vxsetcursor();      /* now this looks odd, but it's right */
         vxcurs^=1;
         vxsetcursor();
         break;

 }

 m4=0;
}

#endif

static int tempvxblock;
static int tempvxcurs;
static int tempvxkeypad;


void vxdisplayicon(void)
{
 int handle=whandle[TDISPLAYVX];

 switch(icon)
 {
  case 0:
         selectst(handle,0,tempvxkeypad^=1);
         break;

  case 1:
         selectst(handle,1,tempvxcurs^=1);
         break;

  case 2:
         selectst(handle,2,tempvxblock^=1);
         break;

  case 3:
         if(vxkeypad!=tempvxkeypad) togglekeypad();
         vxsetcursor();
         vxcurs=tempvxcurs;
         vxblock=tempvxblock;
         vxsetcursor();
         if(buttons==0x4) zapmenu();
         break;
 }
}


int setupvxdisplay(void)
{
 int handle=createwindow(TDISPLAYVX);

 tempvxkeypad=vxkeypad;
 tempvxcurs=vxcurs;
 tempvxblock=vxblock;
 
 selectst(handle,0,tempvxkeypad);
 selectst(handle,1,tempvxcurs);
 selectst(handle,2,tempvxblock);

 return(handle);
}



#ifdef NEVER

/* Setup keyboard */

void setpopvxkeyboard(void)
{
 tickst(vxkey_menu,0,(!ttns && vxreturnishash)||(ttns && campusreturnishash));
 tickst(vxkey_menu,1,vxauto);
}


void decodevxkeyboard(int m3,int m4)
{
 switch(m3)
 {
  case 0:
         if(ttns) campusreturnishash^=1;
         else     vxreturnishash^=1;
         break;

  case 1:
         vxauto^=1;
         keyboardoncaret(1);
         break;

  case 2:
         macrosshow();
         break;
 }
 m3=m4;
}

#endif



static int tempreturnishash;
static int tempvxauto;

void vxkeyicon(void)
{
 int handle=whandle[TKEYVX];

 switch(icon)
 {
  case 0:
         selectst(handle,0,tempreturnishash^=1);
         break;

  case 1:
         selectst(handle,1,tempvxauto^=1);
         break;

  case 2:
         vxauto=tempvxauto;
         if(ttns) campusreturnishash=tempreturnishash;
         else     vxreturnishash=tempreturnishash;
         keyboardoncaret(1);
         if(buttons==0x4) zapmenu();
         break;
 }
}


int setupvxkey(void)
{
 int handle=createwindow(TKEYVX);

 tempvxauto=vxauto;
 if(ttns) tempreturnishash=campusreturnishash;
 else     tempreturnishash=vxreturnishash;
 
 selectst(handle,0,tempreturnishash);
 selectst(handle,1,tempvxauto);

 return(handle);
}





/* Setup line mode */


#ifdef NEVER


void setpopvxlinemode(void)
{
 tickst(vxlmode_menu,0,vxlocal);
 tickst(vxlmode_menu,1,terminalmode==TMODEVX);
 tickst(vxlmode_menu,2,vxlocalecho);
 tickst(vxlmode_menu,3,vxtxcrlnf);
 tickst(vxlmode_menu,4,vxrxcrlnf);
 tickst(vxlmode_menu,5,concode==2);
 tickst(vxlmode_menu,6,concode==1);
 tickst(vxlmode_menu,7,vxbit8c);
}



void decodevxlinemode(int m3)
{
 switch(m3)
 {
  case 0:
         vxlocal^=1;
         break;

  case 1:
         if(terminalmode==TMODEVX) terminalmode=TMODENUL;
         else                      terminalmode=TMODEVX;
         terminalmodeset=terminalmode;
         break;

  case 2:
         vxlocalecho^=1;
         break;

  case 3:
         vxtxcrlnf^=1;
         break;

  case 4:
         vxrxcrlnf^=1;
         break;

  case 5:
         if(concode==TERMIGNRCTRLS) concode=TERMEXECCTRLS;
         else                       concode=TERMIGNRCTRLS;
         break;

  case 6:
         if(concode==TERMDISPCTRLS) concode=TERMEXECCTRLS;
         else                       concode=TERMDISPCTRLS;
         break;

  case 7:
         vxbit8c^=1;
         break;
 }
}

#endif


static int templocalmode;
static int temptmode;
static int tempechomode;
static int temptxcrlnf;
static int temprxcrlnf;
static int tempconcode;
static int tempbit8c;



void vxlinemodeicon(void)
{
 int handle=whandle[TLINEMODE];

 switch(icon)
 {
  case 0:
         selectst(handle,0,templocalmode^=1);
         break;

  case 1:
         if(temptmode==TMODEVX) temptmode=TMODENUL;
         else                   temptmode=TMODEVX;
         selectst(handle,1,temptmode==TMODEVX);
         break;

  case 2:
         selectst(handle,2,tempechomode^=1);
         break;

  case 3:
         selectst(handle,3,tempbit8c^=1);
         break;

  case 4:
         selectst(handle,4,temptxcrlnf^=1);
         break;

  case 5:
         selectst(handle,5,temprxcrlnf^=1);
         break;

  case 6:
         if(tempconcode==TERMIGNRCTRLS) tempconcode=TERMEXECCTRLS;
         else                           tempconcode=TERMIGNRCTRLS;

         selectst(handle,6,
                    tempconcode==TERMDISPCTRLS || tempconcode==TERMEXECCTRLS);
         selectst(handle,7,tempconcode==TERMDISPCTRLS);
         shadeiconst(handle,7,tempconcode==TERMIGNRCTRLS);
         break;

  case 7:
         if(tempconcode==TERMDISPCTRLS) tempconcode=TERMEXECCTRLS;
         else                           tempconcode=TERMDISPCTRLS;

         selectst(handle,6,
                   tempconcode==TERMDISPCTRLS || tempconcode==TERMEXECCTRLS);
         selectst(handle,7,tempconcode==TERMDISPCTRLS);
         shadeiconst(handle,7,tempconcode==TERMIGNRCTRLS);
         break;

  case 8:
         vxlocal=templocalmode;

         terminalmode=temptmode;
         terminalmodeset=terminalmode;

         vxlocalecho=tempechomode;
         vxtxcrlnf=temptxcrlnf;
         vxrxcrlnf=temprxcrlnf;
         concode=tempconcode;
         vxbit8c=tempbit8c;

         if(buttons==0x4) zapmenu();
         break;
 }
}


int setupvxlinemode(void)
{
 int handle=createwindow(TLINEMODE);

 linemodeswitch=0;

 templocalmode=vxlocal;
 temptmode=terminalmode;
 tempechomode=vxlocalecho;
 temptxcrlnf=vxtxcrlnf;
 temprxcrlnf=vxrxcrlnf;
 tempconcode=concode;
 tempbit8c=vxbit8c;

 selectst(handle,0,templocalmode);
 selectst(handle,1,temptmode==TMODEVX);
 selectst(handle,2,tempechomode);
 selectst(handle,3,tempbit8c);
 selectst(handle,4,temptxcrlnf);
 selectst(handle,5,temprxcrlnf);

 selectst(handle,6,tempconcode==TERMDISPCTRLS || tempconcode==TERMEXECCTRLS);
 selectst(handle,7,tempconcode==TERMDISPCTRLS);
 shadeiconst(handle,7,tempconcode==TERMIGNRCTRLS);

 return(handle);
}




static int tempvxechocheck;
static int tempvxshortlines;
static int tempvxbeep;
static int tempvxescseq;



void miscvxicon(void)
{
 int handle=whandle[TMISCVX];

 switch(icon)
 {
  case  4:
          selectst(handle,4,tempvxbeep^=1);
          break;

  case 11:
          selectst(handle,11,tempvxescseq^=1);
          break;

  case 18:
          selectst(handle,18,tempvxechocheck^=1);
          break;

  case 20:
          selectst(handle,20,tempvxshortlines^=1);
          break;

  case 21:
          vxechocheck=tempvxechocheck;
          vxshortlines=tempvxshortlines;
          vxbeep=tempvxbeep;
          vxescseq=tempvxescseq;

          strcpy(vxanswerbackstring,iconaddr(handle,1));
          strcpy(vxmbxreply,iconaddr(handle,3));
          strcpy(vxprefix,iconaddr(handle,8));
          strcpy(vxsuffix,iconaddr(handle,10));
          strcpy(vxaseq,iconaddr(handle,13));
          strcpy(vxatseq,iconaddr(handle,15));
          strcpy(vxsolseq,iconaddr(handle,17));
          strcpy(vxechopacestring,iconaddr(handle,19));

          if(buttons==0x4) zapmenu();
          break;
 }
}





              /* N L R D U */

static char miscentryiclst[8][5]=
{
          1,          0,           8,           3,            0,
          3,          0,           0,           8,            1,
          8,          0,           0,          10,            3,
         10,          0,           0,          13,            8,
         13,          0,           0,          15,           10,
         15,          0,           0,          17,           13,
         17,          0,           0,          19,           15,
         19,          0,           0,           0,           17
};




void vxmisckey(int * key)
{
 int cicon;
 int j;
 int ch;

 ch=*key;

 switch(ch)
 {
       case 27:
               zapmenu();
               break;

       case CR:
               ch=CDOWN;

    case 0x18E:
    case 0x18F:
    case 0x19C:
    case 0x19D:
    case 0x19E:
    case 0x19F:
               ch&=0x18F;
               for(j=0;j<8;j++) if(miscentryiclst[j][0]==icon) break;
               cicon=miscentryiclst[j][(ch-0x18B)];
               if(cicon) iecarrot(whandle[TMISCVX],cicon);
               break;

    default:return;
 }
 *key=-1;
}



int setupmiscvx(void)
{
 int handle=createwindow(TMISCVX);

 tempvxbeep=vxbeep;
 tempvxescseq=vxescseq;
 tempvxechocheck=vxechocheck;
 tempvxshortlines=vxshortlines;

 writeicon(handle,1,vxanswerbackstring);
 writeicon(handle,3,vxmbxreply);
 writeicon(handle,8,vxprefix);
 writeicon(handle,10,vxsuffix);
 writeicon(handle,13,vxaseq);
 writeicon(handle,15,vxatseq);
 writeicon(handle,17,vxsolseq);
 writeicon(handle,19,vxechopacestring);

 selectst(handle,4,tempvxbeep);
 selectst(handle,11,tempvxescseq);
 selectst(handle,18,tempvxechocheck);
 selectst(handle,20,tempvxshortlines);

 return(handle);
}



/*****************************************************************************/
/* CET FTP menus */

static int  tempvxslotel;
static int  tempvxcetel;
static int  tempvxautoresume;


#ifdef NEVER

void setpopcet(void)
{
 tickst(cet_menu,0,vxslotel);
 tickst(cet_menu,1,vxcetel);
 tickst(cet_menu,3,vxautoresume);
}


void decodecet(int m2,int m3,int m4)
{

 switch(m2)
 {
  case 0:
         vxslotel^=1;
         break;

  case 1:
         vxcetel^=1;
         break;

  case 3:
         vxautoresume^=1;
         break;
 }

 m3=m4;
}

#endif


static void cetclose(void)
{
 vxslotel=tempvxslotel;
 vxcetel=tempvxcetel;
 vxautoresume=tempvxautoresume;
 strcpy(vxceteol,iconaddr(whandle[TCET],1));
}




void ceticon(void)
{
 int handle=whandle[TCET];

 switch(icon)
 {
  case 2:
         selectst(handle,2,tempvxslotel^=1);
         break;

  case 3:
         selectst(handle,3,tempvxcetel^=1);
         break;

  case 4:
         selectst(handle,4,tempvxautoresume^=1);
         break;

  case 5:
         cetclose();
         if(buttons==0x4) zapmenu();
         break;
 }
}


void cetkey(int * key)
{
 if(*key==RETURN) cetclose();
 else
 if(*key!=ESCAPE) return;
 zapmenu();
 *key=-1;
}


int cetsetup(void)
{
 int handle=createwindow(TCET);

 tempvxslotel=vxslotel;
 tempvxcetel=vxcetel;
 tempvxautoresume=vxautoresume;
 
 selectst(handle,2,tempvxslotel);
 selectst(handle,3,tempvxcetel);
 selectst(handle,4,tempvxautoresume);
 writeicon(handle,1,vxceteol);

 return(handle);
}


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

#ifdef NEVER

void setpopvxsend(void)
{
 tickst(vxsendsetup_menu,2,vxescseq);
 tickst(vxsendsetup_menu,3,vxshortlines);
 tickst(vxsendsetup_menu,4,vxechocheck);
}


void decodevxsend(int m4)
{

 switch(m4)
 {
  case 0:         /* prefix */
         break;

  case 1:         /* suffix */
         break;

  case 2:
         vxescseq^=1;
         break;

  case 3:
         vxshortlines^=1;
         break;

  case 4:
         vxechocheck^=1;
         break;
 }

}




/* General setup */


void setpopvxgeneral(void)
{
 setpopvxlinemode();
 setpopvxsend();
 tickst(vxgen_menu,5,vxbeep);

 unshadest(vxgen_menu,2,!minitel);
 unshadest(vxgen_menu,3,!minitel);
}




void decodevxgeneral(int m3,int m4)
{
 switch(m3)
 {
  case 0:
         decodevxlinemode(m4);
         break;

  case 1:
         break;

  case 2:
         break;

  case 3:
         decodevxsend(m4);
         break;

  case 4:   /* reset */
         vxreset();
         break;

  case 5:
         vxbeep^=1;
         break;

 }
 m3=m4;
}


#endif




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


static void decodesetup(int m2,int m3,int m4)
{
 switch(m2)
 {
  case 5:
         macrosshow();
         break;

  case 6:
         vxreset();
         break;
 }

 m3=m3;
 m4=m4;
}


void setpopvxterm(void)
{
 setpopvxfile();
 setpopvxact();
}



void decodevxterm(int m1,int m2,int m3,int m4)
{
 switch(m1)
 {
  case 0:
         decodevxfile(m2,m3,m4);
         break;

  case 1:
         decodevxact(m2,m3,m4);
         break;

  case 3:
         decodesetup(m2,m3,m4);
         break;

 }
}


