home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / gle / util / manip / manip.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-29  |  11.2 KB  |  611 lines
  1. #include "all.h"
  2. #include "edt.h"
  3. #ifdef __TURBOC__
  4. #define DASHCHAR 249
  5. #include <alloc.h>
  6. #include "bios.h"
  7. #include "conio.h"
  8. #include "dir.h"
  9. #define WLEN 4
  10. #define WEND 24
  11. #else
  12. #define WLEN 3
  13. #define WEND 23
  14. #define DASHCHAR '.'
  15. #include "vaxconio.h"
  16. #endif
  17.  
  18. #define true (!false)
  19. #define false 0
  20. #define BCOLOR BLUE
  21. #define FCOLOR MAGENTA
  22. /* function prototypes */
  23.  
  24. /*
  25. manip /com=a.a
  26.  
  27.     refresh screen.
  28.     edit cell mode,
  29.     command mode.
  30.     arrow keys scroll screen.
  31.  
  32.     data cell:range
  33.     cell:range = expression
  34.     expressions,       c,r,x,y,c1..cn,r1..rn,sum(range),
  35.             c(x-1,y) = c(x,y)
  36.  
  37. */
  38. /* global stuff */
  39. int noscreenio;
  40. int gle_debug;
  41. int moving_x,moving_y;
  42. int data_x;
  43. int data_y;
  44. int changed;
  45. extern int islogging;
  46. extern int isating;
  47. /* local stuff */
  48. int iserr,dont_clear;
  49. int scr_frow=1,scr_fcol=1;
  50. int scr_width=76,scr_colwidth=8;
  51. int scr_ncol;
  52. int scr_nrow=18;
  53. int curx,cury;
  54. int max_x=0,max_y=0;     /* change to 1,1 */
  55.  
  56. int scr_blackwhite;
  57. int exit_manip;
  58. char file_name[80];
  59. int in_recover,single_step;
  60. char gleroot[80];
  61. extern char strmiss[];
  62. #ifdef unix
  63. #include "../../glepath.h"
  64. #endif
  65. /*---------------------------------------------------------------------------*/
  66. main(int argc, char **argv)
  67. {
  68.     int i;
  69.     char ans[90];
  70.     int cmd;
  71.     static char atfile[80];
  72.     char *ss;
  73.     strcpy(gleroot,argv[0]);
  74. #ifdef unix
  75.     ss = getenv("GLE_TOP");
  76.     if (ss==NULL) ss = GLEPATH;
  77.     strcpy(gleroot,ss);
  78. #endif
  79.     scr_init();
  80. #ifdef __TURBOC__
  81.     ss = strchr(gleroot,'\\');
  82.     if (ss==NULL) {fner("Unable to locat help file, press key to continue\n"); scr_getch();}
  83.     for (;strchr(ss+1,'\\')!=NULL;) ss = strchr(ss+1,'\\');
  84.     *(ss+1) = 0;
  85. #endif
  86.     if (strmiss[0]==0) strcpy(strmiss,"-");
  87.  
  88.     for (i=1;i<argc;i++) {
  89.         strupr( argv[i] );
  90.         if (strncmp( argv[i] , "-RECOVER",2)==0) in_recover = true;
  91.         else if (strncmp( argv[i] , "-STEP",3)==0) single_step = true ;
  92.         else if (strncmp( argv[i] , "-SIZE",4)==0) {
  93.             data_setsize(atoi(argv[i+1]),atoi(argv[i+2]));
  94.             i+=2;
  95.         }
  96.         else if (strncmp( argv[i] , "-COMMANDS",2)==0) strcpy(atfile,argv[++i]);
  97.         else if (strncmp( argv[i] , "-DEBUG",2)==0)         ;
  98.         else if (strncmp( argv[i] , "-FLOAT",2)==0)  set_usefloat();
  99.         else if (strncmp( argv[i] , "-SINGLE",4)==0)  set_usefloat();
  100.         else if (isalnum(*argv[i])) strcpy(file_name, argv[i]);
  101.         else {
  102.             printf("Unrecognized parameter {%s} \n",argv[i]);
  103.             printf("Usage: MANIP infile.dat -recover -step -commands c.log -single -size x y\n");
  104.             exit(0);
  105.         }
  106.     }
  107.     init_logging(file_name);
  108.  
  109.  
  110.     if (atfile[0]!=0) at_open(atfile);
  111.     strlwr(file_name);
  112.     if (strlen(file_name)>0) cmd_load(file_name,"",2);
  113. xx1:
  114.     if (strlen(file_name)==0) strcpy(file_name,"mtest.dat");
  115.     set_colwidth(10);
  116.     changed = false;
  117.     for (;exit_manip==false;) {
  118.         top_line();
  119.         hi_cell(curx,cury);
  120.         mjl_flush();
  121.         read_command(&cmd,ans,"% ");
  122.         if (cmd==eescape || cmd==equit) break;
  123.         if (cmd==0)     do_command(ans);
  124.         else if (cmd==eload) {
  125.             pick_file(ans,"*.dat");
  126.             refresh();
  127.             clear_data();
  128.             cmd_load(ans,"",2);
  129.         } else if (cmd==ehelp) {
  130.             do_help("MANIP","");
  131.             refresh();
  132.         } else if (cmd==esave) {
  133.             text_save();
  134.             refresh();
  135.         } else if (cmd==eload) {
  136.             refresh();
  137.         } else       do_arrow(cmd);
  138.     }
  139.     if (cmd==eescape) if (text_changed()) { exit_manip = false; goto xx1;}
  140.     window_exit();
  141.     if (islogging) log_close();
  142.     scr_end();
  143. }
  144. text_changed()
  145. {
  146.     int c;
  147.     if (!changed) return false;
  148.     for (;;) {
  149.         fner("Save in {%s} ? (Y,N)",file_name);
  150.         c = text_inkey();
  151.         fner_clear();
  152.         if (c==eescape) return true;
  153.         if (tolower(c)=='n') return false;
  154.         if (tolower(c)=='y') {text_save(); return false;}
  155.     }
  156. }
  157. text_save()
  158. {
  159.     cmd_save(file_name,"","",2);
  160.     changed = false;
  161. }
  162. fix_cur()
  163. {
  164.     if (curx<1) curx = 1;
  165.     if (cury<1) cury = 1;
  166. }
  167. shift_window()
  168. {
  169.     int doit=false;
  170.     fix_cur();
  171.     if (curx<scr_fcol || curx >= scr_fcol + scr_ncol) {
  172.         scr_fcol = curx - scr_ncol/2;
  173.         if (scr_fcol<1) scr_fcol = 1;
  174.         doit = true;
  175.     }
  176.     if (cury<scr_frow || cury >= scr_frow + scr_nrow) {
  177.         scr_frow = cury - scr_nrow/2;
  178.         if (scr_frow<1) scr_frow = 1;
  179.         doit = true;
  180.     }
  181.     if (doit) refresh();
  182. }
  183. do_arrow(int k)
  184. {
  185.     char buff[280];
  186.     show_cellwide(curx,cury);
  187.     moving_x = moving_y = 0;
  188.     switch (k) {
  189.     case eup:    cury--; moving_y = -1;  break;
  190.     case edown:     cury++; moving_y = 1; break;
  191.     case eright:    curx++; moving_x = 1; break;
  192.     case eleft:    curx--; moving_x = -1; break;
  193.     case edelline:    cury+=12; break;
  194.     case esearch:     cury-=12; break;
  195.     case ebigright: curx+=6; break;
  196.     case ebigleft:     curx-=6; break;
  197.     }
  198.     fix_cur();
  199.     sprintf(buff,"goto %d %d ",curx,cury);
  200.     if (islogging) log_write(buff);
  201.     shift_window();
  202.     hi_cell(curx,cury);
  203. }
  204. set_newxy(int x, int y)
  205. {
  206.     show_cellwide(curx,cury);
  207.     curx = x;
  208.     cury = y;
  209.     shift_window();
  210.     hi_cell(curx,cury);
  211. }
  212. window_norm()
  213. {
  214.     window(1,1,80,25);
  215. }
  216. window_exit()
  217. {
  218.     window(1,1,80,25);
  219.     gotoxy(1,25);
  220.     scr_norm();
  221.     printf("\n");clreol();
  222. }
  223. set_colwidth(int n)
  224. {
  225.     scr_colwidth = n;
  226.     scr_ncol = scr_width/scr_colwidth;
  227.     shift_window();
  228.     refresh();
  229. }
  230. set_ncol(int n)
  231. {
  232.     scr_ncol = n;
  233.     scr_colwidth = scr_width/scr_ncol;
  234.     scr_ncol;
  235.     shift_window();
  236.     refresh();
  237. }
  238. top_line()
  239. {
  240.     gotoxy(1,1); clreol();
  241.     wprintf("Free=%ld  Used(%d,%d) MANIP 3.3    Current file={%s}"
  242.         ,coreleft(),max_x,max_y,file_name);
  243. }
  244. void refresh()
  245. {
  246.     int i,j;
  247.  
  248.     fix_cur();
  249.     window_norm();
  250.     scr_norm();
  251.     clrscr();
  252.     top_line();
  253.     fner_clear();
  254.  
  255.     scr_menuhi();
  256.     for (i=1;i<=scr_ncol;i++) {
  257.         gotocell(i+scr_fcol-1,scr_frow-1);
  258.         wprintf("c%d",i+scr_fcol-1);
  259.     }
  260.     for (i=1;i<=scr_nrow;i++) {
  261.         gotocell(scr_fcol-1,i+scr_frow-1);
  262.         wprintf("r%d",i+scr_frow-1);
  263.     }
  264.     scr_norm();
  265.  
  266.     for (j=0;j<scr_nrow;j++) {
  267.      for (i=0;i<scr_ncol;i++) {
  268.         show_cell(i+scr_fcol,j+scr_frow);
  269.      }
  270.     }
  271.     iserr = true;
  272.     fner_clear();
  273.     hi_cell(curx,cury);
  274. }
  275. hi_cell(int x,int y)
  276. {
  277.     scr_menuhi();
  278.     show_cellwide(x,y);
  279.     scr_norm();
  280. }
  281. gotocell(int x,int y)
  282. {
  283.     if (x==scr_fcol-1) gotoxy( (x-scr_fcol+1)*scr_colwidth+1,(y-scr_frow)+3);
  284.     else gotoxy( (x-scr_fcol)*scr_colwidth+6,(y-scr_frow)+3);
  285. }
  286. void show_ifcell(int x, int y)
  287. {
  288.     if (x>=scr_fcol && x<(scr_fcol+scr_ncol)) {
  289.     if (y>=scr_frow && y<(scr_frow+scr_nrow)) {
  290.         show_cellwide(x,y);
  291.     }
  292.     }
  293. }
  294. void show_cell(int x, int y)
  295. {
  296.     gotocell(x,y);
  297.     cputs(scell(x,y));
  298. }
  299. void show_cellwide(int x, int y)
  300. {
  301.     char buff[280];
  302.     gotocell(x,y);
  303.     strcpy(buff,scell(x,y));
  304.     if (strlen(buff)<(scr_colwidth-1)) 
  305.         ncpy(buff+strlen(buff),"                ",
  306.             scr_colwidth-strlen(buff)-1);
  307.     cputs(buff);
  308. }
  309. #ifdef unix
  310. wprintf_do(char *s)
  311. {
  312.     printw("%s",s);
  313. }
  314. fner_do(char *output)
  315. {
  316.     if (strchr(output,'\n')!=NULL) *strchr(output,'\n') = 0;
  317.     fnerx(output);
  318. }
  319. printmess_do(char *output)
  320. {
  321.     if (strchr(output,'\n')!=NULL) *strchr(output,'\n') = 0;
  322.     fnerxx(output);
  323. }
  324. #endif
  325.  
  326. #ifndef unix
  327. void wprintf(va_list arg_list, ...)
  328. /* Prints to the window */
  329. {
  330.      va_list arg_ptr;
  331.      char *format;
  332.     char output[200];
  333.  
  334.      va_start(arg_ptr, arg_list);
  335.      format = arg_list;
  336.      vsprintf(output, format, arg_ptr);
  337. #ifdef __TURBOC__
  338.     printf(output);
  339. #else
  340.     cputs(output);
  341. #endif
  342. }
  343.  
  344. void fner(va_list arg_list, ...)
  345. /* Prints to the window */
  346. {
  347.      va_list arg_ptr;
  348.      char *format;
  349.     char output[200];
  350.  
  351.      va_start(arg_ptr, arg_list);
  352.      format = arg_list;
  353.     vsprintf(output, format, arg_ptr);
  354.     if (strchr(output,'\n')!=NULL) *strchr(output,'\n') = 0;
  355.     fnerx(output);
  356. }
  357. void printmess(va_list arg_list, ...)
  358. /* Prints to the window */
  359. {
  360.      va_list arg_ptr;
  361.      char *format;
  362.     char output[200];
  363.  
  364.      va_start(arg_ptr, arg_list);
  365.      format = arg_list;
  366.     vsprintf(output, format, arg_ptr);
  367.     if (strchr(output,'\n')!=NULL) *strchr(output,'\n') = 0;
  368.     fnerxx(output);
  369. }
  370. #endif
  371. d_tidyup()
  372. {}
  373. gle_abort(char *s)
  374. {
  375.     fner("ABORT {%s}\n",s);
  376.     exit(1);
  377. }
  378.  
  379. char *function_bar(void);
  380. void fner_clear(void)
  381. {
  382.     if (iserr==false) return;
  383.     if (dont_clear) return;
  384.     scr_savexy();
  385.     window_norm();
  386.     gotoxy(1,25);
  387.     scr_grey();
  388.     clreol();
  389.     gotoxy(2,25);
  390.     cputs(function_bar());
  391.     scr_norm();
  392.     iserr = false;
  393.     window_norm();
  394.     scr_restorexy();
  395. }
  396. fnerx(char *s)
  397. {
  398.     if (dont_clear) return;
  399.     scr_savexy();
  400.     iserr = true;
  401.     window_norm();
  402.     gotoxy(1,25);
  403.     scr_inv();
  404.     clreol();
  405.     gotoxy(2,25);
  406.     cputs(s);
  407.     scr_norm();
  408.     scr_restorexy();
  409.     scr_refresh();
  410. }
  411. fnerxx(char *s)
  412. {
  413.     scr_savexy();
  414.     command_scroll_up();
  415.     iserr = true;
  416.     window_norm();
  417.     gotoxy(1,23);
  418.     scr_inv();
  419.     clreol();
  420.     gotoxy(2,23);
  421.     cputs(s);
  422.     scr_norm();
  423.     scr_restorexy();
  424.     scr_refresh();
  425. }
  426. int read_command(int *cmd,char *ans,char *ques)
  427. {
  428.     static char *lastline[22];
  429.     int cl=0;
  430.     int rr,i;
  431.     int direc=0;
  432.  
  433.     if (isating) {
  434.         if (!at_read(ans)) goto contxx;
  435.         window(1,21,80,WEND);
  436.         gotoxy(1,WLEN);
  437.         scr_inv();
  438.         clreol();
  439.         gotoxy(2,WLEN);
  440.         clreol(); *cmd = 0;
  441.         cputs(ques); cputs(ans);  rr = false;
  442.         goto xxend;
  443.     }
  444. contxx:;
  445.     *ans = 0;
  446.     iserr = true;
  447.     window(1,21,80,WEND);
  448.     gotoxy(1,WLEN);
  449.     scr_inv();
  450.     clreol();
  451. xxxx:    gotoxy(2,WLEN);
  452.     clreol();
  453.     cputs(ques);
  454.     rr = read_str(cmd,ans);
  455.     if (*cmd == epageup) {
  456.         if (direc==-1) cl++;
  457.         if (lastline[cl]!=NULL) {
  458.             strcpy(ans,lastline[cl]);
  459.             cl++;
  460.         }
  461.         if (cl>18) cl = 0;
  462.         direc = 1;
  463.         goto xxxx;
  464.     }
  465.     if (*cmd == epagedown) {
  466.         if (direc==1) cl--;
  467.         cl--;
  468.         direc = -1;
  469.         if (cl<0) {cl = -1; *ans = 0; goto xxxx;}
  470.         if (lastline[cl]!=NULL) strcpy(ans,lastline[cl]);
  471.         goto xxxx;
  472.     }
  473. xxend:
  474.     gotoxy(1,WLEN);
  475.     if (strlen(ans)>0) {
  476.         if (lastline[20]!=NULL) free(lastline[20]);
  477.         for (i=20;i>0;i--) lastline[i] = lastline[i-1];
  478.         lastline[0] = sdup(ans);
  479.         command_scroll_up();
  480.     }
  481.     scr_norm();
  482.     clreol();
  483.     window_norm();
  484.     return rr;
  485. }
  486. int read_str(int *cmd, char *s)
  487. {
  488.     int c,cx=0;
  489.     char mbuff[280];
  490.     *cmd = 0;
  491.     cputs(s); cx = strlen(s);
  492.     for (;;) {
  493.      c = text_inkey();
  494.      if (iserr) fner_clear();
  495.      if (strlen(s)==0) {
  496.         switch (c) {
  497.     case edelline:
  498.     case esearch: 
  499.     case ebigright:
  500.     case ebigleft: 
  501.           case eup:
  502.           case edown:
  503.           case eleft:
  504.           case eright:
  505.           case equit:
  506.           case eescape:
  507.           case eload:
  508.           case esave:
  509.           case ehelp:
  510.              *cmd = c;
  511.              return false;
  512.         }
  513.      }
  514.      switch (c) {
  515.        case ebackline:
  516.         c = epageup;
  517.       case eload:
  518.       case esave:
  519.       case ehelp:
  520.        case epagedown:
  521.        case epageup:
  522.         *cmd = c;
  523.         return false;
  524.        case eescape: /* ESCAPE */
  525.         *cmd = c;
  526.        case equit: /* control c */
  527.         return true;
  528.        case eleft: /* left */
  529.         if (cx <= 0) break;
  530.         cx--;
  531.         scr_left(1);
  532.         break;
  533.        case eright: /* right */
  534.         if (cx >= strlen(s)) break;
  535.         cx++;
  536.         scr_right(1);
  537.         break;
  538.     case edelline:
  539.     case esearch: 
  540.     case ebigright:
  541.     case ebigleft: 
  542.        case eup: /* arrow up */
  543.        case edown: /* arrow down */
  544.         break;
  545.       case ereturn: /* carriage return */
  546.         return false;
  547.       case edelete: /* delete */
  548.         if (strlen(s)==0) break;
  549.         if (cx<1) break;
  550.         ncpy(mbuff,s,cx-1);
  551.         strcat(mbuff,s + cx);
  552.         strcpy(s,mbuff);
  553.         cx--;
  554.         scr_left(1);
  555.         cputs(s + cx);
  556.         putch(' ');
  557.         scr_left(strlen(s+cx)+1);
  558.         break;
  559.       case eshowerror:
  560.       case edrawit:
  561.         break;
  562.       default: /* normal key */
  563.         if (c<26  && c!=9) {fner("Key has no affect"); break;}
  564.         if (c>200)  fner("Unimplemented command");
  565.         else {
  566.             ncpy(mbuff,s,cx);
  567.             mbuff[cx] = c; mbuff[cx+1] = 0;
  568.             strcat(mbuff,s + cx);
  569.             strcpy(s,mbuff);
  570.             cputs(s + cx);
  571.             cx++;
  572.             scr_left(strlen(s+cx));
  573.         }
  574.         break;
  575.        }
  576.      }
  577. }
  578. command_scroll_up()
  579. {
  580.     window(1,21,80,WEND);
  581.     gotoxy(1,1);
  582.     delline();
  583. }
  584. char *gle_top()
  585. {
  586.     char *s;
  587. #ifdef unix
  588.     return gleroot;
  589. #endif
  590. #ifdef __TURBOC__
  591.     return gleroot;
  592. #else
  593.     return "cgle_top:";
  594. #endif
  595. }
  596. char *gledir(char *s);
  597. char *gledir(char *fname)
  598. {
  599.     static char fbuff[80];
  600. #ifdef __TURBOC__
  601.     strcpy(fbuff,gle_top());
  602. #else
  603.     strcpy(fbuff,"cgle_top:");
  604. #endif
  605. #ifdef unix
  606.     strcpy(fbuff,gle_top());
  607. #endif
  608.     strcat(fbuff,fname);
  609.     return &fbuff[0];
  610. }
  611.