home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / gle / test.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-29  |  7.8 KB  |  529 lines
  1. #define unix true
  2. #include <stdio.h>
  3. #ifdef ultrix
  4. #include <cursesX.h>
  5. #else
  6. #include <curses.h>
  7. #endif
  8. #include <signal.h>
  9. #include "vaxconio.h"
  10. #define false 0
  11. #define true (!false)
  12. #define dbg if (1==1)
  13. int iserr;
  14. int dont_clear;
  15. int noscreenio;
  16. main()
  17. {
  18.   scr_init();
  19.   scr_refresh();
  20.   for (;;) {
  21.     printw("%d ",getch());
  22.     scr_refresh();
  23.   }
  24.   scr_end();
  25. }
  26.  
  27. delay(int i)
  28. {}
  29. int vx_top=1,vx_bot=24;
  30. textattr()
  31. {}
  32. abort_key()
  33. {
  34.     return false;
  35. }
  36. kbhit()
  37. {
  38.     return false;
  39. }
  40. scr_gets(char *x)
  41. {
  42.     getstr(x);
  43. }
  44. clreol()
  45. {
  46.     if (noscreenio) return;
  47.     clrtoeol();
  48. }
  49. cputs(char *line)
  50. {
  51.     int x;
  52.     int y;
  53.     if (noscreenio) return;
  54.     getyx(stdscr,y,x);
  55.     mvaddstr(y,x,line);
  56. }
  57. delline()
  58. {
  59.     int x;
  60.     int y;
  61.     getyx(stdscr,y,x);
  62.     move(22,1);
  63.     clrtobot();
  64.     move(y,1);
  65.     deleteln();
  66.     move(y,x);
  67. }
  68. gotoxy(int x, int y)
  69. {
  70.     if (noscreenio) return;
  71.     if (y==25) y=24;
  72.     move(y+vx_top-2,x);
  73. }
  74. insline()
  75. {
  76.     int x;
  77.     int y;
  78.     getyx(stdscr,y,x);
  79.     move(y,x);
  80.     insertln();
  81.     move(y,x);
  82.     move(22,1);
  83.     clrtobot();
  84.     move(y,x);
  85.  
  86. }
  87. putch(int char_val)
  88. {
  89.     int x;
  90.     int y;
  91.     getyx(stdscr,y,x);
  92.     mvaddch(y,x,char_val);
  93. }
  94. int scr_refresh()
  95. {
  96.     if (!noscreenio) refresh();
  97.     else {printf("not refreshing, \n"); refresh();}
  98. }
  99. int scr_getch()
  100. {
  101.     if (noscreenio) return getc(stdin);
  102.     else return getch();
  103. }
  104. trap(int sig)
  105. {
  106.     echo();
  107.     nl();
  108.     nocbreak();
  109.     endwin();
  110.     exit(sig);
  111. }
  112. scr_init()
  113. {
  114.     static int doneinit;
  115. #ifdef ultrix
  116.     signal(SIGINT,trap);
  117. #endif
  118.     if (doneinit) {printf("init called twice \n"); exit();}
  119.     doneinit = true;
  120.     initscr();
  121. /*    scrollok(stdscr,true);
  122. */
  123. #ifdef unix
  124. /*    noecho();
  125.     nonl();
  126.     cbreak();
  127.     clear();
  128.     keypad(stdscr,TRUE);
  129. */
  130. #endif
  131. }
  132. scr_end()
  133. {
  134.     if (noscreenio) return;
  135.     echo();
  136.     nl();
  137.     nocbreak();
  138.     endwin();
  139. }
  140. textbackground(int color_num)
  141. {}
  142. textcolor(int colornum)
  143. {}
  144. gettextinfo(struct text_info *r)
  145. {
  146.     int x;
  147.     int y;
  148.     if (noscreenio) return;
  149.     getyx(stdscr,y,x);
  150.     r->curx = x;
  151.     r->cury = y;
  152.     r->wintop = vx_top;
  153. }
  154. screen_save()
  155. {}
  156. screen_restore()
  157. {
  158.     if (noscreenio) return;
  159.     scr_norm();
  160.     clrscr();
  161.     gotoxy(1,1);
  162.     cputs("\n");
  163. }
  164. int wyerr;
  165. w_message(char *s)
  166. {
  167.     wyerr++;
  168.     if (noscreenio) return;
  169.     scr_savexy();
  170.     gotoxy(1,wyerr);
  171.     clreol();
  172.     cputs(s);
  173.     scr_restorexy();
  174. }
  175. window(int left,int top, int right, int bottom)
  176. {
  177.     if (left==1 && top==1 && bottom==25) {
  178.     if (noscreenio) return;
  179. #ifndef unix
  180.         printf("\x1b[%d;%dr",1,24);
  181. #endif
  182.     }
  183.     vx_top = top;
  184.     vx_bot = bottom;
  185.     wyerr = 0;
  186. }
  187. clrscr()
  188. {
  189.     if (noscreenio) return;
  190.     if (vx_top==1 && vx_bot==25) {
  191.         clearok(stdscr,TRUE);
  192.         clear();
  193.         refresh();
  194.         clearok(stdscr,FALSE);
  195.         return;
  196.     }
  197.     clear();
  198. }
  199. scr_dots(int i)
  200. {
  201. }
  202. scr_left(int i)
  203. {
  204.     int y,x;
  205.     if (i<=0) return;
  206.     getyx(stdscr,y,x);
  207.     move(y,x-i);
  208. }
  209. scr_right(int i)
  210. {
  211.     int y,x;
  212.     if (i<=0) return;
  213.     getyx(stdscr,y,x);
  214.     move(y,x+i);
  215. }
  216. int vx_topsave,vx_botsave;
  217. int savex,savey;
  218. scr_savexy()
  219. {
  220.     if (noscreenio) return;
  221.     getyx(stdscr,savey,savex);
  222.     vx_topsave = vx_top;
  223.     vx_botsave = vx_bot;
  224.  
  225. }
  226. scr_restorexy()
  227. {
  228.     if (noscreenio) return;
  229.     move(savey,savex);
  230.     vx_top = vx_topsave;
  231.     vx_bot = vx_botsave;
  232. }
  233.  
  234. scr_norm()  /* yellow on blue */
  235. {
  236.     attrset(A_NORMAL);
  237. }
  238. scr_inv()   /* black on white */
  239. {
  240.     attrset(A_BOLD);
  241. }
  242. scr_grey()  /* black on grey */
  243. {
  244.     attrset(A_REVERSE);
  245. }
  246. scr_isblackwhite()
  247. {
  248.     return true;
  249. }
  250. scr_menubg()
  251. {
  252.     scr_norm();
  253. }
  254. scr_menuval()
  255. {
  256.     scr_inv();
  257. }
  258. scr_menuhi()
  259. {
  260.  
  261.     scr_grey();
  262. }
  263.  
  264. #ifndef unix
  265. #include <descrip.h>
  266. vax_edt(char *s)     /* call the vax EDT editor */
  267. {
  268.     $DESCRIPTOR(sdesc,"");
  269.     sdesc.dsc$a_pointer = s;
  270.     sdesc.dsc$w_length = strlen(s);
  271.     edt$edit(&sdesc,&sdesc);
  272. }
  273. #else
  274. vax_edt(char *s)
  275. {}
  276. #endif
  277.  
  278. #include "edt.h"
  279. #define true (!false)
  280. #define false 0
  281. int fner(char *s);
  282. int scr_refresh(void);
  283. int scr_getch(void);
  284. char *function_bar()
  285. {
  286.     return "F11-Help F12-Save F13-Load F14-Saveas F9-Graphmenu F10-Drawit ^x=Exit";
  287. }
  288.  
  289. struct escape_struct {char *str; int val;};
  290.  
  291. struct escape_struct gold[] = {
  292.         "v",     epaste,
  293.         "R",    esearch,
  294.         "S",    eundeleol,
  295.         NULL,    };
  296.  
  297. struct escape_struct eseq[] = {
  298.         "4~",     eselect,
  299.         "1~",    esearch,
  300.         "2~",    epaste,
  301.         "3~",    ecut,
  302.         "4~",    eselect,
  303.         "5~",    epageup,
  304.         "6~",    epagedown,
  305.         "A",    eup,
  306.         "B",    edown,
  307.         "C",    eright,
  308.         "D",    eleft,
  309.         "20~",    egraphmenu,
  310.         "21~",    edrawit,
  311.         "23~",    ehelp,
  312.         "24~",    esave,
  313.         "25~",    eload,
  314.         "26~",    esaveas,
  315.         "P",    egold,
  316.         "Q",    ehelp,
  317.         "R",    efindnext,
  318.         "S",    edeleol,
  319.         "n",    eselect,
  320.         "v",    ecut,
  321.         "l",    edelright,
  322.         NULL,    };
  323.  
  324. int gold_fn[] = {
  325.     edrawit,ehelp,esave,eload,esaveas,eshowerror,0,0,0,egraphmenu,edrawit
  326. };
  327. struct keymatch {int m; int val;};
  328. /* Normal key and ^ commands  commands */
  329. struct keymatch kmatch2[] = {
  330.     13, ereturn,
  331.     3, equit,
  332.     4, eword,
  333.     5, eedt,
  334.     6, efast,
  335.     7, edrawit,
  336.     18, eshowerror,
  337.     8, ehelp,
  338.     20, etrace,
  339.     12, efindnext,
  340.     21, eundelline,
  341.     24, eescape,
  342.     25, edelline,
  343.     26, eescape,
  344.     27, eescape,
  345.     127, edelete,
  346.     0,0
  347. };
  348. struct keymatch kmatchx[] = {
  349.     KEY_DOWN, edown,
  350.     KEY_UP, eup,
  351.     KEY_F0+4, edeleol,
  352.     KEY_LEFT, eleft,
  353.     KEY_RIGHT, eright,
  354.     KEY_NPAGE, epagedown,
  355.     KEY_PPAGE, epageup,
  356.     0,0
  357. };
  358. /* Control K commands */
  359. struct keymatch kmatch3[] = {
  360.     'b', eselect,
  361.     'v', emove,
  362.     'k', emark,
  363.     'c', ecopy,
  364.     'y', ecut,
  365.     'u', epaste,
  366.     'p', epaste,
  367.     'r', eblockread,
  368.     'w', eblockwrite,
  369.     'm', egraphmenu,
  370.     'l', eload,
  371.     'd', edrawit,
  372.     's', esave,
  373.     'x', equit,
  374.     0,0
  375. };
  376. /* Control Q commands */
  377. struct keymatch kmatch4[] = {
  378.     'f', esearch,
  379.     'c', eendoffile,
  380.     'r', etopoffile,
  381.     0,0
  382. };
  383. extern int noscreenio;
  384. tt_inkey()
  385. {
  386.     int i;
  387.     if (noscreenio) return getc(stdin);
  388.     else {
  389.         i = getch();
  390.         return i;
  391.     }
  392. }
  393. text_inkey()
  394. {
  395.     int cc,i,c1,c2;
  396.  
  397.     scr_refresh();
  398.  
  399. loop1:    cc = tt_inkey();
  400.     c2 = cc;
  401.     if (c2==KEY_F(1)) return do_gold();
  402.     if (cc>KEY_BREAK) {
  403.         for (i=0;kmatchx[i].m!=0;i++)
  404.         if (kmatchx[i].m==c2) return kmatchx[i].val;
  405.     }
  406.     switch(c2) {
  407.       default:
  408.         for (i=0;kmatch2[i].m!=0;i++)
  409.         if (kmatch2[i].m==c2) return kmatch2[i].val;
  410.         break;
  411.       case 27:
  412.         c2 = tt_inkey(); /* throw away next char (unless escape) */
  413.         if (c2==27) return eescape;
  414.       case -101:
  415.       case -113:
  416.         c2 = escape_seq();
  417.         if (c2==egold)     return do_gold();
  418.         return c2;
  419.         break;
  420.       case 17:
  421.         fner("^Q  F=Find string,  R=Top of file");
  422.         cc = tt_inkey();
  423.         c2 = (cc & 0xff);
  424.         if (c2<32) c2 = c2 + 'a' - 1;
  425.         c2 = tolower(c2);
  426.         for (i=0;kmatch4[i].m!=0;i++)
  427.         if (kmatch4[i].m==c2) return kmatch4[i].val;
  428.         fner("Unrecognized Quick movement command");
  429.         goto loop1;
  430.       case 11:
  431.         fner("^K  B=begin block,  P=Paste,  (use KP6 for Cut),  K=End block");
  432.         cc = tt_inkey();
  433.         c2 = (cc & 0xff);
  434.         if (c2<32) c2 = c2 + 'a' - 1;
  435.         c2 = tolower(c2);
  436.         for (i=0;kmatch3[i].m!=0;i++)
  437.         if (kmatch3[i].m==c2) return kmatch3[i].val;
  438.         fner("Unrecognized block command");
  439.         goto loop1;
  440.     }
  441.     return c2;
  442. }
  443. escape_seq()
  444. {
  445.     int cc,i;
  446.     unsigned char esq[10];
  447.     char *s;
  448.  
  449.     s = &esq[0];
  450.     *s++ = cc = tt_inkey();
  451.     while (cc<65) *s++ = cc = tt_inkey();
  452.     *s++ = 0;
  453.     for (i=0;eseq[i].str!=NULL;i++)
  454.         if (strcmp(eseq[i].str,esq)==0) break;
  455.     if (eseq[i].str!=NULL)
  456.         return eseq[i].val;
  457.     else
  458.         return 0;
  459.  
  460. }
  461. escape_seq_gold()
  462. {
  463.     int cc,i;
  464.     unsigned char esq[10];
  465.     char *s;
  466.  
  467.     s = &esq[0];
  468.     *s++ = cc = tt_inkey();
  469.     while (cc<65) *s++ = cc = tt_inkey();
  470.     *s++ = 0;
  471.     for (i=0;gold[i].str!=NULL;i++)
  472.         if (strcmp(gold[i].str,esq)==0) break;
  473.     if (gold[i].str!=NULL)
  474.         return gold[i].val;
  475.     else
  476.         return 0;
  477.  
  478. }
  479.  
  480. do_gold()
  481. {
  482.     int c2;
  483.     c2 = tt_inkey();
  484.     if (c2==KEY_F(4)) return eundeleol;
  485.     if (c2==27) {
  486.         tt_inkey();
  487.         return escape_seq_gold();
  488.     } else if (isdigit(c2)) {
  489.         return gold_fn[c2-'0'];
  490.     }
  491. }
  492.  
  493. char *function_bar(void);
  494. fner_clear()
  495. {
  496.     if (noscreenio) return;
  497.     if (iserr==false) return;
  498.     if (dont_clear) return;
  499.     window(1,1,80,25);
  500.     gotoxy(1,25);
  501.     scr_grey();
  502.     clreol();
  503.     gotoxy(2,25);
  504.     cputs(function_bar());
  505.     scr_norm();
  506.     iserr = false;
  507.     window(2,3,79,23);
  508. }
  509. extern int noscreenio;
  510. fner(char *s)
  511. {
  512.     if (dont_clear) return;
  513.     if (noscreenio) {
  514.         printf("%s\n",s);
  515.         return;
  516.     }
  517. /*    scr_savexy();
  518.     iserr = true;
  519.     window(1,1,80,25);
  520.     gotoxy(1,25);
  521. */    scr_inv();
  522.     clreol();
  523.     gotoxy(2,25);
  524.     cputs(s);
  525.     scr_norm();
  526.     scr_restorexy();
  527.     scr_refresh();
  528. }
  529.