Subversion Repositories shark

/*

 *

 *

 */

#include <stdio.h>

#include <stdlib.h>

/* per sleep() */

#include <unistd.h>

#if defined(USE_NCURSES)

#include <curses.h>

#elif defined(USE_CONIO)

#include <conio.o>

#else

#error USE_NCURSES or USE_CONIO must be defined

#endif

#include "hconf.h"

/*

 *

 * CONIO

 *

 */

#ifdef USE_CONIO

#define DEFAULT_BG BLUE

#define NORMAL_FG WHITE

#define NORMAL_BG BLUE

#define INVERSE_FG BLACK

#define INVERSE_BG RED

/* -- */

struct text_info info;

void _initscreen(void)

{

  textbackground(DEFAULT_BG);

  clrscr();

  gettextinfo(&info);

}

void _endscreen(void)

{

  clrscr();

}

static __inline__ int _cols(void)

{

  return info.screenwidth;

}

static __inline__ int _rows(void)

{

  return info.screenheight;

}

int _gotorc(int r, int c)

{

  /* zero based */

  gotoxy(c,r);

}

#define _printw(fmt,args...) cprintf(fmt,##args)

#define _refresh()

void _normal(void)

{

  textbackground(NORMAL_BG);

  textcolor(NORMAL_FG);

}

#endif

/*

 *

 * NCURSES

 *

 */

#ifdef USE_NCURSES

// with bold

#define DEFAULT_FG COLOR_CYAN

#define DEFAULT_BG COLOR_BLUE

#define NORMAL_FG COLOR_BLACK

#define NORMAL_BG COLOR_WHITE

// with bold

#define INVERSE_FG COLOR_WHITE

#define INVERSE_BG COLOR_BLUE

//with bold

#define BOX_BORDERFGU COLOR_WHITE

#define BOX_BORDERBGU COLOR_WHITE

#define BOX_BORDERFGD COLOR_BLACK

#define BOX_BORDERBGD COLOR_WHITE

#define BOX_FG COLOR_BLACK

#define BOX_BG COLOR_WHITE

#define SHADOW_FG COLOR_BLACK

#define SHADOW_BG COLOR_BLACK

#define TITLE_FG COLOR_YELLOW

#define TITLE_BG COLOR_WHITE

#define _KEY_OK     0x1b

#define _KEY_DOWN   KEY_DOWN

#define _KEY_UP     KEY_UP

#define _KEY_TOGGLE 0x0a

/* -- */

#define _BACKGROUND 1

#define _NORMAL     2

#define _INVERSE    3

#define _BORDERBOXU 4

#define _BORDERBOXD 5

#define _BOX        6

#define _SHADOW     7

#define _TITLE      8

#define _DEFAULT    9

#define STDWIN stdscr

/* (U-upper,L-lower) (L-left,R-right) */

#define _UL ACS_BSSB

#define _LL ACS_SSBB        

#define _UR ACS_BBSS

#define _LR ACS_SBBS

#define _HH ACS_BSBS

#define _VV ACS_SBSB

void _defaultcolor(WINDOW *w)

{

  wattrset(w,COLOR_PAIR(_DEFAULT)|A_BOLD);

  wbkgdset(w,COLOR_PAIR(_DEFAULT)|A_BOLD);

}

void _normal(WINDOW *w)

{

  wattrset(w,COLOR_PAIR(_NORMAL));

  wbkgdset(w,COLOR_PAIR(_NORMAL));

}

void _inverse(WINDOW *w)

{

  wattrset(w,COLOR_PAIR(_INVERSE)|A_BOLD);

  wbkgdset(w,COLOR_PAIR(_INVERSE)|A_BOLD);

}

void _shadow(WINDOW *w)

{

  wattrset(w,COLOR_PAIR(_SHADOW));

  wbkgdset(w,COLOR_PAIR(_SHADOW));

}

void _boxcolor(WINDOW *w)

{

  wattrset(w,COLOR_PAIR(_BOX));

  wbkgdset(w,COLOR_PAIR(_BOX));

}

void _titlecolor(WINDOW *w)

{

  wattrset(w,COLOR_PAIR(_TITLE)|A_BOLD);

  wbkgdset(w,COLOR_PAIR(_TITLE)|A_BOLD);

}

void _borderboxucolor(WINDOW *w)

{

  wattrset(w,COLOR_PAIR(_BORDERBOXU)|A_BOLD);

  wbkgdset(w,COLOR_PAIR(_BORDERBOXU)|A_BOLD);

}

void _borderboxdcolor(WINDOW *w)

{

  wattrset(w,COLOR_PAIR(_BORDERBOXD));

  wbkgdset(w,COLOR_PAIR(_BORDERBOXD));

}

void _initscreen(void)

{

  initscr();

  start_color();

  init_pair(_BACKGROUND,DEFAULT_BG,DEFAULT_BG);

  init_pair(_DEFAULT,DEFAULT_FG,DEFAULT_BG);

  init_pair(_NORMAL,NORMAL_FG,NORMAL_BG);

  init_pair(_INVERSE,INVERSE_FG,INVERSE_BG);

  init_pair(_BORDERBOXU,BOX_BORDERFGU,BOX_BORDERBGU);

  init_pair(_BORDERBOXD,BOX_BORDERFGD,BOX_BORDERBGD);

  init_pair(_BOX,BOX_FG,BOX_BG);

  init_pair(_SHADOW,SHADOW_FG,SHADOW_BG);

  init_pair(_TITLE,TITLE_FG,TITLE_BG);

  bkgdset(COLOR_PAIR(_BACKGROUND));

  clear();

  cbreak(); /* input one char at time (don't wait for \n) */

  noecho();

  keypad(stdscr,TRUE);

  _normal(stdscr);

  refresh();

}

void _endscreen(void)

{

  endwin();

}

static __inline__ int _cols(void)

{

  return COLS;

}

static __inline__ int _rows(void)

{

  return LINES;

}

static __inline__ void _gotorc(WINDOW *w,int r, int c)

{

  /* zero based */

  wmove(w,r,c);

}

#define _printw(w,fmt,args...) wprintw(w,fmt,##args)

void _refresh(WINDOW *w)

{

  wrefresh(w);

}

WINDOW *_createwin(int str, int stc, int lines, int cols)

{

  WINDOW *wnd;

  wnd=newwin(lines,cols,str,stc);

  if (wnd!=NULL) {

    //wbkgdset(wnd,COLOR_PAIR(_BACKGROUND));

    //wclear(wnd);

    //_normal(wnd);

  }

  return wnd;

}

#define _deletewin(w) delwin(w)

#define _putch(w,c) waddch(w,c)

#define _getch() getch()

#define _clreol(w) wclrtoeol(w)

#define _clrscr(w) wclear(w)

#define _bell() addch('\07');

#endif

/*

 *

 *

 *

 */

static void whichcolor(WINDOW *wnd, int up, int inv)

{

  if (((inv==1)&&(up==1))||((inv==0)&&(up==0))) _borderboxdcolor(wnd);

  else _borderboxucolor(wnd);

}

void _settitle(WINDOW *wnd,

               int sy, int sx,

               int lines, int cols,

               int bordy, int bordx,

               char *title,

               int shad, int inv)

{

  int x;

  sx-=bordx+1;

  sy-=bordy+1;

  cols+=2*(bordx+1);

  lines+=2*(bordy+1);

  whichcolor(wnd,1,inv);

  _gotorc(wnd,sy,sx+1);

  for (x=0;x<cols-2;x++) _putch(wnd,_HH);

  if (title!=NULL) {

    _titlecolor(wnd);

    _gotorc(wnd,sy,sx+(cols-strlen(title)-2)/2);

    _printw(wnd," %s ",title);

    _normal(wnd);

    _gotorc(wnd,sy+2,sx+2);

    _printw(wnd,"use <ESC> to exit, <ENTER> to enter/toggle,");

    _gotorc(wnd,sy+3,sx+2);

    _printw(wnd,"arrows keys to move");

  }

  _refresh(wnd);

}

void _box(WINDOW *wnd,

          int sy, int sx,

          int lines, int cols,

          int bordy, int bordx,

          char *title,

          int shad, int inv)

{

  int x,y;

  sx-=bordx+1;

  sy-=bordy+1;

  cols+=2*(bordx+1);

  lines+=2*(bordy+1);

  {

    char blanks[180];

    memset(blanks,' ',sizeof(blanks));

    blanks[cols]='\0';

    _boxcolor(wnd);

    for (y=0;y<lines;y++) {

      _gotorc(wnd,sy+y,sx);

      _printw(wnd,"%s",blanks);

    }

  }

  whichcolor(wnd,1,inv);

  _gotorc(wnd,sy,sx);

  _putch(wnd,_UL);

  for (x=0;x<cols-2;x++) _putch(wnd,_HH);

  whichcolor(wnd,0,inv);

  _putch(wnd,_UR);

  for (y=1;y<lines-1;y++) {

    whichcolor(wnd,1,inv);

    _gotorc(wnd,sy+y,sx);

    _putch(wnd,_VV);

    whichcolor(wnd,0,inv);

    _gotorc(wnd,sy+y,sx+cols-1);

    _putch(wnd,_VV);

    if (shad) {

      _shadow(wnd);

      _putch(wnd,' ');

      _putch(wnd,' ');

    }

  }

  whichcolor(wnd,1,inv);

  _gotorc(wnd,sy+lines-1,sx);

  _putch(wnd,_LL);

  whichcolor(wnd,0,inv);

  for (x=0;x<cols-2;x++) _putch(wnd,_HH);

  _putch(wnd,_LR);

  if (shad) {

    _shadow(wnd);

    _putch(wnd,' ');

    _putch(wnd,' ');

  }

  if (shad) {

    _shadow(wnd);

    _gotorc(wnd,sy+lines,sx+1);

    for (x=0;x<cols+1;x++) _putch(wnd,' ');

  }

  sx+=bordx+1;

  sy+=bordy+1;

  cols-=2*(bordx+1);

  lines-=2*(bordy+1);

  _settitle(wnd,sy,sx,lines,cols,bordy,bordx,title,shad,inv);

  /* refresh made by _settitle() */

}

void showtitle(char *s);

/* -- */

void showbol(WINDOW *wnd, struct menuentry *ptr)

{

  struct variable *var;

  char ch;

  var=ptr->x.bool.var;  

  if (!strcmp(var->value,"y")) ch='*';

  else ch=' ';

  _printw(wnd,"[%c] %s",ch,ptr->x.bool.text);

  _normal(wnd);

  _clreol(wnd);

}

void showtristate(WINDOW *wnd, struct menuentry *ptr)

{

  struct variable *var;

  char ch;

  var=ptr->x.bool.var;  

  if (!strcmp(var->value,"y")) ch='*';

  else if (!strcmp(var->value,"n")) ch=' ';

  else ch='M';

  _printw(wnd,"<%c> %s",ch,ptr->x.bool.text);

  _normal(wnd);

  _clreol(wnd);

}

void showchoice(WINDOW *wnd, struct menuentry *ptr)

{

  _printw(wnd,"   %s (%s)",ptr->x.choice.text,ptr->x.choice.act->text);

  _normal(wnd);

  _clreol(wnd);

}

void showsubmenu(WINDOW *wnd, struct menuentry *ptr)

{

  _printw(wnd,"    %s --->",ptr->x.submenu.text);

  _normal(wnd);

  _clreol(wnd);

}

/* -- */

int nmax; // numero linee massimo

void showmenuentries(WINDOW *wnd,struct menuentry *ptr, int r, int c, int rcur)

{

  int i;

  i=0;

  while (ptr!=NULL) {

    _gotorc(wnd,r,c);

    if (r==rcur) _inverse(wnd);

    else _normal(wnd);

    r++;

    switch(ptr->type) {

    case BOOLENTRY:

      showbol(wnd,ptr);

      break;

    case TRISTATEENTRY:

      showtristate(wnd,ptr);

      break;

    case CHOICEENTRY:

      showchoice(wnd,ptr);

      break;

    case SUBMENUENTRY:

      showsubmenu(wnd,ptr);

      break;

    default:

      _printw(wnd,"@@@");

      break;

    }

    ptr=ptr->n;

    i++;

    if (i==nmax) return;

  }

}

/* --- */

struct menuentry *expandcase(struct menuentry *menuent);

struct menuentry *expandmenu(struct menuentry *menuent);

struct menuentry *expandcase(struct menuentry *menuent)

{

  struct _case *list;

  list=menuent->x._case.list;

  while (list!=NULL) {

    if (!strcmp(list->value,menuent->x._case.var->value)) {      

      return expandmenu(list->list);

    }

    list=list->next;

  }

  return NULL;

}

int nument;

struct menuentry *expandmenu(struct menuentry *menuent)

{

  struct menuentry *start,*ptr,*ent,*prev,*p;

  int ne;

  ne=0;

  ptr=menuent;

  prev=NULL;

  start=NULL;

  while (ptr!=NULL) {

    switch(ptr->type) {

    case CASEENTRY:

      ent=expandcase(ptr);

      if (ent==NULL) {

        if (prev!=NULL) prev->n=ptr->next;

        ptr=ptr->next;

        break;

      }

      if (start==NULL) start=ent;

      if (prev!=NULL) prev->n=ent;

      ent->p=prev;

      p=ent;

      while (p->n!=NULL) p=p->n;

      p->n=ptr->next;

      prev=p;

      ptr=ptr->next;

      break;

    default:

      if (start==NULL) start=ptr;

      ne++;

      ptr->p=prev;

      ptr->n=ptr->next;

      prev=ptr;

      ptr=ptr->next;

      break;

    }

  }

  nument+=ne;

  return start;

}

/* -- */

#define MUSTREDISPLAY 0x01

#define MUSTREBUILD   0x02

int showmenu(WINDOW *wnd, struct menu *menu);

int showchoicewnd(WINDOW *wnd, struct menuentry *menu);

int enteron(WINDOW *wnd,struct menuentry *ptr)

{

  struct variable *var;

  switch(ptr->type) {

  case BOOLENTRY:

    var=ptr->x.bool.var;

    if (*var->value=='y') *var->value='n';

    else *var->value='y';

    if (var->flags&FLAG_M) return MUSTREBUILD;

    break;

  case TRISTATEENTRY:

    var=ptr->x.tristate.var;

    if (*var->value=='y') *var->value='n';

    else if (*var->value=='n') *var->value='m';

    else *var->value='y';

    if (var->flags&FLAG_M) return MUSTREBUILD;

    break;

  case CHOICEENTRY:

    return showchoicewnd(wnd,ptr)|MUSTREDISPLAY;

  case SUBMENUENTRY:

    return showmenu(wnd,ptr->x.submenu.menu)|MUSTREDISPLAY;

  default:

    _bell();

    break;

  }

  return 0;

}

/* --- */

int SC=9;

int SR=9;

int NL=36;

int NC=61;

int BR=0;

int BC=4;

/* --- */

/* sigh :-( */

static struct choice *findprev(struct choice *list, struct choice *cur)

{

  struct choice *c,*p;

  c=list;

  p=NULL;

  while (c!=NULL) {

    if (c==cur) return p;

    p=c;

    c=c->next;

  }

  return NULL;

}

int showchoicewnd(WINDOW *wnd, struct menuentry *ent)

{

  struct choice *first; // first menuentry of the list

  struct choice *cur;   // selected menuentry

  struct choice *fline; // menuentry to show on the first line

  struct choice *p;

  int ch;

  int rcur;

  int i,r,c;

  int ret;

  ret=MUSTREDISPLAY;

  first=fline=cur=ent->x.choice.list;

  rcur=0;

  showtitle(ent->x.choice.text);

  _clrscr(wnd);

  for (;;) {

    r=c=0;

    p=fline;

    i=0;

    while (p!=NULL) {

      _gotorc(wnd,r,c);

      if (r==rcur) _inverse(wnd);

      else _normal(wnd);

      r++;

      _printw(wnd,"(%c) %s",p==ent->x.choice.act?'X':' ',p->text);

      _clreol(wnd);

      p=p->next;

      i++;

      if (i==nmax) break;

    }

    _refresh(wnd);

    ch=getch();

    switch (ch) {

    case _KEY_OK:

      return ret;

    case _KEY_DOWN:

      if (cur->next==NULL) break;

      cur=cur->next;

      if (rcur<NL-1) {

        rcur++;

        break;

      }

      fline=fline->next;

      break;

    case _KEY_UP:

      p=findprev(ent->x.choice.list,cur);

      if (p==NULL) break;

      cur=p;

      if (rcur!=0) {

        rcur=rcur--;

        break;

      }

      fline=findprev(ent->x.choice.list,fline);

      break;

    case _KEY_TOGGLE:

      if ((ent->x.choice.act->var->flags&FLAG_M)||(cur->var->flags&FLAG_M))

        ret|=MUSTREBUILD;

      *(ent->x.choice.act->var->value)='n';

      ent->x.choice.act=cur;

      *(ent->x.choice.act->var->value)='y';

      break;         

    }    

  }

}

int showmenu(WINDOW *wnd, struct menu *menu)

{

  struct menuentry *first; // first menuentry of the list

  struct menuentry *cur;   // selected menuentry

  struct menuentry *fline; // menuentry to show on the first line

  int redo;

  int ch;

  int rcur;

  int ret;

  first=fline=cur=NULL;

  rcur=0;

  redo=1;

  ret=MUSTREDISPLAY;

  for (;;) {

    if (redo&MUSTREBUILD) redo|=MUSTREDISPLAY;

    ret|=redo;

    if (redo&MUSTREBUILD) {

      fline=NULL;

    }

    if (redo&MUSTREDISPLAY) {

      nument=0;

      first=expandmenu(menu->entries);

      if (fline==NULL) {

        fline=first;

        if (cur==NULL) {

          cur=fline;

          rcur=0;

        }

      }

      nmax=NL;

      showtitle(menu->title);

      _normal(wnd);

      _clrscr(wnd);

      redo=0;

    }

    showmenuentries(wnd,fline,0,0,rcur);

    _refresh(wnd);

    ch=getch();

    switch (ch) {

    case _KEY_OK:

      return ret;

    case _KEY_DOWN:

      if (cur->n==NULL) break;

      cur=cur->n;

      if (rcur<NL-1) {

        rcur++;

        break;

      }

      fline=fline->n;

      break;

    case _KEY_UP:

      if (cur->p==NULL) break;

      cur=cur->p;

      if (rcur!=0) {

        rcur=rcur--;

        break;

      }

      fline=fline->p;

      break;

    case _KEY_TOGGLE:

      redo=enteron(wnd,cur);      

      break;         

    default:

      /*

      _normal(STDWIN);

      _gotorc(STDWIN,0,0);

      _printw(STDWIN,"%04x",ch);

      _refresh(STDWIN);

      */

    }    

  }

}

void showtitle(char *s)

{

  _settitle(STDWIN,SR-6,SC-2,NL+8,NC+4,BR,BC,s,1,0);

}

/*

 *

 */

int show(void)

{

  WINDOW *wnd;

  int i;

  _initscreen();

  SC=9;

  SR=9;

  NL=_rows()-5-SR-BR*2;

  NC=_cols()-2-SC-BC*2;

  BR=0;

  BC=4;

  _defaultcolor(STDWIN);

  _gotorc(STDWIN,0,0);

  _printw(STDWIN," Hartik4 (Lego) version 4.0pre1 - Configuration");

  _gotorc(STDWIN,1,1);

  for (i=0;i<_cols()-2;i++) _putch(STDWIN,_HH);

  _box(STDWIN,SR-6,SC-2,NL+8,NC+4,BR,BC,NULL,1,0);

  _box(STDWIN,SR,SC,NL,NC,BR,BC,NULL,0,1);

  wnd=_createwin(SR,SC,NL,NC);