/*->c.vxedit */

#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.akbd"


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




#include "h.vxdef"
#include "h.vxcol"
#include "h.vxwimp"
#include "h.vxbuff"
#include "h.vxterm"
#include "h.vxkey"
#include "h.vxsend"


#include "h.vxedit"





/***************************************************************************/
/*
 Code to edit Viewdata frames
*/
/*****************************************************************************/


#define MAXTOOLS  8

#define VXTNONE   -1
#define VXTTEXT   0
#define VXTCOPY   1
#define VXTMOVE   2
#define VXTDELETE 3
#define VXTCUT    4
#define VXTPASTE  5
#define VXTPIXEL  6
#define VXTCLS    7




static char toolstring[MAXTOOLS][8]=
              {
               "VXED00", /*  Text editor */
               "VXED01", /*  Copy blocks */
               "VXED02", /* Move blocks */
               "VXED03", /*  Delete blocks */
               "VXED04", /*  Save block */
               "VXED05", /*  Paste block */
               "VXED06", /* Pixel editor */
               "VXED07", /* Clear screen */
              };



static int vxtool;         /* current tool */



static int trashstack;            /* stack pointer to editor trash */
static int oldx;
static int oldy;                  /* current pointer char. */
static int oldcode;
static int oldbyte;
       int vxecurcolour;
static int oldcurcolour;


int oldpix;                /* current pixel */
int pixel;                 /* are we in pixel editor */



int box0;
int box1;

int dx0;         /* rubber box coordinates */
int dx1;
int dy0;
int dy1;

int idx0;        /* the initial values for dx0 and dy1 */
int idy1;


int cx0;
int cx1;
int cy0;
int cy1;


static int sax0;
static int sax1;
static int say0;
static int say1;
static int saved;

char * savebuff;


static int tempx[2];
static int tempy[2];

static char * trashbuff=NULL;  /* area to put lines that drop off screen */







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


/* set mttvx,mttvy to current mouse position */

void vxgetxyh(int handle,vxscreen * vsc)
{
 getw(handle);

 mttvx=(mousex-bx)/VXDX;
 mttvy=(by-mousey)/VXDY;

 if(mttvy>23) mttvy=23;
 else
 if(mttvy<0)  mttvy=0;

 if(mttvx<0)  mttvx=0;
 else
 if(mttvx>39) mttvx=39;
}


void vxgetxy(void)
{
 vxgetxyh(whandle[VDATA],vscr);
}



static void setpixelgrid(int set)
{
 vscr->pixelgrid=set;
 vxrefreshwindow(whandle[VDATA],vscr);
}



static void stackcursor(int i)
{
 tempx[i]=ttvx;
 tempy[i]=ttvy;
}


static void destackcursor(int i)
{
 ttvx=tempx[i];
 ttvy=tempy[i];
}


/* many assumptions, like called after a getw, and set up on mttvx */
/* update true when called from drag                               */


void setpix(int update)
{
 int x;
 int y;
 int mask;
 int mul;
 int byte;
 static int mode;

 int tempx=mttvx;
 int tempy=mttvy;


 if(update)
 {
  if(buttons==0x100 || buttons==0x1 || buttons==0x10) mode=2;
  else
  if(buttons==0x400 || buttons==0x4 || buttons==0x40) 
  {
   if(isshift) mode=0;
   else        mode=1;
  }
  else return;

  oldpix=-1;
 }

 if(vscr->attr[tempy]==VXADHB) tempy--;

 if(vscr->tcbuf[tempy][tempx]>127) return;

 if((vscr->tvbuf[tempy][tempx] & 0x1FF)<(128-32)) return;


 /* OK should be graphics */

 x=((mousex-bx) % VXDXM)/(VXDXM>>1);           /* 0 or 1 */

 if(vscr->attr[tempy]==VXADHT) mul=2;
 else                          mul=1;

 y=((by-mousey)-tempy*VXDYM)/((VXDYM*mul)/3);  /* 0,1,2 */
                             
 mask=x+(y<<1);

 if(mode>0 && oldpix==mask) return;

 oldpix=mask;

 mask=1<<(x+2*y);
 if(mask==32) mask=64;

 stackcursor(0);

 ttvx=tempx;
 ttvy=tempy;

 byte=vscr->tcbuf[ttvy][ttvx];

 if(mode==1) byte=byte|mask; 
 else     
 if(mode==2) byte=byte&(255-mask);
 else
             byte=byte^mask;

 if(byte!=vscr->tcbuf[ttvy][ttvx])
 {
  viewhi(byte);
  convertline(vscr,tempy);
 }

 destackcursor(0);
}





void insertchar(void)        /* insert blank at cursor  */
{
 int tempx=ttvx;

 stackcursor(0);
 if(vscr->attr[ttvy]==VXADHB) ttvy--;
 ttvx=39;
 while(ttvx>tempx)
 {
  viewhi(vscr->tcbuf[ttvy][ttvx-1]);
  viewx(8);
  viewx(8);
 }
 viewx(32);
 convertline(vscr,ttvy);
 destackcursor(0);
}


void deletechar(void)        /* delete char at cursor   */
{
 stackcursor(0);
 if(vscr->attr[ttvy]==VXADHB) ttvy--;
 while(ttvx<39)
 {
  viewhi(vscr->tcbuf[ttvy][ttvx+1]);
 }
 viewx(32);
 convertline(vscr,ttvy);
 destackcursor(0);
}



static void killdble(void)
{
 ttvx=0;

 do
 {
  if(vscr->tcbuf[ttvy][ttvx]==141) viewx(32); 
  else                             viewx(9);
 } while(ttvx!=0);
 viewx(8);

 convertline(vscr,ttvy);
}


static void blankline(void)
{
 ttvx=0;
 do viewx(32); while(ttvx!=0); 
 viewx(8);
 convertline(vscr,ttvy);
}



/* stack the bottom line on the screen */

static void stackline(void)
{
 char * i;
 char * j;
 int k;

 if(trashstack==10)
 {
  i=trashbuff;
  j=i+40;
  for(k=0;k<360;k++) *i++=*j++;
  trashstack--;
 }

 i=trashbuff+(trashstack++)*40;

 for(ttvx=0;ttvx<40;ttvx++) *i++=vscr->tcbuf[ttvy][ttvx];
}


/* destack the bottom line */

static void destackline(void)
{
 char * i;

 if(trashstack==0) return;

 i=trashbuff+(--trashstack)*40;

 ttvx=0;

 do viewhi(*i++); while(ttvx!=0);
}




/* insert line at cursor   */

void insertline(void)
{
 int tempy=ttvy;

 stackcursor(0);
 if(vscr->attr[22]==VXADHB)
 {
  ttvy=22;
  killdble();
 }
 destackcursor(0);

 if(vscr->attr[ttvy]==VXADHB)
 {
  ttvy--;
  killdble();
  ttvy++;
 }

 ttvy=23;
 stackline();
 ttvy=24;

 while(--ttvy>tempy)
 {
  if(vscr->attr[ttvy-1]!=VXADHB) 
  {
   vscr->attr[ttvy-1]=0;
   vscr->attr[ttvy]=0;
   ttvx=0;
   do
   {
    viewhi(vscr->tcbuf[ttvy-1][ttvx]);
   } while(ttvx!=0);
   viewx(8);
   convertline(vscr,ttvy);
  }
 }
 destackcursor(0);
 blankline();
 destackcursor(0);
}



/* delete line at cursor   */

void deleteline(void)
{ 
 stackcursor(0);
 if(vscr->attr[ttvy]==VXADHB)
 {
  ttvy--;
  killdble();
  ttvy++;
 }
 blankline();

 while(ttvy<23) 
 {
  ttvx=0;
  do viewhi(vscr->tcbuf[ttvy+1][ttvx]); while(ttvx!=0); 
 }

 blankline();
 destackline();
 destackcursor(0);
}





/* saves contents of box 0 */

static void savebox0(void)
{
 char * p=savebuff;
 int    x;
 int    y;

 sax0=dx0;
 sax1=dx1;
 say0=dy0;
 say1=dy1;
 saved=1;

 for(y=dy1;y<=dy0;y++)
  for(x=dx0;x<=dx1;x++)
    *p++=vscr->tcbuf[y][x];
}



/* pastes buffer into box 1 */

static void pastebox1(void)
{
 int sx;
 int sy;
 char * p=savebuff;

 stackcursor(0);

 for(sy=cy1;sy<=cy0;sy++)
 {
  ttvy=sy;
  for(sx=cx0;sx<=cx1;sx++)
  {
   ttvx=sx;
   viewhi(*p++);
  }
  convertline(vscr,sy);
 }

 destackcursor(0);
}



/* deletes contents of box 0 */

static void deletebox0(void)
{
 int sx;
 int sy;

 stackcursor(0);

 for(sy=dy1;sy<=dy0;sy++)
 {
  ttvy=sy;
  for(sx=dx0;sx<=dx1;sx++)
  {
   ttvx=sx;
   viewx(32);
  }
  convertline(vscr,sy);
 }

 destackcursor(0);
}




static void setuptool(int tool)
{
 if(tool!=vxtool)
 {
 if(tool!=VXTNONE) seti(whandle[KEYPAD],vxtool+54,0x10000000,0xF0000000);

/*  deselect(whandle[KEYPAD],vxtool+54); */

  if(vxtool==VXTPIXEL) setpixelgrid(0);
  vxtool=tool;
  if(vxtool==VXTPIXEL) setpixelgrid(1);

  seti(whandle[KEYPAD],vxtool+54,0x30000000,0xF0000000); 


/*  select(whandle[KEYPAD],vxtool+54); */

  writeicon(whandle[KEYPAD],53,transtoken(toolstring[vxtool]));
 }
}




void vxrefreshcode(char * string)
{
 wimp_icon       isblock;
 wimp_redrawstr  redrawstr;
 int             ox;
 int             oy;
 int             more;


 wimp_get_icon_info(whandle[KEYPAD],51,&isblock);

 redrawstr.w=whandle[KEYPAD];
 redrawstr.box=isblock.box;
  
 wimp_update_wind(&redrawstr,&more);

 strcpy(isblock.data.indirecttext.buffer,string);

 while(more)
 {
  ox=redrawstr.box.x0-redrawstr.scx;
  oy=redrawstr.box.y1-redrawstr.scy;

  vxsetgcol(vxecurcolour);
  bbc_rectanglefill(ox+isblock.box.x0,oy+isblock.box.y0,
   isblock.box.x1-isblock.box.x0-deltax,isblock.box.y1-isblock.box.y0-deltay);

  wimp_get_rectangle(&redrawstr,&more);
 }
}




void vxredbox0(wimp_redrawstr * redrawstr)
{
 int ox;
 int oy;

 if(box0)
 {
  ox=redrawstr->box.x0-redrawstr->scx;
  oy=redrawstr->box.y1-redrawstr->scy;
  oy-=deltay;

  seteorcol(0,7);
  bbc_rectangle(ox+dx0*VXDXM,oy-dy1*VXDYM,
                  (dx1-dx0+1)*VXDXM-deltax,(dy1-dy0-1)*VXDYM+deltay);
 }
}




void vxredbox1(wimp_redrawstr * redrawstr)
{
 int ox;
 int oy;

 if(box1)
 {
  ox=redrawstr->box.x0-redrawstr->scx;
  oy=redrawstr->box.y1-redrawstr->scy;
  oy-=deltay;

  seteorcol(0,7);
  bbc_rectangle(ox+cx0*VXDXM,oy-cy1*VXDYM,
                  (cx1-cx0+1)*VXDXM-deltax,(cy1-cy0-1)*VXDYM+deltay);
 }
}





void vxredbox0l(wimp_redrawstr * redrawstr,int xlo,int xhi,int y)
{
 int ox;
 int oy;
 int shift1;
 int shift0;


 if(box0 && y>=dy1 && y<=dy0)
 {
  seteorcol(0,7);
  ox=redrawstr->box.x0-redrawstr->scx;
  oy=redrawstr->box.y1-redrawstr->scy;

  if(y==dy1) shift1=deltay;
  else       shift1=0;

  if(y==dy0) shift0=deltay;
  else       shift0=0;

  oy-=deltay;

  if(dx0>=xlo && dx0<xhi) 
  {
   bbc_move(ox+dx0*VXDXM,oy-y*VXDYM-shift1);
   bbc_draw(ox+dx0*VXDXM,oy-(y+1)*VXDYM+deltay+shift0);
  }

  if(dx1>=xlo && dx1<xhi)
  {
   bbc_move(ox+(dx1+1)*VXDXM-deltax,oy-y*VXDYM-shift1);
   bbc_draw(ox+(dx1+1)*VXDXM-deltax,oy-(y+1)*VXDYM+deltay+shift0);
  }

  if(xlo<dx0) xlo=dx0;
  xhi--;
  if(xhi>dx1) xhi=dx1;

  if(xlo<=xhi)
  {
   if(y==dy1)
   {
    bbc_move(ox+xlo*VXDXM,oy-y*VXDYM);
    bbc_draw(ox+(xhi+1)*VXDXM-deltax,oy-y*VXDYM);
   }

   if(y==dy0)
   {
    bbc_move(ox+xlo*VXDXM,oy-(y+1)*VXDYM+deltay);
    bbc_draw(ox+(xhi+1)*VXDXM-deltax,oy-(y+1)*VXDYM+deltay);
   }
  }
 }
}





void vxredbox1l(wimp_redrawstr * redrawstr,int xlo,int xhi,int y)
{
 int ox;
 int oy;
 int shift1;
 int shift0;


 if(box1 && y>=cy1 && y<=cy0)
 {
  seteorcol(0,7);
  ox=redrawstr->box.x0-redrawstr->scx;
  oy=redrawstr->box.y1-redrawstr->scy;

  if(y==cy1) shift1=deltay;
  else       shift1=0;

  if(y==cy0) shift0=deltay;
  else       shift0=0;

  oy-=deltay;

  if(cx0>=xlo && cx0<xhi) 
  {
   bbc_move(ox+cx0*VXDXM,oy-y*VXDYM-shift1);
   bbc_draw(ox+cx0*VXDXM,oy-(y+1)*VXDYM+deltay+shift0);
  }

  if(cx1>=xlo && cx1<xhi)
  {
   bbc_move(ox+(cx1+1)*VXDXM-deltax,oy-y*VXDYM-shift1);
   bbc_draw(ox+(cx1+1)*VXDXM-deltax,oy-(y+1)*VXDYM+deltay+shift0);
  }

  if(xlo<cx0) xlo=cx0;
  xhi--;
  if(xhi>cx1) xhi=cx1;

  if(xlo<=xhi)
  {
   if(y==cy1)
   {
    bbc_move(ox+xlo*VXDXM,oy-y*VXDYM);
    bbc_draw(ox+(xhi+1)*VXDXM-deltax,oy-y*VXDYM);
   }

   if(y==cy0)
   {
    bbc_move(ox+xlo*VXDXM,oy-(y+1)*VXDYM+deltay);
    bbc_draw(ox+(xhi+1)*VXDXM-deltax,oy-(y+1)*VXDYM+deltay);
   }
  }
 }
}





void vxbox0on(void)
{
 wimp_redrawstr  redrawstr;
 int             more;

 redrawstr.w=whandle[VDATA];
 redrawstr.box.x0=0;
 redrawstr.box.x1=VXDXM*40;
 redrawstr.box.y1=0;
 redrawstr.box.y0=-VXDYM*24;

 wimp_update_wind(&redrawstr,&more);

 while(more)
 {
  vxredbox0(&redrawstr);
  wimp_get_rectangle(&redrawstr,&more);
 }
}





void vxbox1on(void)
{
 wimp_redrawstr  redrawstr;
 int             more;

 redrawstr.w=whandle[VDATA];
 redrawstr.box.x0=0;
 redrawstr.box.x1=VXDXM*40;
 redrawstr.box.y1=0;
 redrawstr.box.y0=-VXDYM*24;

 wimp_update_wind(&redrawstr,&more);

 while(more)
 {
  vxredbox1(&redrawstr);
  wimp_get_rectangle(&redrawstr,&more);
 }
}







void vxmoveboxes(void)
{
 int xshift;
 int yshift;

 if(box1)
 {
  if((mttvx>=cx0 && mttvx<=cx1 && mttvy>=cy1 && mttvy<=cy0) ||
     (oldx>=cx0 && oldx<=cx1 && oldy>=cy1 && oldy<=cy0)
    )
  {
   xshift=mttvx-oldx;
   yshift=mttvy-oldy;

   if((cx0+xshift)<0)  xshift=-cx0;
   if((cx1+xshift)>39) xshift=39-cx1;
   if((cy1+yshift)<0)  yshift=-cy1;
   if((cy0+yshift)>23) yshift=23-cy0;

   vxbox1on();
   cx1+=xshift;
   cx0+=xshift;
   cy0+=yshift;
   cy1+=yshift;

   vxbox1on();
  }
 }
 else
 if(box0)
 {
  vxbox0on();
  if(mttvx<idx0) {dx0=mttvx;dx1=idx0;}
  else           {dx1=mttvx;dx0=idx0;}
  if(mttvy<idy1) {dy1=mttvy;dy0=idy1;}
  else           {dy0=mttvy;dy1=idy1;}
  vxbox0on();
 }
}




static void vxstartbox0(void)
{
 idx0=dx0=dx1=mttvx;
 idy1=dy1=dy0=mttvy;
 box0=1;
 vxbox0on();
}



static void vxstartbox1(void)
{
 cx0=dx0;
 cx1=dx1;
 cy1=dy1;
 cy0=dy0;
 box1=1;
 vxbox1on();
}




static void vxstartbox1atmouse(void)
{
 int xshift;
 int yshift;

 cx0=dx0;
 cx1=dx1;
 cy1=dy1;
 cy0=dy0;
 box1=1;

 xshift=mttvx-(cx1+cx0)/2;
 yshift=mttvy-(dy1+dy0)/2;

 if((cx0+xshift)<0)  xshift=-cx0;
 if((cx1+xshift)>39) xshift=39-cx1;
 if((cy1+yshift)<0)  yshift=-cy1;
 if((cy0+yshift)>23) yshift=23-cy0;

 cx1+=xshift;
 cx0+=xshift;
 cy0+=yshift;
 cy1+=yshift;

 vxbox1on();
}







static void vxboxesoff(void)
{
 if(box0) vxbox0on();
 box0=0;
 if(box1) vxbox1on();
 box1=0;
}



static void startvxdrag(void)
{
 wimp_dragstr drg;

 drg.type=7;

 getw(whandle[VDATA]);
 drg.parent.y0=y0;
 drg.parent.y1=y1;
 drg.parent.x0=x0;
 drg.parent.x1=x1;


 drg.box.x0=mousex;
 drg.box.x1=mousex;
 drg.box.y0=mousey;
 drg.box.y1=mousey;

 wimp_drag_box(&drg);

 startdrag(VXDRAG,whandle[VDATA]);
 remzeroevent(VXEZERO);
}



void vxdragend(void)
{

 addzeroevent(VXEZERO);
}



void vxdragzero(void)                                                          
{
 getpointer();
 vxgetxy();
 setpix(0);
}




void vxeditzero(void)
{
 int    code;
 int    byte;
 char * string;

 getpointer();
 if(mhandle!=whandle[VDATA]) return;
 vxgetxy();

 if(oldx==mttvx && oldy==mttvy) return;

 vxmoveboxes();

 code=vscr->tcbuf[mttvy][mttvx];
 byte=vscr->tvbuf[mttvy][mttvx];

 vxecurcolour=WHITE;

 if(code>128 && code<136)
 {
  string=transtoken("VXED09");
  vxecurcolour=code-128;
 }
 else
 if(code>144 && code<152)
 {
  string=transtoken("VXED10");
  vxecurcolour=code-144;
 } 
 else
 if(code==136) string=transtoken("VXED11"); /* Fla */
 else
 if(code==137) string=transtoken("VXED12"); /* Std */
 else
 if(code==140) string=transtoken("VXED13"); /* Sgl */
 else
 if(code==141) string=transtoken("VXED14"); /* Dbl */
 else
 if(code==152) string=transtoken("VXED15"); /* Cnc */
 else 
 if(code==153) string=transtoken("VXED16"); /* Con */
 else
 if(code==154) string=transtoken("VXED17"); /* Sep */
 else
 if(code==156) string=transtoken("VXED18"); /* Bbk */
 else
 if(code==157) string=transtoken("VXED19"); /* Nbk */
 else
 if(code==158) string=transtoken("VXED20"); /* Hld */
 else
 if(code==159) string=transtoken("VXED21"); /* Rel */
 else
               {code=0;string="";}


 if(code!=oldcode || vxecurcolour!=oldcurcolour) vxrefreshcode(string);

 if(byte!=oldbyte) { }

 oldcurcolour=vxecurcolour;
 oldcode=code;
 oldbyte=byte;
 oldx=mttvx;
 oldy=mttvy;
}




/*

void vxtool2(int tool)
{
  switch(tool)
  {

   case VXTDEC:
               deletechar();
               break;

   case VXTINC:
               insertchar();
               break;

   case VXTINL:
               insertline();
               break;

   case VXTDEL:
               deleteline();
               break;

   case VXTCLS:
               viewcls();
               break;

  }
}

 */


static void vxeditcls(void)
{
 if(confirm(CONDC,"{VXED08}")==1) viewcls();
}


void vxedtool(int tool)
{
 if(tool==VXTCLS) vxeditcls();
 else
 {
  vxboxesoff();
  setuptool(tool);
 }
}



/* click on editor window */

void vxedicon(void)
{
 vxgetxy();

 if(vxtool==VXTPIXEL && (buttons==0x400 || buttons==0x100 || buttons==0x1
                        || buttons==0x4 || buttons==0x40 || buttons==0x10))
 {
  setpix(1);
  if(buttons==0x40 || buttons==0x10) startvxdrag();
 }
 else
 if(buttons==0x400 || buttons==0x40 || buttons==0x4)
 {
  switch(vxtool)
  {

   case VXTCOPY:
                if(!box0 && !box1) vxstartbox0();
                else
                if(box1)
                {
                 vxboxesoff();
                 pastebox1();
                }
                else
                if(box0)
                {
                 savebox0();
                 vxstartbox1();
                }
                break;
    

   case VXTMOVE:
                if(!box0 && !box1) vxstartbox0();
                else
                if(box1)
                {
                 vxboxesoff();
                 deletebox0();
                 pastebox1();
                }
                else
                if(box0)
                {
                 savebox0();
                 vxstartbox1();
                }
                break;


 case VXTDELETE:
                if(!box0 && !box1) vxstartbox0();
                else
                {
                 vxboxesoff();
                 deletebox0();
                }
                break;


   case VXTTEXT:
                vxhomecursortomouse();
                break;

/*
   case  VXTCLS:
                viewcls();
                break;
*/

  case VXTPASTE:
                if(!box0 && !box1) vxstartbox1atmouse();
                else
                {
                 vxboxesoff();
                 pastebox1();
                }
                break;


   case  VXTCUT:
                if(!box0 && !box1) vxstartbox0();
                else
                {
                 vxboxesoff();
                 savebox0();
                }
                break;

/*
    case VXTINC:
    case VXTDEC:
    case VXTINL:
    case VXTDEL:
                stackcursor(1);
                ttvx=mttvx;
                ttvy=mttvy;
                vxtool2(vxtool);
                destackcursor(1);
                break;

 */

  }
 }
 else
 if(buttons==0x100)   /* click with adjust */
 {
  vxboxesoff();
 }
}






/* called when keypad is created */

void vxecreatekeypad(void)
{
 vxtool=VXTNONE;
}




void vxstopedit(void)
{
 vedit=0;

 vxboxesoff();

 if(whandle[KEYPAD]) openatscroll(whandle[KEYPAD],0,0);

 if(trashbuff) flex_free((flex_ptr)&trashbuff);
 if(savebuff)  flex_free((flex_ptr)&savebuff);

 if(vxtool==VXTPIXEL) setpixelgrid(0);

 remzeroevent(VXEZERO);
}



void vxstartedit(void)
{
 vxecurcolour=WHITE;
 box0=0;
 box1=0;

 if(whandle[KEYPAD])
 {
  getw(whandle[KEYPAD]);
  openatscroll(whandle[KEYPAD],0,y0-y1-4);
 }

 vedit=1;

 oldx=-1;
 oldy=-1;
 oldcode=-1;
 oldbyte=-1;

 oldpix=-1;

 saved=0;

 vxcurs=1;
 if(vxtool==VXTNONE) setuptool(VXTTEXT);

 if(vxtool==VXTPIXEL) setpixelgrid(1);


 trashstack=0;
 if(!trashbuff) flex_alloc((flex_ptr)&trashbuff,360);
 if(!savebuff)  flex_alloc((flex_ptr)&savebuff,HEARSAYFF);

 addzeroevent(VXEZERO);
}



