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