#include  <stdio.h>
#include  <stdlib.h>
#include  <malloc.h>
#include  <string.h>
#include  <stdarg.h>
#include  <curses.h>
#include  <memory.h>
#include  <time.h>
#include  <signal.h>
#include  <sys/types.h>
#include  "zlib.h"

#ifdef  UNIX
#define COLOR(F,B) COLOR_PAIR((F)*8+(B))
#endif

typedef struct{
         int     r;
         int     c;
         int     h;
         int     w;
         int     s;
         int     a;
         int     cr;
         int     cc;
         char    *t;
         chtype  *p;
         void    *u;
}ZWIN;

static char ZWbuf[1024];
static ZWIN *ZWptr;

#ifdef UNIX
static int ZW_color[ZC_ACTIVE] = {
	COLOR_BLACK,	COLOR_RED,	COLOR_GREEN,	COLOR_YELLOW,
	COLOR_BLUE,	COLOR_MAGENTA,	COLOR_CYAN,	COLOR_WHITE
};
#endif

#ifdef UNIX
static chtype  ZW_attr[_ZA_COUNT][4]=
#else
static chtype  ZW_attr[_ZA_COUNT][2]=
#endif
       {
       /* Text   */ A_DIM,              A_REVERSE,
#ifdef UNIX
                    COLOR(COLOR_WHITE,COLOR_BLACK),
                    COLOR(COLOR_WHITE,COLOR_BLUE)|A_BOLD,
#endif
       /* Key    */ A_BOLD,             A_BOLD|A_REVERSE,
#ifdef UNIX
                    COLOR(COLOR_YELLOW,COLOR_BLACK)|A_BOLD,
                    COLOR(COLOR_YELLOW,COLOR_BLUE)|A_BOLD,
#endif
       /* Field  */ A_DIM,              A_DIM,
#ifdef UNIX
                    COLOR(COLOR_WHITE,COLOR_BLUE),
                    COLOR(COLOR_BLUE,COLOR_WHITE),
#endif
       /* Edit   */ A_BOLD,             A_DIM,
#ifdef UNIX
                    COLOR(COLOR_YELLOW,COLOR_BLUE)|A_BOLD,
                    COLOR(COLOR_BLACK,COLOR_WHITE),
#endif
       /* Button */ A_REVERSE,          A_DIM,
#ifdef UNIX
                    COLOR(COLOR_YELLOW,COLOR_CYAN)|A_BOLD,
                    COLOR(COLOR_BLACK,COLOR_CYAN),
#endif
       /* Frame  */ A_BOLD,             A_BOLD|A_REVERSE,
#ifdef UNIX
                    COLOR(COLOR_YELLOW,COLOR_BLACK)|A_BOLD,
                    COLOR(COLOR_YELLOW,COLOR_BLUE)|A_BOLD,
#endif
       /* SelBar */ A_REVERSE,          A_DIM,
#ifdef UNIX
                    COLOR(COLOR_YELLOW,COLOR_BLUE)|A_BOLD,
                    COLOR(COLOR_YELLOW,COLOR_WHITE)|A_BOLD,
#endif
       /* Hold   */ A_REVERSE|A_BOLD,   A_BOLD,
#ifdef UNIX
                    COLOR(COLOR_YELLOW,COLOR_CYAN),
                    COLOR(COLOR_BLACK,COLOR_CYAN)|A_BOLD,
#endif
       /* NegTxt */ A_DIM,              A_REVERSE,
#ifdef UNIX
                    COLOR(COLOR_RED,COLOR_BLACK),
                    COLOR(COLOR_RED,COLOR_BLUE)|A_BOLD,
#endif
       /* NegFld */ A_REVERSE,          A_DIM,
#ifdef UNIX
                    COLOR(COLOR_RED,COLOR_BLUE),
                    COLOR(COLOR_RED,COLOR_WHITE)|A_BOLD,
#endif
       /* NegEdt */ A_BOLD|A_REVERSE,   A_BOLD,
#ifdef UNIX
                    COLOR(COLOR_RED,COLOR_BLUE)|A_BOLD,
                    COLOR(COLOR_RED,COLOR_WHITE),
#endif
       /* User   */ A_DIM,              A_REVERSE,
#ifdef UNIX
                    COLOR(COLOR_WHITE,COLOR_BLACK),
                    COLOR(COLOR_WHITE,COLOR_BLUE)|A_BOLD,
#endif
       };

static void ZWsetattr( ZWIN *w, int a )
{
#ifdef UNIX
  if( has_colors()==TRUE )
  {
    if( w->s & ZW_REVERSE )
      attrset(ZW_attr[a][3]);
    else
      attrset(ZW_attr[a][2]);
  }
  else
  {
#endif
    if( w->s & ZW_REVERSE )
      attrset(ZW_attr[a][1]);
    else
      attrset(ZW_attr[a][0]);
#ifdef UNIX
  }
#endif
}

static void ZWenlarge( ZWIN *w )
{
  if( w->s & ZW_BOX )
  {
    w->c--;
    w->w += 2;
    w->r --;
    w->h +=2;
  }
}

static void ZWshrink( ZWIN *w )
{
  if( w->s & ZW_BOX )
  {
    w->c ++;
    w->w -= 2;
    w->r ++;
    w->h -=2;
  }
}

static void ZWsave( ZWIN *w )
{
  int i,j,lr=w->r+w->h,lc=w->c+w->w;
  chtype *p=w->p;

  for( i=w->r; i<lr; i++ )
    for( j=w->c; j<lc; j++ )
    {
      *p=mvinch(i,j);
      p++;
    }
}

static void ZWrestore( ZWIN *w )
{
  int i,j,lr=w->r+w->h,lc=w->c+w->w;
  chtype *p=w->p;

  for( i=w->r; i<lr; i++ )
    for( j=w->c; j<lc; j++ )
    {
      mvaddch(i,j,*p);
      p++;
    }
}

static void ZWclw( int r, int c, int h, int w )
{
  ZWsetattr(ZWptr,ZA_TEXT);
  while( h ){
    mvprintw(ZWptr->r+r,ZWptr->c+c,"%*s",w,"");
    h --;
    r ++;
  }
  attrset(0);
}

static void ZWframe( ZWIN *w, int a )
{
  ZWbox(0,0,w->h,w->w,a);
  if( w->t )
  {
    ZWsetattr(w,a);
    mvprintw(w->r,w->c+((w->w-strlen(w->t)+1)/2),"%s",w->t);
  }
  attrset(0);
}

void ZWuserattr( int f, int b )
{
  int i;

  ZW_attr[ZA_USER][0] = A_DIM;
  ZW_attr[ZA_USER][1] = A_REVERSE;
#ifdef UNIX
  ZW_attr[ZA_USER][2] = COLOR_PAIR( ( f % 8 ) * 8 + ( b % 8 ) );
  ZW_attr[ZA_USER][3] = COLOR_PAIR( ( b % 8 ) * 8 + ( f % 8 ) );
  if( f & ZC_ACTIVE ){
    for( i = 0; i < 4; i += 2 )
      ZW_attr[ZA_USER][i] |= A_BOLD;
  }
  else{
    for( i = 1; i < 4; i += 2 )
      ZW_attr[ZA_USER][i] |= A_BOLD;
  }
  if( b & ZC_ACTIVE ){
    for( i = 0; i < 4; i ++ )
      ZW_attr[ZA_USER][i] |= A_BLINK;
  }
#endif
}

void ZWcursor( int *r, int *c )
{
  getyx(stdscr,*r,*c);
  *r -= ZWptr->r;
  *c -= ZWptr->c;
}

void ZWlocate( int r, int c )
{
  if( r>=0 && r<ZWptr->h && c>=0 && c<ZWptr->w )
  {
    move(ZWptr->r+r,ZWptr->c+c);
    refresh();
  }
}

int ZWattr( int a )
{
  int o=ZWptr->a;

  if( a>=0 && a<_ZA_COUNT )
    ZWptr->a=a;
  return(o);
}

void ZWprint( int r, int c, char *s, int l )
{
  int i;

  if( l>0 && r>=0 && c>=0 && r<ZWptr->h && c<ZWptr->w )
  {
    ZWsetattr(ZWptr,ZWptr->a);
    while( l )
    {
      i=ZWptr->w-c;
      if( i > l )
        i=l;
      mvprintw(ZWptr->r+r,ZWptr->c+c,"%*.*s",i,i,s);
      s+=i;
      l-=i;
      if( !l )
        break;
      if( c==ZWptr->w-i ){
        c=0;
        if( r==ZWptr->h-1 )
        {
          ZWscroll(1);
          ZWsetattr(ZWptr,ZWptr->a);
        }
        else
          r++;
      }
      else
        c+=i;
    }
    attrset(0);
    ZWlocate(0,0);
  }
}

void ZWprintf( int r, int c, char *s, ... )
{
  va_list a;

  va_start(a,s);
  vsprintf(ZWbuf,s,a);
  ZWprint(r,c,ZWbuf,strlen(ZWbuf));
  va_end(a);
  return;
}

void ZWline( int r, int f, char *t )
{
  int c;

  if( strlen(t)<=ZWptr->w )
  {
    switch(f)
    {
      case ZJ_LEFT:
        c=0;
        break;
      case ZJ_RIGHT:
        c=ZWptr->w-strlen(t);
        break;
      case ZJ_CENTER:
        c=(ZWptr->w-strlen(t)+1)/2;
        break;
    }
    ZWprintf(r,c,t);
  }
}

int ZWareaclear( int r, int c, int h, int w )
{
  if( r < 0 || r >= ZWptr->h || c < 0 || c >= ZWptr->w || h <= 0 || w <= 0
      || r + h > ZWptr->h || c + w > ZWptr->w )
    return( -1 );
  ZWclw( r, c, h, w );
  ZWlocate(0,0);
}

void ZWclear( int r, int l )
{
  if( l<=0 || r+l>ZWptr->h )
    ZWclw(r,0,ZWptr->h-r,ZWptr->w);
  else
    ZWclw(r,0,l,ZWptr->w);
  ZWlocate(0,0);
}

int ZWareascroll( int r, int c, int h, int w, int l )
{
  int i,j;
  chtype ch;

  if( r < 0 || r >= ZWptr->h || c < 0 || c >= ZWptr->w || h <= 0 || w <= 0
      || r + h > ZWptr->h || c + w > ZWptr->w )
    return( -1 );
  if( l>0 && l<h )
  {
    for( i=l; i<h; i ++ )
      for( j=0; j<w; j ++ )
      {
        ch=mvinch(ZWptr->r+r+i,ZWptr->c+c+j);
        mvaddch(ZWptr->r+r+i-l,ZWptr->c+c+j,ch);
      }
    ZWareaclear(r+h-l,c,l,w);
  }
  else if( l<0 && l+h > 0 )
  {
    for( i=h-1; i>-l-1; i -- )
      for( j=0; j<w; j ++ )
      {
        ch=mvinch(ZWptr->r+r+i+l,ZWptr->c+c+j);
        mvaddch(ZWptr->r+r+i,ZWptr->c+c+j,ch);
      }
    ZWareaclear(r,c,-l,w);
  }
  else
    ZWareaclear(0,c,0,w);
}

void ZWscroll( int l )
{
  ZWareascroll(0,0,ZWptr->h,ZWptr->w,l);
}

void ZWbox( int r, int c, int h, int w, int a )
{
  int i;

  ZWsetattr(ZWptr,a);
#ifdef UNIX
  for ( i=1; i<h-1; i++ )
  {
    mvaddch(ZWptr->r+r+i,ZWptr->c+c,acs_map[120]);
    mvaddch(ZWptr->r+r+i,ZWptr->c+c+w-1,acs_map[120]);
  }
  for ( i=1; i<w-1; i++ )
  {
    mvaddch(ZWptr->r+r,ZWptr->c+c+i,acs_map[113]);
    mvaddch(ZWptr->r+r+h-1,ZWptr->c+c+i,acs_map[113]);
  }
  if( h>1 && w>1 )
  {
    mvaddch(ZWptr->r+r,ZWptr->c+c,acs_map[108]);
    mvaddch(ZWptr->r+r,ZWptr->c+c+w-1,acs_map[107]);
    mvaddch(ZWptr->r+r+h-1,ZWptr->c+c,acs_map[109]);
    mvaddch(ZWptr->r+r+h-1,ZWptr->c+c+w-1,acs_map[106]);
  }
#else
  for ( i=1; i<h-1; i++ )
  {
    mvaddch(ZWptr->r+r+i,ZWptr->c+c,120|A_ALTCHARSET);
    mvaddch(ZWptr->r+r+i,ZWptr->c+c+w-1,120|A_ALTCHARSET);
  }
  for ( i=1; i<w-1; i++ )
  {
    mvaddch(ZWptr->r+r,ZWptr->c+c+i,113|A_ALTCHARSET);
    mvaddch(ZWptr->r+r+h-1,ZWptr->c+c+i,113|A_ALTCHARSET);
  }
  if( h>1 && w>1 )
  {
    mvaddch(ZWptr->r+r,ZWptr->c+c,108|A_ALTCHARSET);
    mvaddch(ZWptr->r+r,ZWptr->c+c+w-1,107|A_ALTCHARSET);
    mvaddch(ZWptr->r+r+h-1,ZWptr->c+c,109|A_ALTCHARSET);
    mvaddch(ZWptr->r+r+h-1,ZWptr->c+c+w-1,106|A_ALTCHARSET);
  }
#endif
  attrset(0);
}

int ZWrow()
{
  return(ZWptr->r);
}

int ZWcol()
{
  return(ZWptr->c);
}

int ZWwidth()
{
  return(ZWptr->w);
}

int ZWheight()
{
  return(ZWptr->h);
}

int ZWopen( ZWINDOW *W )
{
  int i;
  ZWIN *n;

  if(W->r<0 || W->c<0 || W->h<1 || W->w<1 || W->r+W->h>LINES || W->c+W->w>COLS
     || (W->s&ZW_BOX) && (W->t && strlen(W->t)>W->w || W->r<1
     || W->r+W->h>=LINES || W->c<1 || W->c+W->w>=COLS ))
    return(-1);
  if((n=(ZWIN *)malloc(sizeof(ZWIN)))==NULL)
    return(-1);
  n->r=W->r;
  n->c=W->c;
  n->w=W->w;
  n->h=W->h;
  n->s=W->s;
  n->t=W->t;
  ZWenlarge(n);
  if((n->p=(chtype *)malloc(sizeof(chtype)*n->w*n->h))==NULL)
  {
    free(n);
    return(-1);
  }
  getyx(stdscr,n->cr,n->cc);
  n->a=ZA_TEXT;
  n->u=ZWptr;
  if( ZWptr->s&ZW_BOX )
  {
    ZWenlarge(ZWptr);
/*
    ZWframe(ZWptr,ZA_TEXT);
*/
    ZWshrink(ZWptr);
  }
  ZWptr=n;
  ZWsave(n);
  ZWclw(0,0,n->h,n->w);
  if( n->s&ZW_BOX )
/*
    ZWframe(n,ZA_FRAME);
*/
    ZWframe(n,ZA_TEXT);
  ZWshrink(n);
  attrset(0);
  ZWlocate(0,0);
  return(0);
}

void ZWclose()
{
  ZWIN *p;
  int r=ZWptr->cr,c=ZWptr->cc;

  if( ZWptr->u==0 )
    return;
  ZWenlarge(ZWptr);
  ZWrestore(ZWptr);
  ZWshrink(ZWptr);
  p=ZWptr->u;
  free(ZWptr->p);
  free(ZWptr);
  ZWptr=p;
  if( ZWptr->s&ZW_BOX )
  {
    ZWenlarge(ZWptr);
/*
    ZWframe(ZWptr,ZA_FRAME);
*/
    ZWshrink(ZWptr);
  }
  move(r,c);
  refresh();
}

static void ZSkill(int s)
{
  Zexit();
  exit(0);
}

int Zinit()
{
  int i;
  void ZSkill(int);

  if((ZWptr=(ZWIN *)malloc(sizeof(ZWIN)))==NULL)
    return(-1);
  initscr();
  savetty();
  cbreak();
  nonl();
  noecho();
  keypad(stdscr,TRUE);
  nodelay(stdscr,TRUE);
  curs_set(0);
#ifdef UNIX
  if( has_colors()==TRUE )
  {
    start_color();
    for( i=1; i<COLOR_PAIRS; i++ )
      init_pair((short)i,(short)(i/8),(short)(i%8));
  }
#endif
  ZWptr->r=0;
  ZWptr->c=0;
  ZWptr->w=COLS;
  ZWptr->h=LINES;
  ZWptr->s=ZW_DEFAULT;
  ZWptr->t=0;
  ZWptr->a=ZA_TEXT;
  ZWptr->u=0;
  ZWptr->cr=0;
  ZWptr->cc=0;
  move(0,1);
  refresh();
  signal(SIGHUP,  ZSkill);
  signal(SIGINT,  ZSkill);
  signal(SIGQUIT, ZSkill);
  signal(SIGTERM, ZSkill);
  return(0);
}

void Zsignal()
{
  signal(SIGHUP,  SIG_IGN);
  signal(SIGINT,  SIG_IGN);
  signal(SIGQUIT, SIG_IGN);
  signal(SIGTERM, SIG_IGN);
}

void Zexit()
{
  while( ZWptr->u )
    ZWclose();
  free(ZWptr);
  resetty();
  signal(SIGHUP,  SIG_DFL);
  signal(SIGINT,  SIG_DFL);
  signal(SIGQUIT, SIG_DFL);
  signal(SIGTERM, SIG_DFL);
  endwin();
}

void Zexec( char *s )
{
  endwin();
  system(s);
  refresh();
}