[BACK]Return to if.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / plot

Diff for /OpenXM_contrib2/asir2000/plot/if.c between version 1.23 and 1.24

version 1.23, 2011/08/11 06:25:06 version 1.24, 2013/12/19 05:48:24
Line 45 
Line 45 
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *   *
  * $OpenXM: OpenXM_contrib2/asir2000/plot/if.c,v 1.22 2011/08/10 04:51:58 saito Exp $   * $OpenXM: OpenXM_contrib2/asir2000/plot/if.c,v 1.23 2011/08/11 06:25:06 saito Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 53 
Line 53 
 #include "ifplot.h"  #include "ifplot.h"
   
 #if defined(INTERVAL)  #if defined(INTERVAL)
 /* Time message and func*/  // Time message and func
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/resource.h>  #include <sys/resource.h>
 #include <sys/time.h>  #include <sys/time.h>
Line 65  double get_rtime();
Line 65  double get_rtime();
 void tstart()  void tstart()
 {  {
         get_eg(&ltime);          get_eg(&ltime);
         r0 = get_rtime();          r0=get_rtime();
 }  }
   
 void tstop(struct canvas *can)  void tstop(struct canvas *can)
Line 77  void tstop(struct canvas *can)
Line 77  void tstop(struct canvas *can)
         Widget warnshell,warndialog;          Widget warnshell,warndialog;
   
         get_eg(&egt1);          get_eg(&egt1);
         e = egt1.exectime - ltime.exectime;          e=egt1.exectime - ltime.exectime;
         g = egt1.gctime - ltime.gctime;          g=egt1.gctime - ltime.gctime;
         r = get_rtime() - r0;          r=get_rtime() - r0;
         sprintf(ts,"(%8.6f + gc %8.6f) total %8.6f \n",e,g,r);          sprintf(ts,"(%8.6f + gc %8.6f) total %8.6f \n",e,g,r);
         create_popup(can->shell,"Message",&ts,&warnshell,&warndialog);          create_popup(can->shell,"Message",&ts,&warnshell,&warndialog);
         XawDialogAddButton(warndialog,"OK",popdown_warning,warnshell);          XawDialogAddButton(warndialog,"OK",popdown_warning,warnshell);
Line 94  void tstop(struct canvas *can)
Line 94  void tstop(struct canvas *can)
   
 extern JMP_BUF ox_env;  extern JMP_BUF ox_env;
   
 int open_canvas(NODE arg)  int open_canvas(NODE arg){
 {  
         int id;          int id;
         struct canvas *can;          struct canvas *can;
         LIST wsize;          LIST wsize;
         STRING wname;          STRING wname;
   
         wsize = (LIST)ARG0(arg);          wsize=(LIST)ARG0(arg);
         wname = (STRING)ARG1(arg);          wname=(STRING)ARG1(arg);
           can=canvas[id=search_canvas()];
         can = canvas[id = search_canvas()];          can->mode=MODE_INTERACTIVE;
         can->mode = MODE_INTERACTIVE;          if(!wsize){
         if ( !wsize ) {                  can->width=DEFAULTWIDTH;
                 can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT;                  can->height=DEFAULTHEIGHT;
         } else {          } else {
                 can->width = QTOS((Q)BDY(BDY(wsize)));                  can->width=QTOS((Q)BDY(BDY(wsize)));
                 can->height = QTOS((Q)BDY(NEXT(BDY(wsize))));                  can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
         }          }
         if ( wname )          if(wname)can->wname=BDY(wname);
                 can->wname = BDY(wname);          else can->wname="";
         else  
                 can->wname = "";  
         create_canvas(can);          create_canvas(can);
         return id;          return id;
 }  }
   
 int plot(NODE arg)  
 {  int plot(NODE arg,int fn){
         int id;          int id;
         NODE n;          NODE n;
         struct canvas *can;          struct canvas *can;
Line 130  int plot(NODE arg)
Line 127  int plot(NODE arg)
         STRING wname;          STRING wname;
         V v;          V v;
   
         formula = (P)ARG0(arg);          formula=(P)ARG0(arg);
         xrange = (LIST)ARG1(arg);          xrange=(LIST)ARG1(arg);
         yrange = (LIST)ARG2(arg);          yrange=(LIST)ARG2(arg);
         zrange = (LIST)ARG3(arg);          zrange=(LIST)ARG3(arg);
         wsize = (LIST)ARG4(arg);          wsize=(LIST)ARG4(arg);
         wname = (STRING)ARG5(arg);          wname=(STRING)ARG5(arg);
           can=canvas[id=search_canvas()];
         can = canvas[id = search_canvas()];          if(xrange){
         if ( xrange ) {                  n=BDY(xrange);can->vx=VR((P)BDY(n));n=NEXT(n);
                 n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);                  can->qxmin=(Q)BDY(n);n=NEXT(n);can->qxmax=(Q)BDY(n);
                 can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);                  can->xmin=ToReal(can->qxmin);can->xmax=ToReal(can->qxmax);
                 can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);  
         }          }
         if ( yrange ) {          if(yrange){
                 n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n);                  n=BDY(yrange);can->vy=VR((P)BDY(n));n=NEXT(n);
                 can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n);                  can->qymin=(Q)BDY(n);n=NEXT(n);can->qymax=(Q)BDY(n);
                 can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax);                  can->ymin=ToReal(can->qymin);can->ymax=ToReal(can->qymax);
         }          }
         if ( xrange && yrange )          can->mode=fn;
                 can->mode = zrange ? MODE_CONPLOT : MODE_IFPLOT;          if(zrange){
         else                  n=BDY(zrange); can->zmin=ToReal(BDY(n));
                 can->mode = xrange ? MODE_PLOT : MODE_POLARPLOT;                  n=NEXT(n);can->zmax=ToReal(BDY(n));
                   n=NEXT(n);
         if ( zrange ) {                  if(can->mode==MODE_CONPLOT)can->nzstep=QTOS((Q)BDY(n));
                 n = NEXT(BDY(zrange));  
                 can->zmin = ToReal(BDY(n));  
                 n = NEXT(n); can->zmax = ToReal(BDY(n));  
                 n = NEXT(n);  
                 if ( can->mode == MODE_CONPLOT )  
                         can->nzstep = n ? QTOS((Q)BDY(n)) : MAXGC;  
                 else {                  else {
                         /* XXX */                          can->vx=VR((P)BDY(BDY(zrange)));
                         can->vx = VR((P)BDY(BDY(zrange)));                          can->nzstep=QTOS((Q)BDY(n));
                         can->nzstep = n ? QTOS((Q)BDY(n)) : DEFAULTPOLARSTEP;  
                 }                  }
         }          }
           if(!wsize){
         if ( !wsize ) {                  can->width=DEFAULTWIDTH;
                 can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT;                  can->height=DEFAULTHEIGHT;
         } else {          } else {
                 can->width = QTOS((Q)BDY(BDY(wsize)));                  can->width=QTOS((Q)BDY(BDY(wsize)));
                 can->height = QTOS((Q)BDY(NEXT(BDY(wsize))));                  can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
         }          }
         if ( wname )          if(wname) can->wname = BDY(wname);
                 can->wname = BDY(wname);          else can->wname="";
         else          can->formula=formula;
                 can->wname = "";          if(can->mode==MODE_PLOT){
         can->formula = formula;                  //plot
         if ( can->mode == MODE_PLOT ) {  
                 plotcalc(can);                  plotcalc(can);
                 create_canvas(can);                  create_canvas(can);
                 plot_print(display,can);                  plot_print(display,can);
         } else if ( can->mode == MODE_POLARPLOT ) {          } else if(can->mode==MODE_POLARPLOT){
                   //polarplot
                 polarplotcalc(can);                  polarplotcalc(can);
                 create_canvas(can);                  create_canvas(can);
                 plot_print(display,can);                  plot_print(display,can);
         } else {          } else {
                   //ifplot,conplot
                 create_canvas(can);                  create_canvas(can);
                 ifplotmain(can);                  ifplotmainOld(can);
         }          }
         copy_to_canvas(can);          copy_to_canvas(can);
         return id;          return id;
 }  }
   
 int memory_plot(NODE arg,LIST *bytes)  void ifplotmainOld(struct canvas *can){
 {          int i,width,height;
           double ** tabe;
   
           width=can->width;height=can->height;
           tabe=(double **)ALLOCA((width+1)*sizeof(double *));
           for(i=0;i<width;i++)tabe[i]=(double *)ALLOCA((height+1)*sizeof(double));
           define_cursor(can->window,runningcur);
           set_busy(can); set_selection();
           calc(tabe,can,0);
           if_printOld(display,tabe,can);
           reset_selection(); reset_busy(can);
           define_cursor(can->window,normalcur);
   }
   
   int memory_plot(NODE arg,LIST *bytes){
         NODE n;          NODE n;
         struct canvas tmp_can;          struct canvas tmp_can;
         struct canvas *can;          struct canvas *can;
Line 207  int memory_plot(NODE arg,LIST *bytes)
Line 211  int memory_plot(NODE arg,LIST *bytes)
         BYTEARRAY barray;          BYTEARRAY barray;
         Q qw,qh;          Q qw,qh;
   
         formula = (P)ARG0(arg);          formula=(P)ARG0(arg);
         xrange = (LIST)ARG1(arg);          xrange=(LIST)ARG1(arg);
         yrange = (LIST)ARG2(arg);          yrange=(LIST)ARG2(arg);
         zrange = (LIST)ARG3(arg);          zrange=(LIST)ARG3(arg);
         wsize = (LIST)ARG4(arg);          wsize=(LIST)ARG4(arg);
   
         bzero((char *)&tmp_can,sizeof(tmp_can));          bzero((char *)&tmp_can,sizeof(tmp_can));
         can = &tmp_can;          can=&tmp_can;
         n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);          n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
         can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);          can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
         can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);          can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
         if ( yrange ) {          if( yrange ){
                 n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n);                  n=BDY(yrange); can->vy=VR((P)BDY(n)); n=NEXT(n);
                 can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n);                  can->qymin=(Q)BDY(n); n=NEXT(n); can->qymax=(Q)BDY(n);
                 can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax);                  can->ymin=ToReal(can->qymin); can->ymax=ToReal(can->qymax);
                 if ( zrange ) {                  if( zrange ){
                         n = NEXT(BDY(zrange));                          n=NEXT(BDY(zrange));
                         can->zmin = ToReal(BDY(n)); n = NEXT(n); can->zmax = ToReal(BDY(n));                          can->zmin=ToReal(BDY(n)); n=NEXT(n); can->zmax=ToReal(BDY(n));
                         if ( n = NEXT(n) )                          if(n=NEXT(n)) can->nzstep=QTOS((Q)BDY(n));
                                 can->nzstep = QTOS((Q)BDY(n));                          else can->nzstep=MAXGC;
                         else                          can->mode=MODE_CONPLOT;
                                 can->nzstep = MAXGC;  
                         can->mode = MODE_CONPLOT;  
                 } else                  } else
                         can->mode = MODE_IFPLOT;                          can->mode=MODE_IFPLOT;
         } else          } else
                 can->mode = MODE_PLOT;                  can->mode=MODE_PLOT;
         if ( !wsize ) {          if( !wsize ){
                 can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT;                  can->width=DEFAULTWIDTH; can->height=DEFAULTHEIGHT;
         } else {          } else {
                 can->width = QTOS((Q)BDY(BDY(wsize)));                  can->width=QTOS((Q)BDY(BDY(wsize)));
                 can->height = QTOS((Q)BDY(NEXT(BDY(wsize))));                  can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
         }          }
         can->wname = "";          can->wname="";
         can->formula = formula;          can->formula=formula;
         if ( can->mode == MODE_PLOT ) {          if( can->mode == MODE_PLOT ){
                 plotcalc(can);                  plotcalc(can);
                 memory_print(can,&barray);                  memory_print(can,&barray);
                 STOQ(can->width,qw); STOQ(can->height,qh);                  STOQ(can->width,qw); STOQ(can->height,qh);
                 n = mknode(3,qw,qh,barray);                  n=mknode(3,qw,qh,barray);
                 MKLIST(*bytes,n);                  MKLIST(*bytes,n);
         } else {          } else {
                 width = can->width; height = can->height;                  width=can->width; height=can->height;
                 tabe = (double **)ALLOCA(width*sizeof(double *));                  tabe=(double **)ALLOCA(width*sizeof(double *));
                 for ( i = 0; i < width; i++ )                  for( i=0; i<width; i++ )
                         tabe[i] = (double *)ALLOCA(height*sizeof(double));                          tabe[i]=(double *)ALLOCA(height*sizeof(double));
                 calc(tabe,can,1);                  calc(tabe,can,1);
                 memory_if_print(tabe,can,&barray);                  memory_if_print(tabe,can,&barray);
                 STOQ(width,qw); STOQ(height,qh);                  STOQ(width,qw); STOQ(height,qh);
                 n = mknode(3,qw,qh,barray);                  n=mknode(3,qw,qh,barray);
                 MKLIST(*bytes,n);                  MKLIST(*bytes,n);
         }          }
 }  }
   
 int plotover(NODE arg)  int plotover(NODE arg){
 {          int id,orgcolor,color;
         int index, color;  
         P formula;          P formula;
         struct canvas *can;          struct canvas *can;
         VL vl,vl0;          VL vl,vl0;
   
         index = QTOS((Q)ARG0(arg));          id=QTOS((Q)ARG0(arg));
         formula = (P)ARG1(arg);          formula=(P)ARG1(arg);
         can = canvas[index];          color=QTOS((Q)ARG2(arg));
         color = can->color;  
         if ( !can->window )          can=canvas[id];
                 return -1;          orgcolor=can->color;
           can->color=color;
         get_vars_recursive((Obj)formula,&vl);          get_vars_recursive((Obj)formula,&vl);
         for ( vl0 = vl; vl0; vl0 = NEXT(vl0) )          for(vl0=vl;vl0;vl0=NEXT(vl0))
                 if ( vl0->v->attr == (pointer)V_IND )                  if(vl0->v->attr==(pointer)V_IND)
                         if ( vl->v != can->vx && vl->v != can->vy )                          if(vl->v!=can->vx && vl->v!=can->vy)return -1;
                                 return -1;          if(argc(arg)==3) can->color=QTOS((Q)ARG2(arg));
         if ( argc(arg) == 3 )          else can->color=0;
                 can->color = QTOS((Q)ARG2(arg));  
         else  
                 can->color = 0;  
 #if !defined(VISUAL)  #if !defined(VISUAL)
         set_drawcolor(can->color);          set_drawcolor(can->color);
 #endif  #endif
         current_can = can;          current_can=can;
         can->formula = formula;          can->formula=formula;
         if ( can->mode == MODE_PLOT ) {          if(can->mode==MODE_PLOT){
                 plotcalc(can);                  plotcalc(can);
                 plot_print(display,can);                  plot_print(display,can);
         } else          } else ifplotmainOld(can);
                 ifplotmain(can);  
         copy_to_canvas(can);          copy_to_canvas(can);
         can->color = color;          can->color=color;
 #if !defined(VISUAL)  #if !defined(VISUAL)
         set_drawcolor(can->color);          set_drawcolor(can->color);
 #endif  #endif
         return index;          return index;
 }  }
   
 int drawcircle(NODE arg)  int drawcircle(NODE arg){
 {  
 #if !defined(VISUAL)  #if !defined(VISUAL)
         int id;          int id,index,wx,wy,wr,c;
         int index;  
         pointer ptr;          pointer ptr;
         Q ret;          Q ret;
         LIST xyr;          LIST xyr;
         Obj x,y,r;          Obj x,y,r;
         int wx,wy,wr,c;  
         struct canvas *can;          struct canvas *can;
   
         index = QTOS((Q)ARG0(arg));          index=QTOS((Q)ARG0(arg));
         xyr = (LIST)ARG1(arg);          xyr=(LIST)ARG1(arg);
         x = (Obj)ARG0(BDY(xyr)); y = (Obj)ARG1(BDY(xyr)); r = (Obj)ARG2(BDY(xyr));          x=(Obj)ARG0(BDY(xyr)); y=(Obj)ARG1(BDY(xyr)); r=(Obj)ARG2(BDY(xyr));
         c = QTOS((Q)ARG2(arg));          c=QTOS((Q)ARG2(arg));
         can = canvas[index];          can=canvas[index];
         if ( !can->window )          if(!can->window)return -1;
                 return -1;  
         else {          else {
                 current_can = can;                  current_can=can;
                 set_drawcolor(c);                  set_drawcolor(c);
                 wx = (ToReal(x)-can->xmin)*can->width/(can->xmax-can->xmin);                  wx=(ToReal(x)-can->xmin)*can->width/(can->xmax-can->xmin);
                 wy = (can->ymax-ToReal(y))*can->height/(can->ymax-can->ymin);                  wy=(can->ymax-ToReal(y))*can->height/(can->ymax-can->ymin);
                 wr = ToReal(r);                  wr=ToReal(r);
                 XFillArc(display,can->pix,cdrawGC,wx-wr/2,wy-wr/2,wr,wr,0,360*64);                  XFillArc(display,can->pix,cdrawGC,wx-wr/2,wy-wr/2,wr,wr,0,360*64);
                 copy_to_canvas(can);                  copy_to_canvas(can);
                 set_drawcolor(can->color);                  set_drawcolor(can->color);
Line 334  int drawcircle(NODE arg)
Line 328  int drawcircle(NODE arg)
 #endif  #endif
 }  }
   
 int draw_obj(NODE arg)  int draw_obj(NODE arg){
 {          int index,color,x,y,u,v,len,r;
         int index;  
         int x,y,u,v,len,r;  
         NODE obj,n;          NODE obj,n;
         RealVect *vect;          RealVect *vect;
         struct canvas *can;          struct canvas *can;
         int color;  
   
         index = QTOS((Q)ARG0(arg));          index=QTOS((Q)ARG0(arg));
         can = canvas[index];          can=canvas[index];
         if ( !can && closed_canvas[index] ) {          if(!can && closed_canvas[index]){
                 canvas[index] = closed_canvas[index];                  canvas[index]=closed_canvas[index];
                 closed_canvas[index] = 0;                  closed_canvas[index]=0;
                 can = canvas[index];                  can=canvas[index];
                 popup_canvas(index);                  popup_canvas(index);
                 current_can = can;                  current_can=can;
         } else if ( !can || (can && !can->window) ) {          } else if(!can||(can && !can->window)){
                 set_lasterror("draw_obj : canvas does not exist");                  set_lasterror("draw_obj : canvas does not exist");
                 return -1;                  return -1;
         }          }
   
         obj = BDY((LIST)ARG1(arg));          obj=BDY((LIST)ARG1(arg));
         if ( argc(arg) == 3 )          if(argc(arg)== 3) color=QTOS((Q)ARG2(arg));
                 color = QTOS((Q)ARG2(arg));          else color=0; // black
         else          switch(len=length(obj)){
                 color = 0; /* black */                  case 2: // point
         switch ( len = length(obj) ) {                          x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj));
                 case 2: /* point */  
                         x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj));  
                         draw_point(display,can,x,y,color);                          draw_point(display,can,x,y,color);
                         MKRVECT3(vect,x,y,color); MKNODE(n,vect,can->history);                          MKRVECT3(vect,x,y,color); MKNODE(n,vect,can->history);
                         can->history = n;                          can->history=n;
                         break;                          break;
                 case 3: /* circle */                  case 3: // circle
                         x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj));                          x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj));
                         r = (int)ToReal((Q)ARG2(obj));                          r=(int)ToReal((Q)ARG2(obj));
                         MKRVECT4(vect,x,y,r,color); MKNODE(n,vect,can->history);                          MKRVECT4(vect,x,y,r,color); MKNODE(n,vect,can->history);
                         can->history = n;                          can->history=n;
                         break;                          break;
                 case 4: /* line */                  case 4: // line
                         x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj));                          x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj));
                         u = (int)ToReal((Q)ARG2(obj)); v = (int)ToReal((Q)ARG3(obj));                          u=(int)ToReal((Q)ARG2(obj)); v=(int)ToReal((Q)ARG3(obj));
                         draw_line(display,can,x,y,u,v,color);                          draw_line(display,can,x,y,u,v,color);
                         MKRVECT5(vect,x,y,u,v,color); MKNODE(n,vect,can->history);                          MKRVECT5(vect,x,y,u,v,color); MKNODE(n,vect,can->history);
                         can->history = n;                          can->history=n;
                         break;                          break;
                 default:                  default:
                         set_lasterror("draw_obj : invalid request");                          set_lasterror("draw_obj : invalid request");
Line 391  int draw_obj(NODE arg)
Line 380  int draw_obj(NODE arg)
         return 0;          return 0;
 }  }
   
 int draw_string(NODE arg)  int draw_string(NODE arg){
 {          int index,x,y,color;
         int index,x,y;  
         char *str;          char *str;
         NODE pos;          NODE pos;
         struct canvas *can;          struct canvas *can;
         int color;  
   
         index = QTOS((Q)ARG0(arg));          index=QTOS((Q)ARG0(arg));
         can = canvas[index];          can=canvas[index];
         if ( !can && closed_canvas[index] ) {          if(!can && closed_canvas[index]){
                 canvas[index] = closed_canvas[index];                  canvas[index]=closed_canvas[index];
                 closed_canvas[index] = 0;                  closed_canvas[index]=0;
                 can = canvas[index];                  can=canvas[index];
                 popup_canvas(index);                  popup_canvas(index);
                 current_can = can;                  current_can=can;
         } else if ( !can || (can && !can->window) ) {          } else if(!can||(can && !can->window)){
                 set_lasterror("draw_obj : canvas does not exist");                  set_lasterror("draw_obj : canvas does not exist");
                 return -1;                  return -1;
         }          }
   
         pos = BDY((LIST)ARG1(arg));          pos=BDY((LIST)ARG1(arg));
         str = BDY((STRING)ARG2(arg));          str=BDY((STRING)ARG2(arg));
         if ( argc(arg) == 4 )          if(argc(arg)==4)color=QTOS((Q)ARG3(arg));
                 color = QTOS((Q)ARG3(arg));          else color=0; // black
         else          x=(int)ToReal((Q)ARG0(pos));
                 color = 0; /* black */          y=(int)ToReal((Q)ARG1(pos));
         x = (int)ToReal((Q)ARG0(pos));  
         y = (int)ToReal((Q)ARG1(pos));  
         draw_character_string(display,can,x,y,str,color);          draw_character_string(display,can,x,y,str,color);
 #if !defined(VISUAL)  #if !defined(VISUAL)
         set_drawcolor(can->color);          set_drawcolor(can->color);
Line 427  int draw_string(NODE arg)
Line 412  int draw_string(NODE arg)
         return 0;          return 0;
 }  }
   
 int clear_canvas(NODE arg)  int clear_canvas(NODE arg){
 {  
         int index;          int index;
         struct canvas *can;          struct canvas *can;
   
         index = QTOS((Q)ARG0(arg));          index=QTOS((Q)ARG0(arg));
         can = canvas[index];          can=canvas[index];
         if ( !can || !can->window )          if(!can||!can->window) return -1;
                 return -1;  
         clear_pixmap(can);          clear_pixmap(can);
         copy_to_canvas(can);          copy_to_canvas(can);
         /* clear the history */          // clear the history
         can->history = 0;          can->history=0;
 }  }
   
 #define RealtoDbl(r) ((r)?BDY(r):0.0)  #define RealtoDbl(r) ((r)?BDY(r):0.0)
   
 int arrayplot(NODE arg)  int arrayplot(NODE arg){
 {  
         int id,ix,w,h;          int id,ix,w,h;
         VECT array;          VECT array;
         LIST xrange,wsize;          LIST xrange,wsize;
Line 456  int arrayplot(NODE arg)
Line 438  int arrayplot(NODE arg)
         struct canvas *can;          struct canvas *can;
         POINT *pa;          POINT *pa;
   
         array = (VECT)ARG0(arg);          array=(VECT)ARG0(arg);
         xrange = (LIST)ARG1(arg);          xrange=(LIST)ARG1(arg);
         can = canvas[id = search_canvas()];          can=canvas[id=search_canvas()];
         n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);          n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
         can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);          can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
         can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);          can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
         if ( !wsize ) {          if(!wsize){
                 can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT;                  can->width=DEFAULTWIDTH;
                   can->height=DEFAULTHEIGHT;
         } else {          } else {
                 can->width = QTOS((Q)BDY(BDY(wsize)));                  can->width=QTOS((Q)BDY(BDY(wsize)));
                 can->height = QTOS((Q)BDY(NEXT(BDY(wsize))));                  can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
         }          }
         can->wname = wname; can->formula = 0; can->mode = MODE_PLOT;          can->wname=wname; can->formula=0; can->mode=MODE_PLOT;
         create_canvas(can);          create_canvas(can);
         w = array->len;          w=array->len;
         h = can->height;          h=can->height;
         tab = (Real *)BDY(array);          tab=(Real *)BDY(array);
         if ( can->ymax == can->ymin ) {          if(can->ymax==can->ymin){
                 for ( ymax = ymin = RealtoDbl(tab[0]), ix = 1; ix < w; ix++ ) {                  for(ymax=ymin=RealtoDbl(tab[0]),ix=1; ix<w; ix++){
                         if ( RealtoDbl(tab[ix]) > ymax )                          if(RealtoDbl(tab[ix])>ymax)ymax=RealtoDbl(tab[ix]);
                                 ymax = RealtoDbl(tab[ix]);                          if(RealtoDbl(tab[ix])<ymin)ymin=RealtoDbl(tab[ix]);
                         if ( RealtoDbl(tab[ix]) < ymin )  
                                 ymin = RealtoDbl(tab[ix]);  
                 }                  }
                 can->ymax = ymax; can->ymin = ymin;                  can->ymax=ymax;
                   can->ymin=ymin;
         } else {          } else {
                 ymax = can->ymax; ymin = can->ymin;                  ymax=can->ymax;
                   ymin=can->ymin;
         }          }
         dy = ymax-ymin;          dy=ymax-ymin;
         can->pa = (struct pa *)MALLOC(sizeof(struct pa));          can->pa=(struct pa *)MALLOC(sizeof(struct pa));
         can->pa[0].length = w;          can->pa[0].length=w;
         can->pa[0].pos = pa = (POINT *)MALLOC(w*sizeof(POINT));          can->pa[0].pos=pa=(POINT *)MALLOC(w*sizeof(POINT));
         xstep = (double)can->width/(double)(w-1);          xstep=(double)can->width/(double)(w-1);
         for ( ix = 0; ix < w; ix++ ) {          for(ix=0;ix<w;ix++){
 #ifndef MAXSHORT  #ifndef MAXSHORT
 #define MAXSHORT ((short)0x7fff)  #define MAXSHORT ((short)0x7fff)
 #endif  #endif
                 double t;                  double t;
   
                 pa[ix].x = (int)(ix*xstep);                  pa[ix].x=(int)(ix*xstep);
                 t = (h - 1)*(ymax - RealtoDbl(tab[ix]))/dy;                  t=(h - 1)*(ymax - RealtoDbl(tab[ix]))/dy;
                 if ( t > MAXSHORT )                  if(t>MAXSHORT)pa[ix].y=MAXSHORT;
                         pa[ix].y = MAXSHORT;                  else if(t<-MAXSHORT)pa[ix].y=-MAXSHORT;
                 else if ( t < -MAXSHORT )                  else pa[ix].y=(long)t;
                         pa[ix].y = -MAXSHORT;  
                 else  
                         pa[ix].y = (long)t;  
         }          }
         plot_print(display,can);          plot_print(display,can);
         copy_to_canvas(can);          copy_to_canvas(can);
         return id;          return id;
 }  }
   
 void ifplot_resize(struct canvas *can,POINT spos,POINT epos)  void ifplot_resize(struct canvas *can,POINT spos,POINT epos){
 {  
         struct canvas *ncan;          struct canvas *ncan;
         struct canvas fakecan;          struct canvas fakecan;
         Q dx,dy,dx2,dy2,xmin,xmax,ymin,ymax,xmid,ymid;          Q dx,dy,dx2,dy2,xmin,xmax,ymin,ymax,xmid,ymid;
Line 519  void ifplot_resize(struct canvas *can,POINT spos,POINT
Line 498  void ifplot_resize(struct canvas *can,POINT spos,POINT
         int new;          int new;
         int w,h,m;          int w,h,m;
   
         if ( XC(spos) < XC(epos) && YC(spos) < YC(epos) ) {          if(XC(spos)<XC(epos) && YC(spos)<YC(epos)){
                 if ( can->precise && !can->wide ) {                  if(can->precise && !can->wide){
                         fakecan = *can; ncan = &fakecan;                          fakecan=*can;
                           ncan=&fakecan;
                 } else {                  } else {
                         new = search_canvas(); ncan = canvas[new];                          new=search_canvas();
                           ncan=canvas[new];
                 }                  }
                 ncan->mode = can->mode;                  ncan->mode=can->mode;
                 ncan->zmin = can->zmin; ncan->zmax = can->zmax;                  ncan->zmin=can->zmin; ncan->zmax=can->zmax;
                 ncan->nzstep = can->nzstep;                  ncan->nzstep=can->nzstep;
                 ncan->wname = can->wname;                  ncan->wname=can->wname;
                 ncan->vx = can->vx; ncan->vy = can->vy;                  ncan->vx=can->vx; ncan->vy=can->vy;
                 ncan->formula = can->formula;                  ncan->formula=can->formula;
                 w = XC(epos)-XC(spos);                  w=XC(epos)-XC(spos);
                 h = YC(epos)-YC(spos);                  h=YC(epos)-YC(spos);
                 m = MAX(can->width,can->height);                  m=MAX(can->width,can->height);
                 if ( can->precise ) {                  if(can->precise){
                         ncan->width = w; ncan->height = h;                          ncan->width=w;
                 } else if ( w > h ) {                          ncan->height=h;
                         ncan->width = m; ncan->height = m * h/w;                  } else if(w>h){
                           ncan->width=m;
                           ncan->height=m*h/w;
                 } else {                  } else {
                         ncan->width = m * w/h; ncan->height = m;                          ncan->width=m*w/h;
                           ncan->height=m;
                 }                  }
                 if ( can->wide ) {                  if(can->wide){
                         STOQ(10,ten); STOQ(2,two);                          STOQ(10,ten);
                         subq(can->qxmax,can->qxmin,&t); mulq(t,ten,&dx);                          STOQ(2,two);
                         subq(can->qymax,can->qymin,&t); mulq(t,ten,&dy);                          subq(can->qxmax,can->qxmin,&t);
                         addq(can->qxmax,can->qxmin,&t); divq(t,two,&xmid);                          mulq(t,ten,&dx);
                         addq(can->qymax,can->qymin,&t); divq(t,two,&ymid);                          subq(can->qymax,can->qymin,&t);
                         divq(dx,two,&dx2); divq(dy,two,&dy2);                          mulq(t,ten,&dy);
                         subq(xmid,dx2,&xmin); addq(xmid,dx2,&xmax);                          addq(can->qxmax,can->qxmin,&t);
                         subq(ymid,dy2,&ymin); addq(ymid,dy2,&ymax);                          divq(t,two,&xmid);
                           addq(can->qymax,can->qymin,&t);
                           divq(t,two,&ymid);
                           divq(dx,two,&dx2);
                           divq(dy,two,&dy2);
                           subq(xmid,dx2,&xmin);
                           addq(xmid,dx2,&xmax);
                           subq(ymid,dy2,&ymin);
                           addq(ymid,dy2,&ymax);
                 } else {                  } else {
                         subq(can->qxmax,can->qxmin,&dx); subq(can->qymax,can->qymin,&dy);                          subq(can->qxmax,can->qxmin,&dx);
                         xmin = can->qxmin; xmax = can->qxmax;                          subq(can->qymax,can->qymin,&dy);
                         ymin = can->qymin; ymax = can->qymax;                          xmin=can->qxmin;
                           xmax=can->qxmax;
                           ymin=can->qymin;
                           ymax=can->qymax;
                 }                  }
                 STOQ(XC(spos),sx); STOQ(YC(spos),sy); STOQ(XC(epos),ex); STOQ(YC(epos),ey);                  STOQ(XC(spos),sx); STOQ(YC(spos),sy); STOQ(XC(epos),ex); STOQ(YC(epos),ey);
                 STOQ(can->width,cw); STOQ(can->height,ch);                  STOQ(can->width,cw); STOQ(can->height,ch);
Line 561  void ifplot_resize(struct canvas *can,POINT spos,POINT
Line 556  void ifplot_resize(struct canvas *can,POINT spos,POINT
                 mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax);                  mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax);
                 mulq(ey,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymin);                  mulq(ey,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymin);
                 mulq(sy,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymax);                  mulq(sy,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymax);
                 ncan->xmin = ToReal(ncan->qxmin); ncan->xmax = ToReal(ncan->qxmax);                  ncan->xmin=ToReal(ncan->qxmin); ncan->xmax=ToReal(ncan->qxmax);
                 ncan->ymin = ToReal(ncan->qymin); ncan->ymax = ToReal(ncan->qymax);                  ncan->ymin=ToReal(ncan->qymin); ncan->ymax=ToReal(ncan->qymax);
                 if ( can->precise && !can->wide ) {                  if(can->precise && !can->wide){
                         current_can = can;                          current_can=can;
                         alloc_pixmap(ncan);                          alloc_pixmap(ncan);
 #if defined(VISUAL)  #if defined(VISUAL)
                         ncan->real_can = can;                          ncan->real_can=can;
 #endif  #endif
                         qifplotmain(ncan);                          qifplotmain(ncan);
                         copy_subimage(ncan,can,spos);                          copy_subimage(ncan,can,spos);
                         copy_to_canvas(can);                          copy_to_canvas(can);
                 } else {                  } else {
                         create_canvas(ncan);                          create_canvas(ncan);
                         if ( can->precise )                          if( can->precise ) qifplotmain(ncan);
                                 qifplotmain(ncan);                          else ifplotmain(ncan);
                         else  
                                 ifplotmain(ncan);  
                         copy_to_canvas(ncan);                          copy_to_canvas(ncan);
                 }                  }
         }          }
 }  }
   
 void plot_resize(struct canvas *can,POINT spos,POINT epos)  void plot_resize(struct canvas *can,POINT spos,POINT epos){
 {  
         struct canvas *ncan;          struct canvas *ncan;
         Q dx,dx2,xmin,xmax,xmid;          Q dx,dx2,xmin,xmax,xmid;
         double dy,ymin,ymax,ymid;          double dy,ymin,ymax,ymid;
Line 593  void plot_resize(struct canvas *can,POINT spos,POINT e
Line 585  void plot_resize(struct canvas *can,POINT spos,POINT e
         int new;          int new;
         int w,h,m;          int w,h,m;
   
         if ( XC(spos) < XC(epos) && YC(spos) < YC(epos) ) {          if( XC(spos)<XC(epos) && YC(spos)<YC(epos) ){
                 new = search_canvas(); ncan = canvas[new];                  new=search_canvas(); ncan=canvas[new];
                 ncan->mode = can->mode;                  ncan->mode=can->mode;
                 ncan->zmin = can->zmin; ncan->zmax = can->zmax;                  ncan->zmin=can->zmin; ncan->zmax=can->zmax;
                 ncan->nzstep = can->nzstep;                  ncan->nzstep=can->nzstep;
                 ncan->wname = can->wname;                  ncan->wname=can->wname;
                 ncan->vx = can->vx; ncan->vy = can->vy;                  ncan->vx=can->vx; ncan->vy=can->vy;
                 ncan->formula = can->formula;                  ncan->formula=can->formula;
                 w = XC(epos)-XC(spos);                  w=XC(epos)-XC(spos);
                 h = YC(epos)-YC(spos);                  h=YC(epos)-YC(spos);
                 m = MAX(can->width,can->height);                  m=MAX(can->width,can->height);
                 if ( w > h ) {                  if( w>h ){
                         ncan->width = m; ncan->height = m * h/w;                          ncan->width=m; ncan->height=m * h/w;
                 } else {                  } else {
                         ncan->width = m * w/h; ncan->height = m;                          ncan->width=m * w/h; ncan->height=m;
                 }                  }
                 if ( can->wide ) {                  if( can->wide ){
                         STOQ(10,ten); STOQ(2,two);                          STOQ(10,ten); STOQ(2,two);
                         subq(can->qxmax,can->qxmin,&t); mulq(t,ten,&dx);                          subq(can->qxmax,can->qxmin,&t); mulq(t,ten,&dx);
                         addq(can->qxmax,can->qxmin,&t); divq(t,two,&xmid);                          addq(can->qxmax,can->qxmin,&t); divq(t,two,&xmid);
                         divq(dx,two,&dx2); subq(xmid,dx2,&xmin); addq(xmid,dx2,&xmax);                          divq(dx,two,&dx2); subq(xmid,dx2,&xmin); addq(xmid,dx2,&xmax);
   
                         dy = (can->ymax-can->ymin)*10;                          dy=(can->ymax-can->ymin)*10;
                         ymid = (can->ymax+can->ymin)/2;                          ymid=(can->ymax+can->ymin)/2;
                         ymin = ymid-dy/2; ymax = ymid+dy/2;                          ymin=ymid-dy/2; ymax=ymid+dy/2;
                 } else {                  } else {
                         subq(can->qxmax,can->qxmin,&dx);                          subq(can->qxmax,can->qxmin,&dx);
                         xmin = can->qxmin; xmax = can->qxmax;                          xmin=can->qxmin; xmax=can->qxmax;
   
                         dy = can->ymax-can->ymin;                          dy=can->ymax-can->ymin;
                         ymin = can->ymin; ymax = can->ymax;                          ymin=can->ymin; ymax=can->ymax;
                 }                  }
                 STOQ(XC(spos),sx); STOQ(XC(epos),ex); STOQ(can->width,cw);                  STOQ(XC(spos),sx); STOQ(XC(epos),ex); STOQ(can->width,cw);
                 mulq(sx,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmin);                  mulq(sx,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmin);
                 mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax);                  mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax);
                 ncan->xmin = ToReal(ncan->qxmin); ncan->xmax = ToReal(ncan->qxmax);                  ncan->xmin=ToReal(ncan->qxmin); ncan->xmax=ToReal(ncan->qxmax);
   
                 ncan->ymin = ymax-YC(epos)*dy/can->height;                  ncan->ymin=ymax-YC(epos)*dy/can->height;
                 ncan->ymax = ymax-YC(spos)*dy/can->height;                  ncan->ymax=ymax-YC(spos)*dy/can->height;
   
                 create_canvas(ncan);                  create_canvas(ncan);
                 plotcalc(ncan);                  plotcalc(ncan);
Line 640  void plot_resize(struct canvas *can,POINT spos,POINT e
Line 632  void plot_resize(struct canvas *can,POINT spos,POINT e
         }          }
 }  }
   
 void ifplotmain(struct canvas *can)  void qifplotmain(struct canvas *can)
 {  {
         int width,height;          int width,height;
         double **tabe;          char **tabe,*tabeb;
         int i;          int i;
   
 #if defined(INTERVAL)          width=can->width; height=can->height;
         tstart();          tabe=(char **)ALLOCA(width*sizeof(char *)+width*height*sizeof(char));
 #endif          bzero((void *)tabe,width*sizeof(char *)+width*height*sizeof(char));
         width = can->width; height = can->height;          for( i=0, tabeb=(char *)(tabe+width); i<width; i++ )
         tabe = (double **)ALLOCA((width+1)*sizeof(double *));                  tabe[i]=tabeb + height*i;
         for ( i = 0; i < width; i++ )  
                 tabe[i] = (double *)ALLOCA((height+1)*sizeof(double));  
         define_cursor(can->window,runningcur);          define_cursor(can->window,runningcur);
         set_busy(can); set_selection();          set_busy(can); set_selection();
         calc(tabe,can,0); if_print(display,tabe,can);          qcalc(tabe,can); qif_print(display,tabe,can);
         reset_selection(); reset_busy(can);          reset_selection(); reset_busy(can);
         define_cursor(can->window,normalcur);          define_cursor(can->window,normalcur);
 #if defined(INTERVAL)  
         tstop(can);  
 #endif  
 }  }
   
 void qifplotmain(struct canvas *can)  //*******************ifplotNG
 {  int ifplotNG(NODE arg,char *func){
         int width,height;          int id,orgcolor,color,op_code;
         char **tabe,*tabeb;          NODE n;
         int i;          struct canvas *can;
           P formula;
           LIST xrange,yrange,zrange,wsize;
           STRING wname;
   
         width = can->width; height = can->height;          formula=(P)ARG0(arg);
         tabe = (char **)ALLOCA(width*sizeof(char *)+width*height*sizeof(char));          color=QTOS((Q)ARG1(arg));
         bzero((void *)tabe,width*sizeof(char *)+width*height*sizeof(char));          xrange=(LIST)ARG2(arg);
         for ( i = 0, tabeb = (char *)(tabe+width); i < width; i++ )          yrange=(LIST)ARG3(arg);
                 tabe[i] = tabeb + height*i;          zrange=(LIST)ARG4(arg);
           wsize=(LIST)ARG5(arg);
           wname=(STRING)ARG6(arg);
   
           can=canvas[id=search_canvas()];
           orgcolor=can->color;
           can->color=color;
           can->division=0;
           // set canvas data
           if(xrange){
                   n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
                   can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
                   can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
           }
           if(yrange){
                   n=BDY(yrange); can->vy=VR((P)BDY(n)); n=NEXT(n);
                   can->qymin=(Q)BDY(n); n=NEXT(n); can->qymax=(Q)BDY(n);
                   can->ymin=ToReal(can->qymin); can->ymax=ToReal(can->qymax);
           }
           if(zrange){
                   n=BDY(zrange); can->zmin=ToReal(BDY(n));
                   n=NEXT(n); can->zmax=ToReal(BDY(n));
                   n=NEXT(n); can->nzstep=QTOS((Q)BDY(n));
           }
           if(!wsize){
                   can->width=DEFAULTWIDTH;
                   can->height=DEFAULTHEIGHT;
           } else {
                   can->width=QTOS((Q)BDY(BDY(wsize)));
                   can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
           }
           if(wname) can->wname=BDY(wname);
           else can->wname="";
           can->formula=formula;
           set_drawcolor(color);
           if(!strcmp(func,"ifplot"))can->mode=MODE_IFPLOT;
           else if(!strcmp(func,"ifplotD"))can->mode=MODE_IFPLOTD;
           else if(!strcmp(func,"ifplotQ"))can->mode=MODE_IFPLOTQ;
           else if(!strcmp(func,"ifplotB"))can->mode=MODE_IFPLOTB;
           else if(!strcmp(func,"ineqnD"))can->mode=MODE_INEQND;
           else if(!strcmp(func,"ineqnQ"))can->mode=MODE_INEQNQ;
           else if(!strcmp(func,"ineqnB"))can->mode=MODE_INEQNB;
           else if(!strcmp(func,"conplotD"))can->mode=MODE_CONPLOTD;
           else if(!strcmp(func,"conplotQ"))can->mode=MODE_CONPLOTQ;
           else if(!strcmp(func,"conplotB"))can->mode=MODE_CONPLOTB;
           else if(!strcmp(func,"itvifplot")){
                   can->mode=MODE_ITVIFPLOT;
                   can->division=QTOS((Q)ARG7(arg));
           }
           else can->mode=MODE_IFPLOTD;
           create_canvas(can);
           ifplotmain(can);
           set_drawcolor(orgcolor);
           copy_to_canvas(can);
           can->color=orgcolor;
           return id;
   }
   
   int ifplotOP(NODE arg,char *func){
           //ineqnor[D,Q,B],ineqnand[D,Q,B],ineqnxor[D,Q,b]
           int index,orgcolor,color,op_code;
           NODE n;
           struct canvas *can;
           P formula;
           //s_id,fname,w_id,poly,color
           index=QTOS((Q)ARG0(arg));
           formula=(P)ARG1(arg);
           color=QTOS((Q)ARG2(arg));
           can=canvas[index];
           orgcolor=can->color;
           can->color=color;
           // set canvas data
           can->formula=formula;
           if(!strcmp(func,"ineqnandD"))can->mode=MODE_INEQNANDD;
           else if(!strcmp(func,"ineqnandQ"))can->mode=MODE_INEQNANDQ;
           else if(!strcmp(func,"ineqnandB"))can->mode=MODE_INEQNANDB;
           else if(!strcmp(func,"ineqnorD"))can->mode=MODE_INEQNORD;
           else if(!strcmp(func,"ineqnorQ"))can->mode=MODE_INEQNORQ;
           else if(!strcmp(func,"ineqnorB"))can->mode=MODE_INEQNORB;
           else if(!strcmp(func,"ineqnxorD"))can->mode=MODE_INEQNXORD;
           else if(!strcmp(func,"ineqnxorQ"))can->mode=MODE_INEQNXORQ;
           else if(!strcmp(func,"ineqnxorB"))can->mode=MODE_INEQNXORB;
           else if(!strcmp(func,"plotoverD"))can->mode=MODE_PLOTOVERD;
           else if(!strcmp(func,"plotoverQ"))can->mode=MODE_PLOTOVERQ;
           else if(!strcmp(func,"plotoverB"))can->mode=MODE_PLOTOVERB;
           else can->mode=MODE_IFPLOTD;
           set_drawcolor(color);
           ifplotmain(can);
           set_drawcolor(orgcolor);
           copy_to_canvas(can);
           can->color=orgcolor;
           return index;
   }
   
   void ifplotmain(struct canvas *can){
           int width,height,i,j,ix,iy,**mask;
           double **tabe;
   
           width=can->width; height=can->height;
           tabe=(double **)ALLOCA((width+1)*sizeof(double *));
           for(i=0;i<width;i++)tabe[i]=(double *)ALLOCA((height+1)*sizeof(double));
         define_cursor(can->window,runningcur);          define_cursor(can->window,runningcur);
         set_busy(can); set_selection();          set_busy(can); set_selection();
         qcalc(tabe,can); qif_print(display,tabe,can);          set_drawcolor(can->color);
           switch(can->mode){
           case MODE_IFPLOTD:
                   calc(tabe,can,0);
                   if_print(display,tabe,can,1);
                   break;
           case MODE_IFPLOTQ:
                   calcq(tabe,can,0);
                   if_print(display,tabe,can,1);
                   break;
           case MODE_IFPLOTB:
                   calcb(tabe,can,0);
                   if_print(display,tabe,can,0);
                   break;
           case MODE_INEQND:
                   calc(tabe,can,0);
                   area_print(display,tabe,can,0);
                   break;
           case MODE_INEQNQ:
                   calcq(tabe,can,0);
                   area_print(display,tabe,can,0);
                   break;
           case MODE_INEQNB:
                   calcb(tabe,can,0);
                   area_print(display,tabe,can,0);
                   break;
           case MODE_INEQNANDD:
                   calc(tabe,can,0);
                   area_print(display,tabe,can,0);
                   break;
           case MODE_INEQNANDQ:
                   calcq(tabe,can,0);
                   area_print(display,tabe,can,2);
                   break;
           case MODE_INEQNANDB:
                   calcb(tabe,can,0);
                   area_print(display,tabe,can,2);
                   break;
           case MODE_INEQNORD:
                   calc(tabe,can,0);
                   area_print(display,tabe,can,3);
                   break;
           case MODE_INEQNORQ:
                   calcq(tabe,can,0);
                   area_print(display,tabe,can,3);
                   break;
           case MODE_INEQNORB:
                   calcb(tabe,can,0);
                   area_print(display,tabe,can,3);
                   break;
           case MODE_INEQNXORD:
                   calc(tabe,can,0);
                   area_print(display,tabe,can,4);
                   break;
           case MODE_INEQNXORQ:
                   calcq(tabe,can,0);
                   area_print(display,tabe,can,4);
                   break;
           case MODE_INEQNXORB:
                   calcb(tabe,can,0);
                   area_print(display,tabe,can,4);
                   break;
           case MODE_CONPLOTD:
                   calc(tabe,can,0);
                   con_print(display,tabe,can);
                   break;
           case MODE_CONPLOTB:
                   calcb(tabe,can,0);
                   con_print(display,tabe,can);
                   break;
           case MODE_CONPLOTQ:
                   calcq(tabe,can,0);
                   con_print(display,tabe,can);
                   break;
           case MODE_PLOTOVERD:
                   calc(tabe,can,0);
                   over_print(display,tabe,can,0);
                   break;
           case MODE_PLOTOVERQ:
                   calcq(tabe,can,0);
                   over_print(display,tabe,can,0);
                   break;
           case MODE_PLOTOVERB:
                   calcb(tabe,can,0);
                   over_print(display,tabe,can,0);
                   break;
   #if defined(INTERVAL)
           case MODE_ITVIFPLOT:
                   itvcalc(tabe,can,1);
                   if_print(display,tabe,can,1);
                   break;
   #endif
           }
           set_drawcolor(can->color);
         reset_selection(); reset_busy(can);          reset_selection(); reset_busy(can);
         define_cursor(can->window,normalcur);          define_cursor(can->window,normalcur);
 }  }
   
 #if defined(INTERVAL)  int objcp(NODE arg){
 int objcp(NODE arg)  
 {  
         int idsrc, idtrg, op_code;          int idsrc, idtrg, op_code;
         struct canvas *cansrc, *cantrg;          struct canvas *cansrc, *cantrg;
   
         idsrc = QTOS((Q)ARG0(arg));          idsrc=QTOS((Q)ARG0(arg));
         idtrg = QTOS((Q)ARG1(arg));          idtrg=QTOS((Q)ARG1(arg));
         op_code = QTOS((Q)ARG2(arg));          op_code=QTOS((Q)ARG2(arg));
         cansrc = canvas[idsrc];          cansrc=canvas[idsrc];
         cantrg = canvas[idtrg];          cantrg=canvas[idtrg];
         obj_op(cansrc, cantrg, op_code);          obj_op(cansrc, cantrg, op_code);
         return idsrc;          return idsrc;
 }  }
   
 void obj_op(struct canvas *cansrc, struct canvas *cantrg, int op)  void obj_op(struct canvas *cansrc, struct canvas *cantrg, int op){
 {  
         XImage *imgsrc, *imgtrg;          XImage *imgsrc, *imgtrg;
         int width, height, i, j;          int width, height, i, j;
         unsigned long src, trg, black, white;          unsigned long src, trg, black, white;
   
         width = cansrc->width; height = cansrc->height;          width=cansrc->width; height=cansrc->height;
         imgsrc = XGetImage(display, cansrc->pix, 0, 0, width, height, -1, ZPixmap);          imgsrc=XGetImage(display, cansrc->pix, 0, 0, width, height, -1, ZPixmap);
         imgtrg = XGetImage(display, cantrg->pix, 0, 0, width, height, -1, ZPixmap);          imgtrg=XGetImage(display, cantrg->pix, 0, 0, width, height, -1, ZPixmap);
         black=GetColor(display, "black");          black=GetColor(display, "black");
         white=GetColor(display, "white");          white=GetColor(display, "white");
         flush();          flush();
         define_cursor(cantrg->window,runningcur);          define_cursor(cantrg->window,runningcur);
         set_busy(cantrg); set_selection();          set_busy(cantrg); set_selection();
         cantrg->precise = cansrc->precise;          cantrg->precise=cansrc->precise;
         cantrg->noaxis = cansrc->noaxis;          cantrg->noaxis=cansrc->noaxis;
         cantrg->noaxisb = cansrc->noaxisb;          cantrg->noaxisb=cansrc->noaxisb;
         cantrg->vx = cansrc->vx;          cantrg->vx=cansrc->vx;
         cantrg->vy = cansrc->vy;          cantrg->vy=cansrc->vy;
         cantrg->formula = cansrc->formula;          cantrg->formula=cansrc->formula;
         cantrg->width = cansrc->width;          cantrg->width=cansrc->width;
         cantrg->height = cansrc->height;          cantrg->height=cansrc->height;
         cantrg->xmin = cansrc->xmin;          cantrg->xmin=cansrc->xmin;
         cantrg->xmax = cansrc->xmax;          cantrg->xmax=cansrc->xmax;
         cantrg->ymin = cansrc->ymin;          cantrg->ymin=cansrc->ymin;
         cantrg->ymax = cansrc->ymax;          cantrg->ymax=cansrc->ymax;
         cantrg->zmin = cansrc->zmin;          cantrg->zmin=cansrc->zmin;
         cantrg->zmax = cansrc->zmax;          cantrg->zmax=cansrc->zmax;
         cantrg->nzstep = cansrc->nzstep;          cantrg->nzstep=cansrc->nzstep;
         cantrg->qxmin = cansrc->qxmin;          cantrg->qxmin=cansrc->qxmin;
         cantrg->qxmax = cansrc->qxmax;          cantrg->qxmax=cansrc->qxmax;
         cantrg->qymin = cansrc->qymin;          cantrg->qymin=cansrc->qymin;
         cantrg->qymax = cansrc->qymax;          cantrg->qymax=cansrc->qymax;
         cantrg->pa = cansrc->pa;          cantrg->pa=cansrc->pa;
         switch (op) {          switch(op){
                 case 1:/* and case */                  case 1:/* and case */
                         for(i=0;i<width;i++)for(j=0;j<height;j++){                          for(i=0;i<width;i++)for(j=0;j<height;j++){
                                 src = XGetPixel(imgsrc,i,j);                                  src=XGetPixel(imgsrc,i,j);
                                 trg = XGetPixel(imgtrg,i,j);                                  trg=XGetPixel(imgtrg,i,j);
                                 if ( (src == black) || (trg == black) )                                  if( (src == black) || (trg == black) )
                                         XPutPixel(imgtrg,i,j,black);                                          XPutPixel(imgtrg,i,j,black);
                                 else if ( (src == white) || (trg == white) )                                  else if( (src == white) || (trg == white) )
                                         XPutPixel(imgtrg,i,j,white);                                          XPutPixel(imgtrg,i,j,white);
                                 else XPutPixel(imgtrg,i,j,(src & trg));                                  else XPutPixel(imgtrg,i,j,(src & trg));
                         }                          }
                         break;                          break;
                 case 3:/* copy case */                  case 3:/* copy case */
                         imgtrg->data = imgsrc->data;                          imgtrg->data=imgsrc->data;
                         break;                          break;
                 case 6:/* xor case */                  case 6:/* xor case */
                         for(i=0;i<width;i++)for(j=0;j<height;j++){                          for(i=0;i<width;i++)for(j=0;j<height;j++){
                                 src = XGetPixel(imgsrc,i,j);                                  src=XGetPixel(imgsrc,i,j);
                                 trg = XGetPixel(imgtrg,i,j);                                  trg=XGetPixel(imgtrg,i,j);
                                 if ( (src == black) || (trg == black) )                                  if( (src == black) || (trg == black) )
                                         XPutPixel(imgtrg,i,j,black);                                          XPutPixel(imgtrg,i,j,black);
                                 else if ( (src == white) && (trg == white) )                                  else if( (src == white) && (trg == white) )
                                         XPutPixel(imgtrg,i,j,trg|src);                                          XPutPixel(imgtrg,i,j,trg|src);
                                 else if ( (src != white) && (trg != white) )                                  else if( (src != white) && (trg != white) )
                                         XPutPixel(imgtrg,i,j,white);                                          XPutPixel(imgtrg,i,j,white);
                                 else if ( src == white )                                  else if( src == white )
                                         XPutPixel(imgtrg,i,j,src);                                          XPutPixel(imgtrg,i,j,src);
                         }                          }
                         break;                          break;
                 case 7:/* or case */                  case 7:/* or case */
                         for(i=0;i<width;i++)for(j=0;j<height;j++){                          for(i=0;i<width;i++)for(j=0;j<height;j++){
                                 src = XGetPixel(imgsrc,i,j);                                  src=XGetPixel(imgsrc,i,j);
                                 trg = XGetPixel(imgtrg,i,j);                                  trg=XGetPixel(imgtrg,i,j);
                                 if ( (src == black) || (trg == black) )                                  if( (src == black) || (trg == black) )
                                         XPutPixel(imgtrg,i,j,black);                                          XPutPixel(imgtrg,i,j,black);
                                 else if (src == white)                                  else if(src == white)
                                         XPutPixel(imgtrg,i,j,trg);                                          XPutPixel(imgtrg,i,j,trg);
                                 else if (trg == white)                                  else if(trg == white)
                                         XPutPixel(imgtrg,i,j,src);                                          XPutPixel(imgtrg,i,j,src);
                         }                          }
                         break;                          break;
Line 782  void obj_op(struct canvas *cansrc, struct canvas *cant
Line 962  void obj_op(struct canvas *cansrc, struct canvas *cant
         flush();          flush();
 }  }
   
 int ineqn(NODE arg)  //ifplotNG
 {  /*
         int id, op_code, orgcolor;  
         struct canvas *can;  
         LIST xrange, yrange, geom;  
         NODE n;  
         STRING wname;  
         double **tbl;  
   
         can = canvas[id = search_canvas()];  
         orgcolor = can->color;  
         can->formula = (P)ARG0(arg);  
         can->color = QTOS((Q)ARG1(arg));  
         xrange = (LIST)ARG2(arg);  
         yrange = (LIST)ARG3(arg);  
         geom   = (LIST)ARG4(arg);  
         wname  = (STRING)ARG5(arg);  
         op_code = 3;  
         /* set canvas data */  
         can->mode = MODE_INEQNP;  
         can->width = QTOS((Q)BDY(BDY(geom)));  
         can->height = QTOS((Q)BDY(NEXT(BDY(geom))));  
         n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);  
         can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);  
         can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);  
         n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n);  
         can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n);  
         can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax);  
         can->mode = MODE_INEQNP;  
         if ( wname )  
                 can->wname = BDY(wname);  
         else  
                 can->wname = "";  
         create_canvas(can);  
         ineqnmain(can, orgcolor, op_code);  
         return id;  
 }  
   
 int ineqnover(NODE arg)  int ineqnover(NODE arg)
 {  {
         int id;    int id;
         struct canvas *can;    struct canvas *can;
         int orgcolor, op_code;    int orgcolor, op_code;
   
         id = QTOS((Q)ARG0(arg));    id = QTOS((Q)ARG0(arg));
         can = canvas[id];    can = canvas[id];
         orgcolor = can->color;    orgcolor = can->color;
         can->formula = (P)ARG1(arg);    can->formula = (P)ARG1(arg);
         can->color   = QTOS((Q)ARG2(arg));    can->color   = QTOS((Q)ARG2(arg));
         op_code      = QTOS((Q)ARG3(arg));    op_code      = QTOS((Q)ARG3(arg));
         can->mode    = MODE_INEQNP;    can->mode    = MODE_INEQNP;
         ineqnmain(can, orgcolor, op_code);    ineqnmain(can, orgcolor, op_code);
         return id;    return id;
 }  }
   
 void ineqnmain(struct canvas *can, int orgcolor, int op_code)  void ineqnmain(struct canvas *can, int orgcolor, int op_code)
 {  {
         int **mask;    int **mask;
         double **tbl;    double **tbl;
         int i,j;    int i,j;
   
         current_can = can;    current_can = can;
         tbl = (double **)ALLOCA((can->height+1)*sizeof(double *));    tbl = (double **)ALLOCA((can->height+1)*sizeof(double *));
         for ( i = 0; i <= can->height; i++ )    for ( i = 0; i <= can->height; i++ )
                 tbl[i] = (double *)ALLOCA((can->width+1)*sizeof(double));      tbl[i] = (double *)ALLOCA((can->width+1)*sizeof(double));
         mask = (int **)ALLOCA(can->height*sizeof(int *));    mask = (int **)ALLOCA(can->height*sizeof(int *));
         for ( i = 0; i < can->height; i++)    for ( i = 0; i < can->height; i++)
                 mask[i] = (int *)ALLOCA(can->width*sizeof(int));      mask[i] = (int *)ALLOCA(can->width*sizeof(int));
   
         define_cursor(can->window,runningcur);    define_cursor(can->window,runningcur);
         set_busy(can); set_selection();    set_busy(can); set_selection();
         ineqncalc(tbl, can, 1);  //  ineqncalc(tbl, can, 1);
         for (j = 0; j < can->height; j++){    calc(tab,can,1);
                 for (i = 0; i < can->width; i++){    for (j = 0; j < can->height; j++){
                         if ( tbl[j][i] >= 0 ){      for (i = 0; i < can->width; i++){
                                 if ( (tbl[j+1][i] <= 0 ) ||        if ( tbl[j][i] >= 0 ){
                                         (tbl[j][i+1] <= 0) ||          if ( (tbl[j+1][i] <= 0 ) ||
                                         (tbl[j+1][i+1] <= 0) ) mask[j][i] = 0;            (tbl[j][i+1] <= 0) ||
                                 else mask[j][i] = 1;            (tbl[j+1][i+1] <= 0) ) mask[j][i] = 0;
                         } else {          else mask[j][i] = 1;
                                 if( (tbl[j+1][i] >= 0) ||        } else {
                                         (tbl[j][i+1] >= 0) ||          if( (tbl[j+1][i] >= 0) ||
                                         (tbl[j+1][i+1] >= 0) ) mask[j][i] = 0;            (tbl[j][i+1] >= 0) ||
                                 else mask[j][i] = -1;            (tbl[j+1][i+1] >= 0) ) mask[j][i] = 0;
                         }          else mask[j][i] = -1;
                 }        }
         }      }
         area_print(display, mask, can, op_code);    }
         reset_selection();    area_print(display, mask, can, op_code);
         reset_busy(can);    reset_selection();
         define_cursor(can->window,normalcur);    reset_busy(can);
     define_cursor(can->window,normalcur);
 #if !defined(VISUAL)  #if !defined(VISUAL)
         set_drawcolor(orgcolor);    set_drawcolor(orgcolor);
         can->color = orgcolor;    can->color = orgcolor;
 #endif  #endif
         copy_to_canvas(can);    copy_to_canvas(can);
 }  }
   */
 int itvifplot(NODE arg)  int polarplotNG(NODE arg){
 {          int id,color,orgcolor;
         int id, op_code, orgcolor;  
         struct canvas *can;  
         LIST xrange, yrange, zrange, geom;  
         NODE n;          NODE n;
         STRING wname;  
         double **tbl;  
         int itvsize;  
   
         can = canvas[id = search_canvas()];  
         orgcolor = can->color;  
         can->formula = (P)ARG0(arg);  
         xrange = (LIST)ARG1(arg);  
         yrange = (LIST)ARG2(arg);  
         zrange = (LIST)ARG3(arg);  
         geom   = (LIST)ARG4(arg);  
         wname  = (STRING)ARG5(arg);  
         itvsize = QTOS((Q)ARG6(arg));  
         /* set canvas data */  
         can->mode = MODE_INEQNP;  
         can->width = QTOS((Q)BDY(BDY(geom)));  
         can->height = QTOS((Q)BDY(NEXT(BDY(geom))));  
         n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);  
         can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);  
         can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);  
         n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n);  
         can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n);  
         can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax);  
         can->mode = MODE_INEQNP;  
         if ( wname )  
                 can->wname = BDY(wname);  
         else  
                 can->wname = "";  
         create_canvas(can);  
         itvplotmain(can, itvsize);  
 #if !defined(VISUAL)  
         set_drawcolor(orgcolor);  
         can->color = orgcolor;  
 #endif  
         copy_to_canvas(can);  
         return id;  
 }  
   
 void itvplotmain(struct canvas *can, int itvsize)  
 {  
         int **mask;  
         double **tbl;  
         int i,j;  
         int op_code;  
         pointer *prp;  
   
         tstart(); /* time calc */  
         op_code=3;  
         current_can = can;  
         can->color=0xff00;  
         mask = (int **)ALLOCA(can->height*sizeof(int *));  
         for ( i = 0; i < can->height; i++){  
                 mask[i] = (int *)ALLOCA(can->width*sizeof(int));  
                 for (j = 0; j< can->width; j++) mask[i][j] = -1;  
         }  
         define_cursor(can->window,runningcur);  
         set_busy(can); set_selection();  
         itvcalc(mask, can, 1, itvsize);  
         area_print(display, mask, can, op_code);  
         reset_selection();  
         reset_busy(can);  
         define_cursor(can->window,normalcur);  
         tstop(can); /* time calc */  
 }  
   
 // NORMAL type  
 int itvplot1(NODE arg)  
 {  
         int id, op_code, orgcolor;  
         struct canvas *can;          struct canvas *can;
         LIST xrange, yrange, zrange, geom;          P formula;
         NODE n;          LIST xrange,wsize;
         STRING wname;          STRING wname;
         double **tbl;          V v;
   
         can = canvas[id = search_canvas()];          formula=(P)ARG0(arg);
         orgcolor = can->color;          xrange=(LIST)ARG1(arg);
         can->formula = (P)ARG0(arg);          color=QTOS((Q)ARG2(arg));
         xrange = (LIST)ARG1(arg);          wsize=(LIST)ARG3(arg);
         yrange = (LIST)ARG2(arg);          wname=(STRING)ARG4(arg);
         zrange = (LIST)ARG3(arg);  
         geom   = (LIST)ARG4(arg);  
         wname  = (STRING)ARG5(arg);  
         /* set canvas data */  
         can->mode = MODE_INEQNP;  
         can->width = QTOS((Q)BDY(BDY(geom)));  
         can->height = QTOS((Q)BDY(NEXT(BDY(geom))));  
         n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);  
         can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);  
         can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);  
         n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n);  
         can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n);  
         can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax);  
         can->mode = MODE_INEQNP;  
         if ( wname )  
                 can->wname = BDY(wname);  
         else  
                 can->wname = "";  
         create_canvas(can);  
         itvplotmain1(can);  
 #if !defined(VISUAL)  
         set_drawcolor(orgcolor);  
         can->color = orgcolor;  
 #endif  
         copy_to_canvas(can);  
         return id;  
 }  
   
 void itvplotmain1(struct canvas *can)          can=canvas[id=search_canvas()];
 {          if(xrange){
         int **mask;                  n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
         double **tbl;                  can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
         int i,j;                  can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
         int op_code;  
   
         op_code=3;  
         current_can = can;  
         mask = (int **)ALLOCA(can->height*sizeof(int *));  
         for ( i = 0; i < can->height; i++){  
                 mask[i] = (int *)ALLOCA(can->width*sizeof(int));  
                 for (j = 0; j< can->width; j++) mask[i][j] = -1;  
         }          }
           can->mode=MODE_POLARPLOT;
         define_cursor(can->window,runningcur);          if(!wsize){
         set_busy(can); set_selection();                  can->width=DEFAULTWIDTH;
         itvcalc1(mask, can, 1);                  can->height=DEFAULTHEIGHT;
         area_print(display, mask, can, op_code);          } else {
         reset_selection();                  can->width=QTOS((Q)BDY(BDY(wsize)));
         reset_busy(can);                  can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
         define_cursor(can->window,normalcur);          }
 }          if(wname)can->wname=BDY(wname);
           else can->wname="";
 // TRANSFER type          can->formula=formula;
 int itvplot2(NODE arg)          orgcolor=can->color;
 {          can->color=color;
         int id, op_code, orgcolor;          polarplotcalc(can);
         struct canvas *can;  
         LIST xrange, yrange, zrange, geom;  
         NODE n;  
         STRING wname;  
         double **tbl;  
   
         can = canvas[id = search_canvas()];  
         orgcolor = can->color;  
         can->formula = (P)ARG0(arg);  
         xrange = (LIST)ARG1(arg);  
         yrange = (LIST)ARG2(arg);  
         zrange = (LIST)ARG3(arg);  
         geom   = (LIST)ARG4(arg);  
         wname  = (STRING)ARG5(arg);  
         /* set canvas data */  
         can->mode = MODE_INEQNP;  
         can->width = QTOS((Q)BDY(BDY(geom)));  
         can->height = QTOS((Q)BDY(NEXT(BDY(geom))));  
         n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);  
         can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);  
         can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);  
         n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n);  
         can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n);  
         can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax);  
         can->mode = MODE_INEQNP;  
         if ( wname )  
                 can->wname = BDY(wname);  
         else  
                 can->wname = "";  
         create_canvas(can);          create_canvas(can);
         itvplotmain2(can);          plot_print(display,can);
 #if !defined(VISUAL)          can->color=orgcolor;
         set_drawcolor(orgcolor);  
         can->color = orgcolor;  
 #endif  
         copy_to_canvas(can);          copy_to_canvas(can);
         return id;          return id;
 }  }
   
 void itvplotmain2(struct canvas *can)  int plotoverD(NODE arg){
 {          int index, color;
         int **mask;          P formula;
         double **tbl;  
         int i,j;  
         int op_code;  
   
         op_code=3;  
         current_can = can;  
   
         mask = (int **)ALLOCA(can->height*sizeof(int *));  
         for ( i = 0; i < can->height; i++){  
                 mask[i] = (int *)ALLOCA(can->width*sizeof(int));  
                 for (j = 0; j< can->width; j++) mask[i][j] = -1;  
         }  
   
         define_cursor(can->window,runningcur);  
         set_busy(can); set_selection();  
         itvcalc2(mask, can, 1);  
         area_print(display, mask, can, op_code);  
         reset_selection();  
         reset_busy(can);  
         define_cursor(can->window,normalcur);  
 }  
   
 // RECURSION type  
 int itvplot3(NODE arg)  
 {  
         int id, op_code, orgcolor;  
         struct canvas *can;          struct canvas *can;
         LIST xrange, yrange, zrange, geom;          VL vl,vl0;
         NODE n;  
         STRING wname;  
         double **tbl;  
         int itvsize;  
   
         can = canvas[id = search_canvas()];          index=QTOS((Q)ARG0(arg));
         orgcolor = can->color;          formula=(P)ARG1(arg);
         can->formula = (P)ARG0(arg);          can=canvas[index];
         xrange = (LIST)ARG1(arg);          color=can->color;
         yrange = (LIST)ARG2(arg);          if(!can->window)return -1;
         zrange = (LIST)ARG3(arg);          get_vars_recursive((Obj)formula,&vl);
         geom   = (LIST)ARG4(arg);          for(vl0=vl;vl0;vl0=NEXT(vl0))
         wname  = (STRING)ARG5(arg);                  if(vl0->v->attr==(pointer)V_IND)
         itvsize = QTOS((Q)ARG6(arg));                          if(vl->v!=can->vx && vl->v!=can->vy) return -1;
         /* set canvas data */          if(argc(arg)== 3)can->color=QTOS((Q)ARG2(arg));
         can->mode = MODE_INEQNP;          else can->color=0;
         can->width = QTOS((Q)BDY(BDY(geom)));  
         can->height = QTOS((Q)BDY(NEXT(BDY(geom))));  
         n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);  
         can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);  
         can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);  
         n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n);  
         can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n);  
         can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax);  
         can->mode = MODE_INEQNP;  
         if ( wname )  
                 can->wname = BDY(wname);  
         else  
                 can->wname = "";  
         create_canvas(can);  
         itvplotmain3(can, itvsize);  
 #if !defined(VISUAL)  #if !defined(VISUAL)
         set_drawcolor(orgcolor);          set_drawcolor(can->color);
         can->color = orgcolor;  
 #endif  #endif
           current_can=can;
           can->formula=formula;
           if(can->mode==MODE_PLOT){
                   calcq(can);
                   plot_print(display,can);
           } else ifplotmain(can);
         copy_to_canvas(can);          copy_to_canvas(can);
         return id;          can->color=color;
 }  
   
 void itvplotmain3(struct canvas *can, int itvsize)  
 {  
         int **mask;  
         double **tbl;  
         int i,j;  
         int op_code;  
   
         op_code=3;  
         current_can = can;  
   
         mask = (int **)ALLOCA(can->height*sizeof(int *));  
         for ( i = 0; i < can->height; i++)  
                 mask[i] = (int *)ALLOCA(can->width*sizeof(int));  
   
         define_cursor(can->window,runningcur);  
         set_busy(can); set_selection();  
         itvcalc3(mask, can, 1, itvsize);  
         area_print(display, mask, can, op_code);  
         reset_selection();  
         reset_busy(can);  
         define_cursor(can->window,normalcur);  
 }  
   
 // RECURSION and TRANSFER type  
 int itvplot4(NODE arg)  
 {  
         int id, op_code, orgcolor;  
         struct canvas *can;  
         LIST xrange, yrange, zrange, geom;  
         NODE n;  
         STRING wname;  
         double **tbl;  
         int itvsize;  
   
         can = canvas[id = search_canvas()];  
         orgcolor = can->color;  
         can->formula = (P)ARG0(arg);  
         xrange = (LIST)ARG1(arg);  
         yrange = (LIST)ARG2(arg);  
         zrange = (LIST)ARG3(arg);  
         geom   = (LIST)ARG4(arg);  
         wname  = (STRING)ARG5(arg);  
         itvsize = QTOS((Q)ARG6(arg));  
         /* set canvas data */  
         can->mode = MODE_INEQNP;  
         can->width = QTOS((Q)BDY(BDY(geom)));  
         can->height = QTOS((Q)BDY(NEXT(BDY(geom))));  
         n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);  
         can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);  
         can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);  
         n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n);  
         can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n);  
         can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax);  
         can->mode = MODE_INEQNP;  
         if ( wname )  
                 can->wname = BDY(wname);  
         else  
                 can->wname = "";  
         create_canvas(can);  
         itvplotmain4(can, itvsize);  
 #if !defined(VISUAL)  #if !defined(VISUAL)
         set_drawcolor(orgcolor);          set_drawcolor(can->color);
         can->color = orgcolor;  
 #endif  #endif
         copy_to_canvas(can);          return index;
         return id;  
 }  }
   
 void itvplotmain4(struct canvas *can, int itvsize)  
 {  
         int **mask;  
         double **tbl;  
         int i,j;  
         int op_code;  
   
         tstart();/* time calc */  
         op_code=3;  
         current_can = can;  
   
         mask = (int **)ALLOCA(can->height*sizeof(int *));  
         for ( i = 0; i < can->height; i++){  
                 mask[i] = (int *)ALLOCA(can->width*sizeof(int));  
                 for (j = 0; j< can->width; j++) mask[i][j] = -1;  
         }  
   
         define_cursor(can->window,runningcur);  
         set_busy(can); set_selection();  
         itvcalc4(mask, can, 1, itvsize);  
         area_print(display, mask, can, op_code);  
         reset_selection();  
         reset_busy(can);  
         define_cursor(can->window,normalcur);  
         tstop(can); /* time calc */  
 }  
 #endif  
Legend:
Removed from v.1.23  
changed lines
  Added in v.1.24
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>