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

Diff for /OpenXM_contrib2/asir2000/plot/ox_plot_xevent.c between version 1.4 and 1.35

version 1.4, 2000/10/14 07:43:52 version 1.35, 2018/03/29 01:32:55
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/ox_plot_xevent.c,v 1.3 2000/08/22 05:04:31 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/plot/ox_plot_xevent.c,v 1.34 2015/08/14 13:51:56 fujimoto Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
 #include "ox.h"  #include "ox.h"
 #include "ifplot.h"  #include "ifplot.h"
 #include "cursor.h"  #include "cursor.h"
   #include <X11/Xaw/MenuButton.h>
   #include <X11/Xaw/Paned.h>
   
   static void Quit();
   static void print_canvas(Widget w, struct canvas *can, XtPointer calldata);
   static void output_to_printer(Widget w, struct canvas *can, XtPointer calldata);
   static void print_canvas_to_file(Widget w, struct canvas *can, XtPointer calldata);
   static void printing_method(Widget w, struct canvas *can, XtPointer calldata);
   void clear_pixmap(struct canvas *);
   void create_gc();
   void create_font();
   void create_cursors();
   void copy_to_canvas(struct canvas *can);
   void draw_level(struct canvas *can,int index,GC gc);
   void draw_frame(Window window,POINT spos,POINT opos,POINT epos);
   void draw_frame0( Window window,POINT spos,POINT epos);
   void draw_coord(struct canvas *can,POINT pos);
   void draw_wideframe(struct canvas *can);
   void redraw_canvas(struct canvas *can);
   void reset_busy(struct canvas *can);
   int search_canvas();
   int search_active_canvas();
   void PSFromImage(FILE *fp,XImage *image,struct canvas *can);
   
   
   
   static Atom wm_delete_window;
   
   void SetWM_Proto(Widget w)
   {
     XtOverrideTranslations(w,
       XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));
     XSetWMProtocols(display,XtWindow(w),&wm_delete_window,1);
   }
   
   #if 0
   static void quit(Widget w, XEvent *ev, String *params,Cardinal *nparams)
   {
       XBell(display,0);
   }
   #endif
   
   /* XXX : these lines are in plotg.c, but ld says they are not defined */
   #if __DARWIN__
   int stream;
   
   DISPLAY *display;
   CURSOR normalcur,runningcur,errorcur;
   
   #if defined(VISUAL) || defined(__MINGW32__)
   POINT start_point, end_point;
   SIZE cansize;
   #else
   Window rootwin;
   GC drawGC,dashGC,hlGC,scaleGC,clearGC,xorGC,colorGC,cdrawGC;
   XFontStruct *sffs;
   #endif
   
   struct canvas *canvas[MAXCANVAS];
   struct canvas *closed_canvas[MAXCANVAS];
   struct canvas *current_can;
   #endif /* __DARWIN__ */
   
 #ifdef ABS  #ifdef ABS
 #undef ABS  #undef ABS
 #define ABS(a) ((a)>0?(a):-(a))  #define ABS(a) ((a)>0?(a):-(a))
 #endif  #endif
   
 static char *dname;  static char *dname;
 static int remotes;  
 static int depth,scrn;  static int depth,scrn;
   
 extern jmp_buf ox_env;  extern JMP_BUF ox_env;
 static Widget toplevel;  static Widget toplevel;
 static XtAppContext app_con;  static XtAppContext app_con;
   
 static int busy;  static int busy;
   
 static struct PlotResources {  static struct PlotResources {
         Pixel ForePixel,BackPixel,DashPixel;    Pixel ForePixel,BackPixel,DashPixel;
         char *ForeName,*BackName,*DashName;    char *ForeName,*BackName,*DashName;
         Boolean Reverse;    Boolean Reverse;
     Boolean UpsideDown;
 } PlotResources;  } PlotResources;
   
 #define forePixel PlotResources.ForePixel  #define forePixel PlotResources.ForePixel
Line 81  static struct PlotResources {
Line 143  static struct PlotResources {
 #define backName PlotResources.BackName  #define backName PlotResources.BackName
 #define dashName PlotResources.DashName  #define dashName PlotResources.DashName
 #define reverse PlotResources.Reverse  #define reverse PlotResources.Reverse
   #define upsidedown PlotResources.UpsideDown
   
   Pixel BackPixel;
   
 Cursor create_cursor();  Cursor create_cursor();
   
 #define blackPixel      BlackPixel(display,scrn)  #define blackPixel  BlackPixel(display,scrn)
 #define whitePixel      WhitePixel(display,scrn)  #define whitePixel  WhitePixel(display,scrn)
   
 #define LABELWIDTH 150  #define LABELWIDTH 150
   
 process_xevent() {  void process_xevent() {
         XEvent ev;    XEvent ev;
   
         while ( XPending(display) ) {    while ( XPending(display) ) {
                 XtAppNextEvent(app_con,&ev);      XtAppNextEvent(app_con,&ev);
                 XtDispatchEvent(&ev);      XtDispatchEvent(&ev);
         }    }
 }  }
   
 /* event handlers */  /* event handlers */
   
 static POINT spos,cpos;  static POINT spos,cpos;
   
 void press(w,can,ev)  void press(Widget w,struct canvas *can,XButtonEvent *ev)
 Widget w;  
 struct canvas *can;  
 XButtonEvent *ev;  
 {  {
         POINT p;    POINT p;
   
         switch ( ev->button ) {    switch ( ev->button ) {
                 case Button1:      case Button1:
                         XC(spos) = ev->x; YC(spos) = ev->y; cpos = spos; break;        XC(spos) = ev->x; YC(spos) = ev->y; cpos = spos; break;
                 case Button3:      case Button3:
                         XC(p) = ev->x; YC(p) = ev->y; draw_coord(can,&p); break;        XC(p) = ev->x; YC(p) = ev->y; draw_coord(can,p); break;
                 default:      default:
                         break;        break;
         }    }
 }  }
   
 void motion(w,can,ev)  void motion(Widget w,struct canvas *can,XMotionEvent *ev)
 Widget w;  
 struct canvas *can;  
 XMotionEvent *ev;  
 {  {
   
         POINT o,p;    POINT o,p;
   
         if ( ev->state & Button1Mask ) {    if ( ev->state & Button1Mask ) {
                 o = cpos; XC(cpos) = ev->x; YC(cpos) = ev->y;      o = cpos; XC(cpos) = ev->x; YC(cpos) = ev->y;
                 draw_frame(can->window,spos,o,cpos);      draw_frame(can->window,spos,o,cpos);
         } else if ( ev->state & Button3Mask ) {    } else if ( ev->state & Button3Mask ) {
                 XC(p) = ev->x; YC(p) = ev->y;      XC(p) = ev->x; YC(p) = ev->y;
                 draw_coord(can,p);      draw_coord(can,p);
         }    }
 }  }
   
 void release(w,can,ev)  void release(Widget w,struct canvas *can,XButtonEvent *ev)
 Widget w;  
 struct canvas *can;  
 XButtonEvent *ev;  
 {  {
         POINT e;    POINT e;
     switch ( ev->button ) {
         switch ( ev->button ) {      case Button1:
                 case Button1:        e.x = ev->x; e.y = ev->y;
                         e.x = ev->x; e.y = ev->y;        draw_frame0(can->window,spos,e);
                         draw_frame0(can->window,spos,e);        if(!busy
                         if ( !busy ) {        && can->mode != modeNO(INTERACTIVE)
                                 if ( can->mode == MODE_PLOT )        && can->mode != modeNO(POLARPLOT)) plot_resize(can,spos,e);
                                         plot_resize(can,spos,e);        break;
                                 else      default:
                                         ifplot_resize(can,spos,e);        break;
                         }    }
                         break;  
                 default:  
                         break;  
         }  
 }  }
   
 void structure(w,can,ev)  void structure(Widget w,struct canvas *can,XEvent *ev)
 Widget w;  
 struct canvas *can;  
 XEvent *ev;  
 {  {
         switch ( ev->xany.type ) {    switch ( ev->xany.type ) {
                 case Expose:      case Expose:
                                 if ( !ev->xexpose.count )          if ( !ev->xexpose.count )
                                         redraw_canvas(can);            redraw_canvas(can);
                         break;        break;
                 case ConfigureNotify:      case ConfigureNotify:
                         redraw_canvas(can); break;        redraw_canvas(can); break;
                 default:      default:
                         break;        break;
         }    }
 }  }
   
 static int lindex;  static int lindex;
   
 void lpress(w,can,ev)  void lpress(Widget w,struct canvas *can,XButtonEvent *ev)
 Widget w;  
 struct canvas *can;  
 XButtonEvent *ev;  
 {  {
         lindex = (can->height-ev->y)/(can->height/can->nzstep);    lindex = (can->height-ev->y)/(can->height/can->nzstep);
         draw_level(can,lindex,hlGC);    draw_level(can,lindex,hlGC);
 }  }
   
 void jumpproc(w,can,percent)  void jumpproc(Widget w,struct canvas *can,float *percent)
 Widget w;  
 struct canvas *can;  
 float *percent;  
 {  {
         int index;    int index;
   
         index = can->nzstep * (1.0-*percent);    index = can->nzstep * (1.0-*percent);
         if ( index == lindex )    if ( index == lindex )
                 return;      return;
         if ( lindex >= 0 )    if ( lindex >= 0 )
                 draw_level(can,lindex,drawGC);      draw_level(can,lindex,drawGC);
         lindex = index;    lindex = index;
         draw_level(can,lindex,hlGC);    draw_level(can,lindex,hlGC);
 }  }
   
 void jumpproc_m(w,can,percent)  void jumpproc_m(Widget w,struct canvas *can,float *percent)
 Widget w;  
 struct canvas *can;  
 float *percent;  
 {  {
         int index;    int index;
   
         index = can->nzstep * (1.0-*percent);    index = can->nzstep * (1.0-*percent);
         if ( index != lindex ) {    if ( index != lindex ) {
                 draw_level(can,lindex,drawGC);      draw_level(can,lindex,drawGC);
                 draw_level(can,lindex,hlGC);      draw_level(can,lindex,hlGC);
         }    }
 }  }
   
 void lrelease(w,can,ev)  void lrelease(Widget w,struct canvas *can,XButtonEvent *ev)
 Widget w;  
 struct canvas *can;  
 XButtonEvent *ev;  
 {  {
         draw_level(can,lindex,drawGC); lindex = -1;    draw_level(can,lindex,drawGC); lindex = -1;
 }  }
   
 void lrelease_m(w,can,ev)  void lrelease_m(Widget w,struct canvas *can,XButtonEvent *ev)
 Widget w;  
 struct canvas *can;  
 XButtonEvent *ev;  
 {  {
         lindex = -1;    lindex = -1;
 }  }
   
 draw_level(can,index,gc)  void draw_level(struct canvas *can,int index,GC gc)
 struct canvas *can;  
 int index;  
 GC gc;  
 {  {
         Pixmap pix;    Pixmap pix;
         struct pa *pa;    struct pa *pa;
         int i,len;    int i,len;
         POINT *p;    POINT *p;
         Arg arg[2];    Arg arg[2];
         char buf[BUFSIZ];    char buf[BUFSIZ];
   
         if ( busy || can->wide || index < 0 || index > can->nzstep )    if ( busy || can->wide || index < 0 || index > can->nzstep )
                 return;      return;
         pix = can->pix; pa = &can->pa[index]; len = pa->length; p = pa->pos;    pix = can->pix; pa = &can->pa[index]; len = pa->length; p = pa->pos;
         for ( i = 0; i < len; i++ )    for ( i = 0; i < len; i++ )
                 XDrawPoint(display,pix,gc,p[i].x,p[i].y);      XDrawPoint(display,pix,gc,p[i].x,p[i].y);
         sprintf(buf,"level:%g",can->zmin+(can->zmax-can->zmin)*index/can->nzstep);    sprintf(buf,"level:%g",can->zmin+(can->zmax-can->zmin)*index/can->nzstep);
         XtSetArg(arg[0],XtNlabel,buf); XtSetArg(arg[1],XtNwidth,LABELWIDTH);    XtSetArg(arg[0],XtNlabel,buf); XtSetArg(arg[1],XtNwidth,LABELWIDTH);
         XtSetValues(can->level,arg,2);    XtSetValues(can->level,arg,2);
         copy_to_canvas(can);    copy_to_canvas(can);
 }  }
   
 draw_frame(window,spos,opos,epos)  void draw_frame(Window window,POINT spos,POINT opos,POINT epos)
 Window window;  
 POINT spos,opos,epos;  
 {  {
         if ( XC(opos) != XC(epos) || YC(opos) != YC(epos) )    if ( XC(opos) != XC(epos) || YC(opos) != YC(epos) )
                 draw_frame0(window,spos,opos);      draw_frame0(window,spos,opos);
         draw_frame0(window,spos,epos);    draw_frame0(window,spos,epos);
 }  }
   
 draw_frame0(window,spos,epos)  void draw_frame0(Window window,POINT spos,POINT epos)
 Window window;  
 POINT spos,epos;  
 {  {
         int ulx,uly,w,h;    int ulx,uly,w,h;
   
         ulx = MIN(XC(spos),XC(epos)); uly = MIN(YC(spos),YC(epos));    ulx = MIN(XC(spos),XC(epos)); uly = MIN(YC(spos),YC(epos));
         w = ABS(XC(spos)-XC(epos)); h = ABS(YC(spos)-YC(epos));    w = ABS(XC(spos)-XC(epos)); h = ABS(YC(spos)-YC(epos));
         if ( !w || !h )    if ( !w || !h )
                 return;      return;
         XDrawRectangle(display,window,xorGC,ulx,uly,w,h);    XDrawRectangle(display,window,xorGC,ulx,uly,w,h);
         XFlush(display);    XFlush(display);
 }  }
   
 draw_coord(can,pos)  void draw_coord(struct canvas *can,POINT pos)
 struct canvas *can;  
 POINT pos;  
 {  {
         char buf[BUFSIZ];    char buf[BUFSIZ];
         Arg arg[2];    Arg arg[2];
         double x,y,xmin,ymax,dx,dy;    double x,y,xmin,ymax,dx,dy;
   
         if ( can->wide ) {    if ( can->wide ) {
                 dx = 10*(can->xmax-can->xmin); dy = 10*(can->ymax-can->ymin);      dx = 10*(can->xmax-can->xmin); dy = 10*(can->ymax-can->ymin);
                 xmin = (can->xmax+can->xmin-dx)/2;      xmin = (can->xmax+can->xmin-dx)/2;
                 ymax = (can->ymax+can->ymin+dy)/2;      ymax = (can->ymax+can->ymin+dy)/2;
         } else {    } else {
                 dx = can->xmax-can->xmin; dy = can->ymax-can->ymin;      dx = can->xmax-can->xmin; dy = can->ymax-can->ymin;
                 xmin = can->xmin; ymax = can->ymax;      xmin = can->xmin; ymax = can->ymax;
         }    }
         x = xmin+XC(pos)*dx/can->width;    x = xmin+XC(pos)*dx/can->width;
         y = ymax-YC(pos)*dy/can->height;    y = ymax-YC(pos)*dy/can->height;
         sprintf(buf,"%s:%g",can->vx?can->vx->name:"horiz",x);    sprintf(buf,"%s:%g",can->vx?can->vx->name:"horiz",x);
         XtSetArg(arg[0],XtNlabel,buf); XtSetArg(arg[1],XtNwidth,LABELWIDTH);    XtSetArg(arg[0],XtNlabel,buf); XtSetArg(arg[1],XtNwidth,LABELWIDTH);
         XtSetValues(can->xcoord,arg,2);    XtSetValues(can->xcoord,arg,2);
         sprintf(buf,"%s:%g",can->vy?can->vy->name:"vert",y);    sprintf(buf,"%s:%g",can->vy?can->vy->name:"vert",y);
         XtSetArg(arg[0],XtNlabel,buf); XtSetArg(arg[1],XtNwidth,LABELWIDTH);    XtSetArg(arg[0],XtNlabel,buf); XtSetArg(arg[1],XtNwidth,LABELWIDTH);
         XtSetValues(can->ycoord,arg,2);    XtSetValues(can->ycoord,arg,2);
 }  }
   
 redraw_canvas(can)  void redraw_canvas(struct canvas *can)
 struct canvas *can;  
 {  {
         if ( can->wide )    if ( can->wide )
                 draw_wideframe(can);      draw_wideframe(can);
         else    else
                 copy_to_canvas(can);      copy_to_canvas(can);
 }  }
   
 search_canvas()  int search_canvas()
 {  {
         int i;    int i;
   
         for ( i = 0; i < MAXCANVAS; i++ )    for ( i = 0; i < MAXCANVAS; i++ )
                 if ( !canvas[i] ) {      if ( !canvas[i] ) {
                         canvas[i] = (struct canvas *)MALLOC(sizeof(struct canvas));        canvas[i] = (struct canvas *)MALLOC(sizeof(struct canvas));
                         canvas[i]->index = i; return i;        canvas[i]->index = i; return i;
                 }      }
     return -1;
 }  }
   
 search_active_canvas()  int search_active_canvas()
 {  {
         int i;    int i;
   
         for ( i = 0; i < MAXCANVAS; i++ )    for ( i = 0; i < MAXCANVAS; i++ )
                 if ( canvas[i] )      if ( canvas[i] )
                         return i;        return i;
         return -1;    return -1;
 }  }
   
   void popup_canvas(int index)
 #define PRINT_XOFFSET   100  {
 #define PRINT_YOFFSET   100    clear_pixmap(canvas[index]);
     XtPopup(canvas[index]->shell,XtGrabNone);
     copy_to_canvas(canvas[index]);
   }
   
   void destroy_canvas(Widget w,struct canvas *can,XtPointer calldata)
   {
     XtPopdown(can->shell);
   /*  XtDestroyWidget(can->shell); */
     XFlush(display);
     if ( can == current_can ) {
       reset_busy(can); current_can = 0;
     }
     if ( closed_canvas[can->index] )
       XtDestroyWidget(closed_canvas[can->index]->shell);
     closed_canvas[can->index] = can;
     canvas[can->index] = 0;
   }
   
   void precise_canvas(Widget w,struct canvas *can,XtPointer calldata)
   {
     if ( can->precise )
       can->precise = 0;
     else
       can->precise = 1;
   }
   
   void wide_canvas(Widget w,struct canvas *can,XtPointer calldata)
   {
     if ( can->wide ) {
       can->wide = 0; copy_to_canvas(can);
     } else {
       can->wide = 1; draw_wideframe(can);
     }
   }
   
   void noaxis_canvas(Widget w,struct canvas *can,XtPointer calldata)
   {
     if ( can->noaxis )
       can->noaxis = 0;
     else
       can->noaxis = 1;
     if ( can->wide )
       draw_wideframe(can);
     else
       copy_to_canvas(can);
   }
   
   void toggle_button(Widget w,int flag)
   {
     Arg arg[2];
   
     if ( flag ) {
       XtSetArg(arg[0],XtNforeground,backPixel);
       XtSetArg(arg[1],XtNbackground,forePixel);
     } else {
       XtSetArg(arg[0],XtNforeground,forePixel);
       XtSetArg(arg[1],XtNbackground,backPixel);
     }
     XtSetValues(w,arg,2); XFlush(display);
   }
   
   void draw_wideframe(struct canvas *can)
   {
     struct canvas fakecan;
     double xmid,ymid,dx,dy;
     POINT s,e;
   
     fakecan = *can;
     dx = 10*(can->xmax-can->xmin); dy = 10*(can->ymax-can->ymin);
     xmid = (can->xmax+can->xmin)/2; ymid = (can->ymax+can->ymin)/2;
   
     fakecan.xmin = xmid-dx/2; fakecan.xmax = xmid+dx/2;
     fakecan.ymin = ymid-dy/2; fakecan.ymax = ymid+dy/2;
   
     XFillRectangle(display,can->window,clearGC,
       0,0,can->width,can->height);
     pline(display,&fakecan,can->window);
     XC(s) = can->width*9/20; YC(s) = can->height*9/20;
     XC(e) = can->width*11/20; YC(e) = can->height*11/20;
     draw_frame0(can->window,s,e);
   }
   
   void create_popup(Widget parent,char *name,char *str,Widget *shell,Widget *dialog)
   {
     Arg arg[3];
     Position x,y;
   
     XtTranslateCoords(parent,0,0,&x,&y);
     XtSetArg(arg[0],XtNx,x); XtSetArg(arg[1],XtNy,y);
     *shell = XtCreatePopupShell(name,transientShellWidgetClass,parent,arg,2);
     XtSetArg(arg[0],XtNlabel,str);
     *dialog = XtCreateManagedWidget("dialog",dialogWidgetClass,*shell,arg,1);
   }
   
   void warning(struct canvas *can,char *s)
   {
     void popdown_warning();
     Widget warnshell,warndialog;
   
     if ( !can->shell )
       return;
     create_popup(can->shell,"warning",s,&warnshell,&warndialog);
     XawDialogAddButton(warndialog,"dismiss",popdown_warning,warnshell);
     XtPopup(warnshell,XtGrabNone);
     SetWM_Proto(warnshell);
   }
   
   void popdown_warning(Widget w,XtPointer client,XtPointer call)
   {
     XtPopdown(client); XtDestroyWidget(client);
   }
   
   void show_formula(Widget w,struct canvas *can,XtPointer calldata)
   {
     void popdown_formula();
     Widget fshell,fdialog;
     char buf[BUFSIZ];
   
     soutput_init(buf); sprintexpr(CO,(Obj)can->formula);
     create_popup(can->shell,"formula",buf,&fshell,&fdialog);
     XawDialogAddButton(fdialog,"dismiss",popdown_formula,w);
     XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
     SetWM_Proto(fshell);
   }
   
   void popdown_formula(Widget w,Widget fbutton,XtPointer call)
   {
     Widget shell = XtParent(XtParent(w));
     XtPopdown(shell); XtDestroyWidget(shell);
     XtSetSensitive(fbutton,True);
   }
   
   #define NormalSelection ButtonPressMask|ButtonReleaseMask|Button1MotionMask|Button3MotionMask|StructureNotifyMask| ExposureMask
   
   void create_canvas(struct canvas *can)
   {
     Widget box,frame,commands,
       coords,quit,print,wide,precise,canvas,formula;
     Window window;
     Pixmap pix;
     int width,height;
     Arg arg[6];
     char buf[BUFSIZ];
   
     XImage *image;
   
     width = can->width; height = can->height;
   
     sprintf(buf,"%s : %d", can->wname?can->wname:"Plot",can->index);
     XtSetArg(arg[0],XtNiconName,buf);
     can->shell =
       XtCreatePopupShell("shell",topLevelShellWidgetClass,toplevel,arg,1);
   
     XtSetArg(arg[0],XtNhSpace,0);
     XtSetArg(arg[1],XtNvSpace,0);
     XtSetArg(arg[2],XtNborderWidth,0);
     box = XtCreateManagedWidget("box",boxWidgetClass,can->shell,arg,3);
   
     frame = XtCreateManagedWidget("form",formWidgetClass,box,NULL,0);
   
     XtSetArg(arg[0],XtNorientation,XtorientHorizontal);
     XtSetArg(arg[1],XtNborderWidth,0);
     commands = XtCreateManagedWidget("commands",boxWidgetClass,frame,arg,2);
   
     quit = XtCreateManagedWidget("quit",commandWidgetClass,commands,NULL,0);
     XtAddCallback(quit,XtNcallback,(XtCallbackProc)destroy_canvas,can);
     print = XtCreateManagedWidget("print",commandWidgetClass,commands,NULL,0);
     XtAddCallback(print,XtNcallback,(XtCallbackProc)print_canvas,can);
     can->wideb = wide =
       XtCreateManagedWidget("wide",toggleWidgetClass,commands,NULL,0);
     XtAddCallback(wide,XtNcallback,(XtCallbackProc)wide_canvas,can);
     can->preciseb = precise =
       XtCreateManagedWidget("precise",toggleWidgetClass,commands,NULL,0);
     XtAddCallback(precise,XtNcallback,(XtCallbackProc)precise_canvas,can);
     formula =
       XtCreateManagedWidget("formula",commandWidgetClass,commands,NULL,0);
     XtAddCallback(formula,XtNcallback,(XtCallbackProc)show_formula,can);
     can->noaxisb =
       XtCreateManagedWidget("noaxis",toggleWidgetClass,commands,NULL,0);
     XtAddCallback(can->noaxisb,XtNcallback,(XtCallbackProc)noaxis_canvas,can);
   
     XtSetArg(arg[0],XtNfromVert,commands);
     XtSetArg(arg[1],XtNwidth,width);
     XtSetArg(arg[2],XtNheight,height);
     canvas = XtCreateManagedWidget("canvas",simpleWidgetClass,frame,arg,3);
   
     XtSetArg(arg[0],XtNfromVert,canvas);
     XtSetArg(arg[1],XtNheight,5);
     XtSetArg(arg[2],XtNwidth,width);
     XtSetArg(arg[3],XtNorientation,XtorientHorizontal);
     XtSetArg(arg[4],XtNsensitive,False);
     can->xdone =
       XtCreateManagedWidget("xdone",scrollbarWidgetClass,frame,arg,5);
   
     XtSetArg(arg[0],XtNfromHoriz,canvas);
     XtSetArg(arg[1],XtNfromVert,commands);
     XtSetArg(arg[2],XtNwidth,5);
     XtSetArg(arg[3],XtNheight,height);
     XtSetArg(arg[4],XtNorientation,XtorientVertical);
     XtSetArg(arg[5],XtNsensitive,False);
     can->ydone =
       XtCreateManagedWidget("ydone",scrollbarWidgetClass,frame,arg,6);
   
     XtSetArg(arg[0],XtNfromVert,can->xdone);
     XtSetArg(arg[1],XtNorientation,XtorientHorizontal);
     XtSetArg(arg[2],XtNborderWidth,0);
     coords = XtCreateManagedWidget("coords",boxWidgetClass,frame,arg,3);
   
     XtSetArg(arg[0],XtNwidth,LABELWIDTH);
     can->xcoord = XtCreateManagedWidget("xcoord",labelWidgetClass,coords,arg,1);
     XtSetArg(arg[0],XtNwidth,LABELWIDTH);
     can->ycoord = XtCreateManagedWidget("ycoord",labelWidgetClass,coords,arg,1);
   
     XtAddEventHandler(canvas,ButtonPressMask,False,(XtEventHandler)press,can);
     XtAddEventHandler(canvas,ButtonReleaseMask,False,(XtEventHandler)release,can);
     XtAddEventHandler(canvas,Button1MotionMask,False,(XtEventHandler)motion,can);
     XtAddEventHandler(canvas,Button3MotionMask,False,(XtEventHandler)motion,can);
     XtAddEventHandler(canvas,StructureNotifyMask,False,(XtEventHandler)structure,can);
     XtAddEventHandler(canvas,ExposureMask,False,(XtEventHandler)structure,can);
   
     if ( can->mode == modeNO(CONPLOT) ) {
       XtSetArg(arg[0],XtNwidth,LABELWIDTH);
       can->level = XtCreateManagedWidget("level",labelWidgetClass,
         commands,arg,1);
   
       XtSetArg(arg[0],XtNsensitive,True);
       XtSetValues(can->ydone,arg,1);
       if ( depth >= 2 ) {
         XtAddCallback(can->ydone,XtNjumpProc,(XtCallbackProc)jumpproc,can);
         XtAddEventHandler(can->ydone,ButtonReleaseMask,False,(XtEventHandler)lrelease,can);
       } else {
         XtAddCallback(can->ydone,XtNjumpProc,(XtCallbackProc)jumpproc_m,can);
         XtAddEventHandler(can->ydone,ButtonReleaseMask,False,(XtEventHandler)lrelease_m,can);
       }
     }
     if ( can->mode != modeNO(IFPLOT) || !qpcheck((Obj)can->formula) )
       XtSetSensitive(precise,False);
     XtPopup(can->shell,XtGrabNone);
     SetWM_Proto(can->shell);
     window = can->window = XtWindow(canvas);
     pix = can->pix = XCreatePixmap(display,window,width,height,depth);
     XFillRectangle(display,pix,clearGC,0,0,width,height);
     image = XGetImage(display, can->pix, 0, 0, can->width, can->height,
       -1, ZPixmap);
     BackPixel = XGetPixel(image,0,0);
     XDefineCursor(display,window,normalcur);
     XFlush(display);
     current_can = can;
   }
   
   void alloc_pixmap(struct canvas *can)
   {
     can->pix = XCreatePixmap(display,can->window,
       can->width,can->height,depth);
     XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);
   }
   
   static XrmOptionDescRec options[] = {
   {"-upsidedown","*upsidedown",XrmoptionNoArg,"on"},
   {"-reverse","*reverse",XrmoptionNoArg,"on"},
   {"-fg","*foreground",XrmoptionSepArg,NULL},
   {"-bg","*background",XrmoptionSepArg,NULL},
   };
   
   #define offset(name) XtOffset(struct PlotResources *,name)
   
   static XtResource resources[] = {
   {"upsidedown","UpsideDown",XtRBoolean,sizeof(Boolean),
     offset(UpsideDown),XtRBoolean,&upsidedown},
   {"reverse","Reverse",XtRBoolean,sizeof(Boolean),
     offset(Reverse),XtRBoolean,&reverse},
   {"foreground","Foreground",XtRString,sizeof(char *),
     offset(ForeName),XtRString,NULL},
   {"foreground","Foreground",XtRPixel,sizeof(Pixel),
     offset(ForePixel),XtRPixel,(XtPointer)&forePixel},
   {"background","Background",XtRString,sizeof(char *),
     offset(BackName),XtRString,NULL},
   {"background","Background",XtRPixel,sizeof(Pixel),
     offset(BackPixel),XtRPixel,(XtPointer)&backPixel},
   {"dash","Dash",XtRString,sizeof(char *),
     offset(DashName),XtRString,NULL},
   {"dash","Dash",XtRPixel,sizeof(Pixel),
     offset(DashPixel),XtRPixel,(XtPointer)&dashPixel},
   };
   
   static XtActionsRec actions_table[] = {
     {"quit",Quit},
   };
   
   static void Quit(Widget w, XEvent *ev, String *params,Cardinal *nparams)
   {
       XBell(XtDisplay(w),0);
   }
   
   int init_plot_display(int argc,char **argv)
   {
     int ac;
     char **av;
     unsigned int tmp;
   
     for ( ac = argc, av = argv; ac; ac--, av++ )
       if ( !strcmp(*av,"nox") )
         return 0;
       else if ( index(*av,':') )
         dname = *av;
     XtToolkitInitialize();
     app_con = XtCreateApplicationContext();
     XtAppAddActions(app_con,actions_table, XtNumber(actions_table));
     display = XtOpenDisplay(app_con,dname,"plot","Plot",
       options,XtNumber(options),&argc,argv);
     if ( !display ) {
       fprintf(stderr,"Can't open display\n");
       return 0;
     }
     toplevel = XtAppCreateShell(0,"Plot",applicationShellWidgetClass,
       display,0,0);
   
     forePixel = blackPixel; backPixel = whitePixel;
     dashPixel = blackPixel;
     XtGetApplicationResources(toplevel,&PlotResources,
       resources,XtNumber(resources),NULL,0);
     display = XtDisplay(toplevel);
     scrn = DefaultScreen(display);
     depth = DefaultDepth(display,scrn);
     rootwin = RootWindow(display,scrn);
   
     /* for handling DELETE message */
     wm_delete_window = XInternAtom(display,"WM_DELETE_WINDOW",False);
     XtOverrideTranslations(toplevel,
       XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));
   
     if ( reverse ) {
       tmp = forePixel; forePixel = backPixel; backPixel = tmp;
     }
   
     create_gc();
     create_font();
     create_cursors();
     return 1;
   }
   
   static char *scalefont = "*-8-80-*";
   
   void create_font() {
     Font sfid;
   
     sfid = XLoadFont(display,scalefont);
     sffs = XQueryFont(display,sfid);
     XSetFont(display,scaleGC,sfid);
   }
   
   void create_gc() {
     static XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};
   
     drawGC = XCreateGC(display,rootwin,0,NULL);
     dashGC = XCreateGC(display,rootwin,0,NULL);
     hlGC = XCreateGC(display,rootwin,0,NULL);
     clearGC = XCreateGC(display,rootwin,0,NULL);
     scaleGC = XCreateGC(display,rootwin,0,NULL);
     xorGC = XCreateGC(display,rootwin,0,NULL);
     colorGC = XCreateGC(display,rootwin,0,NULL);
     cdrawGC = XCreateGC(display,rootwin,0,NULL);
     XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,drawGC);
     XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,dashGC);
     XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,clearGC);
     XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,scaleGC);
     XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,xorGC);
     XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,colorGC);
     XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,cdrawGC);
     XSetForeground(display,drawGC,forePixel);
     XSetForeground(display,scaleGC,forePixel);
     XSetForeground(display,clearGC,backPixel);
     XSetForeground(display,xorGC,forePixel^backPixel);
     XSetFunction(display,xorGC,GXxor);
     XSetForeground(display,dashGC,dashPixel);
     XSetLineAttributes(display,dashGC,1,LineOnOffDash,CapButt,JoinRound);
   
     color.red = color.green = color.blue = 0xffff/2;
     XAllocColor(display,DefaultColormap(display,scrn),&color);
     XSetForeground(display,hlGC,color.pixel);
     color.red = 0xffff; color.green = color.blue = 0;
     XAllocColor(display,DefaultColormap(display,scrn),&color);
     XSetForeground(display,colorGC,color.pixel);
   }
   
   void set_drawcolor(unsigned int c)
   {
     XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};
   
     color.red = (c&0xff0000)>>8;
     color.green = (c&0xff00);
     color.blue = (c&0xff)<<8;
     XAllocColor(display,DefaultColormap(display,scrn),&color);
     XSetForeground(display,cdrawGC,color.pixel);
   }
   
   void create_cursors() {
     static XColor fg = {0, 0x0, 0x0, 0x0,DoRed|DoGreen|DoBlue,0};
     static XColor bg = {0, 0xffff, 0xffff, 0xffff,DoRed|DoGreen|DoBlue,0};
   
     XAllocColor(display,DefaultColormap(display,scrn),&fg);
     XAllocColor(display,DefaultColormap(display,scrn),&bg);
     normalcur = create_cursor(h_bits,h_m_bits,h_width,h_height,
       h_x_hot,h_y_hot,&fg,&bg);
     runningcur = create_cursor(ht_bits,ht_m_bits,ht_width,ht_height,
       ht_width/2,ht_height/2,&fg,&bg);
     errorcur = create_cursor(m_bits,m_m_bits,m_width,m_height,
       m_width/2,m_height/2,&fg,&bg);
   }
   
   Cursor create_cursor(char *image,char *mask,int width,int height,int xhot,int yhot,XColor *fg,XColor *bg)
   {
     Pixmap ipix,mpix;
   
     ipix = XCreateBitmapFromData(display,rootwin,image,width,height);
     mpix = XCreateBitmapFromData(display,rootwin,mask,width,height);
     return XCreatePixmapCursor(display,ipix,mpix,fg,bg,xhot,yhot);
   }
   
   void copy_to_canvas(struct canvas *can)
   {
     if ( display ) {
       if ( can->color ) {
         set_drawcolor(can->color);
         XCopyArea(display,can->pix,can->window,
           cdrawGC,0,0,can->width,can->height,0,0);
       } else
         XCopyArea(display,can->pix,can->window,
           drawGC,0,0,can->width,can->height,0,0);
       pline(display,can,can->window);
       XFlush(display);
     }
   }
   
   void copy_subimage(struct canvas *subcan,struct canvas *can,XPoint pos)
   {
     if ( display ) {
       XCopyArea(display,subcan->pix,can->pix,
         drawGC,0,0,subcan->width,subcan->height,pos.x,pos.y);
       XFlush(display);
     }
   }
   
   #include <signal.h>
   #include <fcntl.h>
   
   void set_selection() {
     if ( current_can ) {
       XSelectInput(display,current_can->window,0);
       XFlush(display);
     }
   }
   
   void reset_selection() {
     if ( current_can ) {
       XSelectInput(display,current_can->window,NormalSelection);
       XFlush(display);
     }
   }
   
   void set_busy(struct canvas *can)
   {
     busy = 1;
     XtSetSensitive(can->wideb,False);
     XtSetSensitive(can->preciseb,False);
     XtSetSensitive(can->noaxisb,False);
     XFlush(display);
   }
   
   void reset_busy(struct canvas *can)
   {
     busy = 0;
     if ( can->window ) {
       XtSetSensitive(can->wideb,True);
       XtSetSensitive(can->noaxisb,True);
       if ( can->mode == modeNO(IFPLOT) && qpcheck((Obj)can->formula) )
         XtSetSensitive(can->preciseb,True);
       XFlush(display);
     }
   }
   
   void reset_current_computation()
   {
     if ( current_can ) {
       reset_selection(); reset_busy(current_can);
       define_cursor(current_can->window,normalcur);
     }
   }
   
 static struct canvas *Can;  static struct canvas *Can;
 /* void print_canvas(Widget w,struct canvas *can, XtPointer calldata); */  /* void print_canvas(Widget w,struct canvas *can, XtPointer calldata); */
 static void output_to_file(Widget , XtPointer, XtPointer );  static void output_to_file(Widget , XtPointer, XtPointer );
 static void output_to_ps_printer(Widget , XtPointer, XtPointer );  static void output_to_ps_printer(Widget , XtPointer, XtPointer );
 static void cancel_output_to_file(Widget , XtPointer,XtPointer);  static void cancel_output_to_file(Widget , XtPointer,XtPointer);
 static void generate_psfile(struct canvas *can, FILE *fp);  static void generate_psfile(struct canvas *can, FILE *fp);
   static void set_printing_method(Widget,XtPointer,XtPointer);
   static void method_is_not_available();
 static Widget PrintDialog;  static Widget PrintDialog;
 static Widget PrintDialog_lp;  static Widget PrintDialog_lp;
 static Widget W;  static Widget W;
   static char *Fname = NULL;
   static char *PrinterName = NULL;
   #define PRINTING_METHOD_BITMAP 0
   #define PRINTING_METHOD_VECTOR 1
   static int PrintingMethod = PRINTING_METHOD_BITMAP;
   static String Printing_methods[]={
     "bitMap","vector",
   };
   static int N_printing_methods = 2;
   
 static void print_canvas(w,can,calldata)  /*
          Widget w;  static Widget create_printing_method_bar(Widget parent) {
          struct canvas *can;    Widget panel, button;
          XtPointer calldata;    int i,n;
     Arg wargs[1];
     panel = XtCreateManagedWidget("printing methods",panedWidgetClass,
                   parent,NULL,0);
     for (i=0; i<N_printing_methods; i++) {
     button = XtCreateManagedWidget(Printing_methods[i],menuButtonWidgetClass,
                      panel,NULL,0);
     fprintf(stderr,"button=%x\n",(int) button);
     XtAddCallback(button,XtNcallback,set_printing_method,(XtPointer) i);
     }
     return(panel);
   }
   */
   
   
   static void print_canvas(Widget w,struct canvas *can,XtPointer calldata)
 {  {
   Widget fshell,fdialog;    Widget fshell,fdialog;
   extern struct canvas *Can;    extern struct canvas *Can;
   extern Widget W;    extern Widget W;
   static void output_to_printer();  
   static void print_canvas_to_file();  
   
   W = w;    W = w;
   Can = can;    Can = can;
   create_popup(can->shell,"Print/Output PS file","",&fshell,&fdialog);    create_popup(can->shell,"Print/Output PS file","",&fshell,&fdialog);
   XawDialogAddButton(fdialog,"print",output_to_printer,w);    XawDialogAddButton(fdialog,"print",(XtCallbackProc)output_to_printer,w);
   XawDialogAddButton(fdialog,"Output PS file",print_canvas_to_file,w);    XawDialogAddButton(fdialog,"output PS file",(XtCallbackProc)print_canvas_to_file,w);
   XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);    XawDialogAddButton(fdialog,"method",(XtCallbackProc)printing_method,w);
     XawDialogAddButton(fdialog,"dismiss",(XtCallbackProc)cancel_output_to_file,w);
   XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);    XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
     SetWM_Proto(fshell);
 }  }
 static void print_canvas_to_file(w,can,calldata)  
          Widget w;  static void set_printing_method(Widget w,XtPointer number,XtPointer call_data)
          struct canvas *can;  
          XtPointer calldata;  
 {  {
   FILE *fp;    Widget shell;
     extern int PrintingMethod;
     PrintingMethod = (int) number;
     fprintf(stderr,"PrintingMethod=%d\n",(int)number);
     shell = XtParent(XtParent(w));
     XtPopdown(shell); XtDestroyWidget(shell);
   }
   
   static void printing_method(Widget w,struct canvas *can,XtPointer calldata)
   {
   Arg arg[10];    Arg arg[10];
     int i,n;
     Widget fshell,fdialog;
     extern struct canvas *Can;
     extern int PrintingMethod;
   
     w = W;
     can = Can;
     create_popup(can->shell,"Printing method",Printing_methods[PrintingMethod],
         &fshell,&fdialog);
     n = 0;
     XtSetArg(arg[n], XtNlabel, "Method: "); n++;
     XtSetArg(arg[n], XtNvalue, Printing_methods[PrintingMethod]); n++;
     XtSetValues(fdialog,arg,n);
     for (i=0; i<N_printing_methods; i++) {
       XawDialogAddButton(
         fdialog,Printing_methods[i],set_printing_method,(XtPointer) i);
     }
     XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
     SetWM_Proto(fshell);
   }
   
   static void print_canvas_to_file(Widget w,struct canvas *can,XtPointer calldata)
   {
     Arg arg[10];
   int n;    int n;
   char psfile[50];    static char *psfile = NULL;
   Widget fshell,fdialog;    Widget fshell,fdialog;
   extern struct canvas *Can;    extern struct canvas *Can;
   extern Widget PrintDialog;    extern Widget PrintDialog;
     extern char *Fname;
   
   w = W;    w = W;
   can = Can;    can = Can;
   strcpy(psfile,"ox_plot.eps");    if (psfile == NULL || Fname == NULL) psfile = "ox_plot.eps";
     else psfile = Fname;
   create_popup(can->shell,"Output as PS file",psfile,&fshell,&fdialog);    create_popup(can->shell,"Output as PS file",psfile,&fshell,&fdialog);
   n = 0;    n = 0;
   XtSetArg(arg[n], XtNlabel, "File : "); n++;    XtSetArg(arg[n], XtNlabel, "File : "); n++;
Line 392  static void print_canvas_to_file(w,can,calldata)
Line 965  static void print_canvas_to_file(w,can,calldata)
   XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);    XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);
   PrintDialog = fdialog;    PrintDialog = fdialog;
   XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);    XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
     SetWM_Proto(fshell);
 }  }
 static void output_to_printer(w,can,calldata)  
          Widget w;  static void output_to_printer(Widget w,struct canvas *can,XtPointer calldata)
          struct canvas *can;  
          XtPointer calldata;  
 {  {
   FILE *fp;  
   Arg arg[10];    Arg arg[10];
   int n;    int n;
   char psfile[50];    static char *psfile = NULL;
   Widget fshell,fdialog;    Widget fshell,fdialog;
   extern struct canvas *Can;    extern struct canvas *Can;
   extern Widget PrintDialog_lp;    extern Widget PrintDialog_lp;
     extern char *PrinterName;
   
   w = W;    w = W;
   can = Can;    can = Can;
   strcpy(psfile,"xerox");    if (psfile  == NULL || PrinterName == NULL) psfile = "lp";
     else psfile = PrinterName;
   create_popup(can->shell,"Output PS file to printer",psfile,&fshell,&fdialog);    create_popup(can->shell,"Output PS file to printer",psfile,&fshell,&fdialog);
   n = 0;    n = 0;
   XtSetArg(arg[n], XtNlabel, "PS Printer Name : "); n++;    XtSetArg(arg[n], XtNlabel, "PS Printer Name : "); n++;
Line 418  static void output_to_printer(w,can,calldata)
Line 991  static void output_to_printer(w,can,calldata)
   XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);    XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);
   PrintDialog_lp = fdialog;    PrintDialog_lp = fdialog;
   XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);    XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
     SetWM_Proto(fshell);
 }  }
   
 static void cancel_output_to_file(w,fbutton,call)  static void cancel_output_to_file(Widget w,XtPointer fbutton,XtPointer call)
          Widget w;  
          XtPointer fbutton, call;  
 {  {
   Widget shell = XtParent(XtParent(w));    Widget shell = XtParent(XtParent(w));
   XtPopdown(shell); XtDestroyWidget(shell);    XtPopdown(shell); XtDestroyWidget(shell);
   XtSetSensitive(fbutton,True);    XtSetSensitive(fbutton,True);
 }  }
   
 static void output_to_file(w,fbutton,call)  static void output_to_file(Widget w,XtPointer fbutton,XtPointer call)
          Widget w;  
          XtPointer fbutton, call;  
 {  {
   char *fname;    char *fname;
   FILE *fp;    FILE *fp;
     int i;
   
   extern struct canvas *Can;    extern struct canvas *Can;
   extern Widget PrintDialog;    extern Widget PrintDialog;
     extern int PrintingMethod;
   Widget shell = XtParent(XtParent(w));    Widget shell = XtParent(XtParent(w));
   
     if (PrintingMethod == PRINTING_METHOD_BITMAP) {
       TODO;
     }else{
       method_is_not_available();
       XtPopdown(shell); XtDestroyWidget(shell);
       XtSetSensitive(fbutton,True);
       return;
     }
   
   fname = XawDialogGetValueString(PrintDialog);    fname = XawDialogGetValueString(PrintDialog);
   fprintf(stderr,"fname=%s\n",fname); fflush(NULL);    Fname = (char *)malloc(sizeof(char)*strlen(fname)+1);
   fp = fopen(fname,"w");    strcpy(Fname,fname);
     for (i=0; i<strlen(Fname); i++) {
       if (Fname[i] == 0xd || Fname[i] == 0xa) {
         Fname[i] = 0; break;
       }
     }
     fprintf(stderr,"fname=%s\n",Fname); fflush(NULL);
     fp = fopen(Fname,"w");
   if (fp == NULL) {    if (fp == NULL) {
         warning(Can,"Could not open the output file.");      warning(Can,"Could not open the output file.");
   }else{    }else{
         generate_psfile(Can,fp);      generate_psfile(Can,fp);
         fclose(fp);      fclose(fp);
   }    }
   
   XtPopdown(shell); XtDestroyWidget(shell);    XtPopdown(shell); XtDestroyWidget(shell);
   XtSetSensitive(fbutton,True);    XtSetSensitive(fbutton,True);
 }  }
   
 static void output_to_ps_printer(w,fbutton,call)  static void output_to_ps_printer(Widget w, XtPointer fbutton, XtPointer call)
          Widget w;  
          XtPointer fbutton, call;  
 {  {
   char *printerName;    char *printerName;
   FILE *fp;    FILE *fp;
Line 464  static void output_to_ps_printer(w,fbutton,call) 
Line 1051  static void output_to_ps_printer(w,fbutton,call) 
   char fname[256];    char fname[256];
   char cmd[512];    char cmd[512];
   static int id = 0;    static int id = 0;
     int i;
   Widget shell = XtParent(XtParent(w));    Widget shell = XtParent(XtParent(w));
   
   sprintf(fname,"/tmp/ox_plot_%d.eps",(int) getpid(),id++);    if (PrintingMethod == PRINTING_METHOD_BITMAP) {
     }else{
       method_is_not_available();
       XtPopdown(shell); XtDestroyWidget(shell);
       XtSetSensitive(fbutton,True);
       return;
     }
   
     sprintf(fname,"/tmp/ox_plot_%d_%d.eps",(int) getpid(),id++);
   
   printerName = XawDialogGetValueString(PrintDialog_lp);    printerName = XawDialogGetValueString(PrintDialog_lp);
   fprintf(stderr,"printerName=%s\n",printerName); fflush(NULL);    PrinterName = (char *)malloc(sizeof(char)*strlen(printerName)+1);
     strcpy(PrinterName,printerName);
     for (i=0; i<strlen(PrinterName); i++) {
       if (PrinterName[i] == 0xd || PrinterName[i] == 0xa) {
         PrinterName[i] = 0; break;
       }
     }
     fprintf(stderr,"printerName=%s\n",PrinterName); fflush(NULL);
   fp = fopen(fname,"w");    fp = fopen(fname,"w");
   if (fp == NULL) {    if (fp == NULL) {
         warning(Can,"Could not open the output file.");      warning(Can,"Could not open the output file.");
   }else{    }else{
         generate_psfile(Can,fp);      generate_psfile(Can,fp);
         fclose(fp);      fclose(fp);
   }    }
   
   sprintf(cmd,"lpr -P%s %s",printerName,fname);    sprintf(cmd,"lpr -P%s %s",PrinterName,fname);
   if (system(cmd)) {    if (system(cmd)) {
         warning(Can,"Unknown printer?");      warning(Can,"Unknown printer?");
   }    }
   sprintf(cmd,"rm -f %s",fname);    sprintf(cmd,"rm -f %s",fname);
   system(cmd);    system(cmd);
Line 488  static void output_to_ps_printer(w,fbutton,call) 
Line 1091  static void output_to_ps_printer(w,fbutton,call) 
   XtSetSensitive(fbutton,True);    XtSetSensitive(fbutton,True);
 }  }
   
   
 /* test sequence  /* test sequence
    ox_launch(0,"ox_plot");     ox_launch(0,"ox_plot");
    ifplot(x^2-y^3);     ifplot(x^2-y^3);
    drawcircle(0,0,100,0,0);     drawcircle(0,0,100,0xff000,0);
    */     */
 static void generate_psfile(can,fp)  static void generate_psfile(struct canvas *can, FILE *fp)
          struct canvas *can;  
          FILE *fp;  
 {  {
   int x,y;  
   XImage *image;    XImage *image;
   int color;    int color[1];
   fprintf(stderr,"generate_psfile\n");    extern int PrintingMethod;
   if ( display ) {  
         fprintf(stderr,"generate_psfile: output to a file.\n");    fprintf(stderr,"generate_psfile\n");
         fprintf(fp,"%%!\n");    if (PrintingMethod == PRINTING_METHOD_BITMAP) {
         fprintf(fp,"%%%%BoundingBox: %d %d %d %d \n",PRINT_XOFFSET,PRINT_YOFFSET,      if ( display ) {
                         PRINT_XOFFSET+can->width+1,PRINT_YOFFSET+can->height+1);        fprintf(stderr,"generate_psfile: output to a file.\n");
         fprintf(fp,"%%This is generated by ifplot\n");        image = XGetImage(display,can->pix,
     fprintf(fp,"/ifplot_putpixel { /oxcolor 2 1 roll def  \n");              0,0,can->width,can->height,-1,ZPixmap);
         fprintf(fp,"    /yyy 2 1 roll def /xxx 2 1 roll def \n");        color[0] = 0; /* black line */
         fprintf(fp,"    gsave newpath xxx yyy .5 0 360 arc \n");        PSFromImage(fp,image,can);
     fprintf(fp,"    .3 oxcolor .04 mul add setgray  fill grestore \n");      }else{
         fprintf(fp,"} def \n");      fprintf(stderr,"Cannot print on this system\n");
         fprintf(fp,"%% newpath   ....  stroke \n");      }
         image = XGetImage(display,can->pix,  
                                           0,0,can->width,can->height,-1,ZPixmap);  
         for (x=0; x<can->width; x++) {  
           for (y=0; y<can->height; y++) {  
                 if ((color = (int) XGetPixel(image,x,y)) == 1) {  
                   /* white background */  
                 }else {  
                   fprintf(fp,"%d %d %d ifplot_putpixel \n",PRINT_XOFFSET+x,  
                                   PRINT_YOFFSET+can->height-y,color);  
                 }  
           }  
         }  
         /* pline(display,can,can->window); */  
         fprintf(fp,"showpage \n");  
   }else{    }else{
         fprintf(stderr,"Cannot print on this system\n");      method_is_not_available();
   }    }
   fflush(NULL);    fflush(NULL);
 }  }
   
 void destroy_canvas(w,can,calldata)  static void method_is_not_available() {
 Widget w;    char *m;
 struct canvas *can;  #define MSG1 "Printing method \""
 XtPointer calldata;  #define MSG2 "\" is not available for this picture."
 {    m = (char *)malloc(strlen(MSG1)+strlen(MSG2)+strlen(Printing_methods[PrintingMethod])+1);
         XtPopdown(can->shell);    strcpy(m,MSG1);
         XtDestroyWidget(can->shell);    strcat(m,Printing_methods[PrintingMethod]);
         XFlush(display);    strcat(m,MSG2);
         if ( can == current_can ) {    warning(Can,m);
                 reset_busy(can); current_can = 0;  
         }  
         canvas[can->index] = 0;  
 }  }
   
 void precise_canvas(w,can,calldata)  void clear_pixmap(struct canvas *can)
 Widget w;  
 struct canvas *can;  
 XtPointer calldata;  
 {  {
         if ( can->precise )    XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);
                 can->precise = 0;    XFlush(display);
         else  
                 can->precise = 1;  
 }  }
   
 void wide_canvas(w,can,calldata)  #if 0
 Widget w;  /*
 struct canvas *can;     The following functions are used to generate color postscript file.
 XtPointer calldata;  */
 {  /* In order to count colorSize, binary tree (sm_btree) is used. */
         if ( can->wide ) {  static struct sm_btree *sm_newNode(unsigned long v);
                 can->wide = 0; copy_to_canvas(can);  static void sm_insert(struct sm_btree *node,unsigned long v);
         } else {  static int sm_count(struct sm_btree *rootp);
                 can->wide = 1; draw_wideframe(can);  static int getColorSizeOfImageForPS(int xsize,int ysize,XImage *image,
         }                                      struct xcolorForPS **tableOfxcolorForPS);
 }  
   
 void noaxis_canvas(w,can,calldata)  struct sm_btree {
 Widget w;    unsigned long p;
 struct canvas *can;    struct sm_btree * left;
 XtPointer calldata;    struct sm_btree * right;
 {  };
         if ( can->noaxis )  
                 can->noaxis = 0;  
         else  
                 can->noaxis = 1;  
         if ( can->wide )  
                 draw_wideframe(can);  
         else  
                 copy_to_canvas(can);  
 }  
   
 toggle_button(w,flag)  static struct sm_btree *sm_newNode(unsigned long v) {
 Widget w;    struct sm_btree * n;
 int flag;    n = (struct sm_btree *)MALLOC(sizeof(struct sm_btree));
 {    if (n == NULL) { fprintf(stderr,"No more memory.\n"); exit(10); }
         Arg arg[2];    n->p = v;
     n->left = NULL;
         if ( flag ) {    n->right = NULL;
                 XtSetArg(arg[0],XtNforeground,backPixel);    return n;
                 XtSetArg(arg[1],XtNbackground,forePixel);  
         } else {  
                 XtSetArg(arg[0],XtNforeground,forePixel);  
                 XtSetArg(arg[1],XtNbackground,backPixel);  
         }  
         XtSetValues(w,arg,2); XFlush(display);  
 }  }
   
 draw_wideframe(can)  static void sm_insert(struct sm_btree *node,unsigned long v)
 struct canvas *can;  
 {  {
         struct canvas fakecan;    if (node->p == v) return;
         double xmin,xmax,ymin,ymax,xmid,ymid,dx,dy;    if (node->p > v) {
         POINT s,e;      if (node->left == NULL) {
         node->left = sm_newNode(v);
         fakecan = *can;        return;
         dx = 10*(can->xmax-can->xmin); dy = 10*(can->ymax-can->ymin);      }
         xmid = (can->xmax+can->xmin)/2; ymid = (can->ymax+can->ymin)/2;      sm_insert(node->left,v);
     }
         fakecan.xmin = xmid-dx/2; fakecan.xmax = xmid+dx/2;    if (node->p < v) {
         fakecan.ymin = ymid-dy/2; fakecan.ymax = ymid+dy/2;      if (node->right == NULL) {
         node->right = sm_newNode(v);
         XFillRectangle(display,can->window,clearGC,        return;
                 0,0,can->width,can->height);      }
         pline(display,&fakecan,can->window);      sm_insert(node->right,v);
         XC(s) = can->width*9/20; YC(s) = can->height*9/20;    }
         XC(e) = can->width*11/20; YC(e) = can->height*11/20;  
         draw_frame0(can->window,s,e);  
 }  }
   
 create_popup(parent,name,str,shell,dialog)  
 Widget parent;  
 char *name,*str;  
 Widget *shell,*dialog;  
 {  
         Arg arg[3];  
         Position x,y;  
   
         XtTranslateCoords(parent,0,0,&x,&y);  static int sm_count(struct sm_btree *rootp)
         XtSetArg(arg[0],XtNx,x); XtSetArg(arg[1],XtNy,y);  
         *shell = XtCreatePopupShell(name,transientShellWidgetClass,parent,arg,2);  
         XtSetArg(arg[0],XtNlabel,str);  
         *dialog = XtCreateManagedWidget("dialog",dialogWidgetClass,*shell,arg,1);  
 }  
   
 warning(can,s)  
 struct canvas *can;  
 char *s;  
 {  {
         void popdown_warning();    if (rootp == NULL) return 0;
         Widget warnshell,warndialog;    return (1+sm_count(rootp->left)+sm_count(rootp->right));
         Position x,y;  
         Arg arg[3];  
   
         if ( !can->shell )  
                 return;  
         create_popup(can->shell,"warning",s,&warnshell,&warndialog);  
         XawDialogAddButton(warndialog,"dismiss",popdown_warning,warnshell);  
         XtPopup(warnshell,XtGrabNone);  
 }  }
   
 void popdown_warning(w,client,call)  static int setTableOfxcolorForPS(struct sm_btree *rootp,
 Widget w;                                   struct xcolorForPS *table,int k,int size)
 XtPointer client,call;  
 {  {
         XtPopdown(client); XtDestroyWidget(client);    int m;
     m = k;
     if (rootp == NULL) return 0;
     if (k >= size) {
       warning(Can,"internal error of setTableOfxcolorForPS");
     }
     if (rootp->left != NULL) {
       m = setTableOfxcolorForPS(rootp->left,table,k,size);
     }
   
     (table[m]).pixel = rootp->p;
     m++;
     if (rootp->right != NULL) {
       m = setTableOfxcolorForPS(rootp->right,table,m,size);
     }
     return m;
 }  }
   
 void show_formula(w,can,calldata)  static int getColorSizeOfImageForPS(int xsize,int ysize,XImage *image,
 Widget w;                                      struct xcolorForPS **tableOfxcolorForPS)
 struct canvas *can;  
 XtPointer calldata;  
 {  {
         void popdown_formula();    int x,y;
         Widget fshell,fdialog;    int size;
         char buf[BUFSIZ];    struct sm_btree root;
     struct xcolorForPS *table;
     XStandardColormap scm;
     Colormap cm;
     XColor color;
     XColor white;
     int screen,i;
   
         soutput_init(buf); sprintexpr(CO,(Obj)can->formula);    root.p = 0;
         create_popup(can->shell,"formula",buf,&fshell,&fdialog);    root.left = NULL; root.right=NULL;
         XawDialogAddButton(fdialog,"dismiss",popdown_formula,w);    /* get color size */
         XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);    for (x=0; x<xsize; x++) {
 }      for (y=0; y<ysize; y++) {
         sm_insert(&root,XGetPixel(image,x,y));
       }
     }
     size=sm_count(&root);
   
 void popdown_formula(w,fbutton,call)    table = (struct xcolorForPS *)MALLOC((size+1)*sizeof(struct xcolorForPS));
 Widget w,fbutton;    if (table == NULL) {
 XtPointer call;    fprintf(stderr,"No more memory in getColorSizeOfImageForPS.\n");
 {    return 0;
         Widget shell = XtParent(XtParent(w));    }
         XtPopdown(shell); XtDestroyWidget(shell);    /* Set rgb values standing for the pixel values.
         XtSetSensitive(fbutton,True);    */
 }    if (setTableOfxcolorForPS(&root,table,0,size) != size) {
     warning(Can,"internal error.");
     return 0;
     }
   
 #define NormalSelection ButtonPressMask|ButtonReleaseMask|Button1MotionMask|Button3MotionMask|StructureNotifyMask| ExposureMask    screen = DefaultScreen(display);
     cm = DefaultColormap(display,screen);
     /*  BUG: it does not work.
     if (!XGetStandardColormap(display,RootWindow(display,DefaultScreen(display)),&scm,XA_RGB_DEFAULT_MAP)) {
     warning(Can,"failed to open the X Standard Colormap.");
     scm.red_max = 0xffff;
     scm.green_max = 0xffff;
     scm.blue_max = 0xffff;
     }
     */
     /* Set by hand. */
     scm.red_max = 0xffff;
     scm.green_max = 0xffff;
     scm.blue_max = 0xffff;
     XParseColor(display,cm,"White",&white);
     for (i=0; i<size; i++) {
       color.pixel=(table[i]).pixel;
       /*
       {
         char s[254];
         sprintf(s,"%ld",color.pixel);
         warning(Can,s);
       }
       */
       XQueryColor(display,cm,&color);
       (table[i]).r = ((double) color.red)/((double) scm.red_max);
       (table[i]).g = ((double) color.green)/((double) scm.green_max);
       (table[i]).b = ((double) color.blue)/((double) scm.blue_max);
       if ((table[i]).r > 1.0) (table[i]).r = 1.0;
       if ((table[i]).g > 1.0) (table[i]).g = 1.0;
       if ((table[i]).b > 1.0) (table[i]).b = 1.0;
       if (color.red == white.red && color.green == white.green
           && color.blue == white.blue) {
         (table[i]).print = 0;
       }else{
         (table[i]).print = 1;
       }
     }
   
 create_canvas(can)    *tableOfxcolorForPS = table;
 struct canvas *can;    return size;
 {  
         XEvent event;  
         Widget box,frame,commands,  
                 coords,quit,print,wide,precise,canvas,formula;  
         Window window;  
         Pixmap pix;  
         int i,width,height;  
         Arg arg[6];  
         char buf[BUFSIZ];  
   
         width = can->width; height = can->height;  
   
         sprintf(buf,"%s : %d/%d", can->wname?can->wname:"Plot",  
                 remotes,can->index);  
         XtSetArg(arg[0],XtNiconName,buf);  
         can->shell =  
                 XtCreatePopupShell("shell",topLevelShellWidgetClass,toplevel,arg,1);  
   
         XtSetArg(arg[0],XtNhSpace,0);  
         XtSetArg(arg[1],XtNvSpace,0);  
         XtSetArg(arg[2],XtNborderWidth,0);  
         box = XtCreateManagedWidget("box",boxWidgetClass,can->shell,arg,3);  
   
         frame = XtCreateManagedWidget("form",formWidgetClass,box,NULL,0);  
   
         XtSetArg(arg[0],XtNorientation,XtorientHorizontal);  
         XtSetArg(arg[1],XtNborderWidth,0);  
         commands = XtCreateManagedWidget("commands",boxWidgetClass,frame,arg,2);  
   
         quit = XtCreateManagedWidget("quit",commandWidgetClass,commands,NULL,0);  
         XtAddCallback(quit,XtNcallback,destroy_canvas,can);  
         print = XtCreateManagedWidget("print",commandWidgetClass,commands,NULL,0);  
         XtAddCallback(print,XtNcallback,print_canvas,can);  
         can->wideb = wide =  
                 XtCreateManagedWidget("wide",toggleWidgetClass,commands,NULL,0);  
         XtAddCallback(wide,XtNcallback,wide_canvas,can);  
         can->preciseb = precise =  
                 XtCreateManagedWidget("precise",toggleWidgetClass,commands,NULL,0);  
         XtAddCallback(precise,XtNcallback,precise_canvas,can);  
         formula =  
                 XtCreateManagedWidget("formula",commandWidgetClass,commands,NULL,0);  
         XtAddCallback(formula,XtNcallback,show_formula,can);  
         can->noaxisb =  
                 XtCreateManagedWidget("noaxis",toggleWidgetClass,commands,NULL,0);  
         XtAddCallback(can->noaxisb,XtNcallback,noaxis_canvas,can);  
   
         XtSetArg(arg[0],XtNfromVert,commands);  
         XtSetArg(arg[1],XtNwidth,width);  
         XtSetArg(arg[2],XtNheight,height);  
         canvas = XtCreateManagedWidget("canvas",simpleWidgetClass,frame,arg,3);  
   
         XtSetArg(arg[0],XtNfromVert,canvas);  
         XtSetArg(arg[1],XtNheight,5);  
         XtSetArg(arg[2],XtNwidth,width);  
         XtSetArg(arg[3],XtNorientation,XtorientHorizontal);  
         XtSetArg(arg[4],XtNsensitive,False);  
         can->xdone =  
                 XtCreateManagedWidget("xdone",scrollbarWidgetClass,frame,arg,5);  
   
         XtSetArg(arg[0],XtNfromHoriz,canvas);  
         XtSetArg(arg[1],XtNfromVert,commands);  
         XtSetArg(arg[2],XtNwidth,5);  
         XtSetArg(arg[3],XtNheight,height);  
         XtSetArg(arg[4],XtNorientation,XtorientVertical);  
         XtSetArg(arg[5],XtNsensitive,False);  
         can->ydone =  
                 XtCreateManagedWidget("ydone",scrollbarWidgetClass,frame,arg,6);  
   
         XtSetArg(arg[0],XtNfromVert,can->xdone);  
         XtSetArg(arg[1],XtNorientation,XtorientHorizontal);  
         XtSetArg(arg[2],XtNborderWidth,0);  
         coords = XtCreateManagedWidget("coords",boxWidgetClass,frame,arg,3);  
   
         XtSetArg(arg[0],XtNwidth,LABELWIDTH);  
         can->xcoord = XtCreateManagedWidget("xcoord",labelWidgetClass,coords,arg,1);  
         XtSetArg(arg[0],XtNwidth,LABELWIDTH);  
         can->ycoord = XtCreateManagedWidget("ycoord",labelWidgetClass,coords,arg,1);  
   
         XtAddEventHandler(canvas,ButtonPressMask,False,press,can);  
         XtAddEventHandler(canvas,ButtonReleaseMask,False,release,can);  
         XtAddEventHandler(canvas,Button1MotionMask,False,motion,can);  
         XtAddEventHandler(canvas,Button3MotionMask,False,motion,can);  
         XtAddEventHandler(canvas,StructureNotifyMask,False,structure,can);  
         XtAddEventHandler(canvas,ExposureMask,False,structure,can);  
   
         if ( can->mode == MODE_CONPLOT ) {  
                 Widget scale;  
   
                 XtSetArg(arg[0],XtNwidth,LABELWIDTH);  
                 can->level = XtCreateManagedWidget("level",labelWidgetClass,  
                         commands,arg,1);  
   
                 XtSetArg(arg[0],XtNsensitive,True);  
                 XtSetValues(can->ydone,arg,1);  
                 if ( depth >= 2 ) {  
                         XtAddCallback(can->ydone,XtNjumpProc,jumpproc,can);  
                         XtAddEventHandler(can->ydone,ButtonReleaseMask,False,lrelease,can);  
                 } else {  
                         XtAddCallback(can->ydone,XtNjumpProc,jumpproc_m,can);  
                         XtAddEventHandler(can->ydone,ButtonReleaseMask,False,lrelease_m,can);  
                 }  
         }  
         if ( can->mode != MODE_IFPLOT || !qpcheck((Obj)can->formula) )  
                 XtSetSensitive(precise,False);  
         XtPopup(can->shell,XtGrabNone);  
   
         window = can->window = XtWindow(canvas);  
         pix = can->pix = XCreatePixmap(display,window,width,height,depth);  
         XFillRectangle(display,pix,clearGC,0,0,width,height);  
         XDefineCursor(display,window,normalcur);  
         XFlush(display);  
         current_can = can;  
 }  }
   #endif
   
 alloc_pixmap(can)  
 struct canvas *can;  
 {  
         can->pix = XCreatePixmap(display,can->window,  
                 can->width,can->height,depth);  
         XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);  
 }  
   
 static XrmOptionDescRec options[] = {  
 {"-reverse","*reverse",XrmoptionNoArg,"on"},  
 {"-fg","*foreground",XrmoptionSepArg,NULL},  
 {"-bg","*background",XrmoptionSepArg,NULL},  
 };  
   
 #define offset(name) XtOffset(struct PlotResources *,name)  
   
 static XtResource resources[] = {  
 {"reverse","Reverse",XtRBoolean,sizeof(Boolean),  
         offset(Reverse),XtRBoolean,&reverse},  
 {"foreground","Foreground",XtRString,sizeof(char *),  
         offset(ForeName),XtRString,NULL},  
 {"foreground","Foreground",XtRPixel,sizeof(Pixel),  
         offset(ForePixel),XtRPixel,(XtPointer)&forePixel},  
 {"background","Background",XtRString,sizeof(char *),  
         offset(BackName),XtRString,NULL},  
 {"background","Background",XtRPixel,sizeof(Pixel),  
         offset(BackPixel),XtRPixel,(XtPointer)&backPixel},  
 {"dash","Dash",XtRString,sizeof(char *),  
         offset(DashName),XtRString,NULL},  
 {"dash","Dash",XtRPixel,sizeof(Pixel),  
         offset(DashPixel),XtRPixel,(XtPointer)&dashPixel},  
 };  
   
 init_plot_display(argc,argv)  
 int argc;  
 char **argv;  
 {  
         int ac;  
         char **av;  
         unsigned int tmp;  
   
         for ( ac = argc, av = argv; ac; ac--, av++ )  
                 if ( index(*av,':') )  
                         dname = *av;  
         XtToolkitInitialize();  
         app_con = XtCreateApplicationContext();  
         display = XtOpenDisplay(app_con,dname,"plot","Plot",  
                 options,XtNumber(options),&argc,argv);  
         if ( !display ) {  
                 fprintf(stderr,"Can't open display\n");  
                 exit(1);  
         }  
         toplevel = XtAppCreateShell(0,"Plot",applicationShellWidgetClass,  
                 display,0,0);  
   
         forePixel = blackPixel; backPixel = whitePixel;  
         dashPixel = blackPixel;  
         XtGetApplicationResources(toplevel,&PlotResources,  
                 resources,XtNumber(resources),NULL,0);  
         display = XtDisplay(toplevel);  
         scrn = DefaultScreen(display);  
         depth = DefaultDepth(display,scrn);  
         rootwin = RootWindow(display,scrn);  
   
         if ( reverse ) {  
                 tmp = forePixel; forePixel = backPixel; backPixel = tmp;  
         }  
   
         create_gc();  
         create_font();  
         create_cursors();  
 }  
   
 static char *scalefont = "*-8-80-*";  
   
 create_font() {  
         Font sfid;  
   
         sfid = XLoadFont(display,scalefont);  
         sffs = XQueryFont(display,sfid);  
         XSetFont(display,scaleGC,sfid);  
 }  
   
 create_gc() {  
         static XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};  
         int i,b,step;  
   
         drawGC = XCreateGC(display,rootwin,0,NULL);  
         dashGC = XCreateGC(display,rootwin,0,NULL);  
         hlGC = XCreateGC(display,rootwin,0,NULL);  
         clearGC = XCreateGC(display,rootwin,0,NULL);  
         scaleGC = XCreateGC(display,rootwin,0,NULL);  
         xorGC = XCreateGC(display,rootwin,0,NULL);  
         colorGC = XCreateGC(display,rootwin,0,NULL);  
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,drawGC);  
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,dashGC);  
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,clearGC);  
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,scaleGC);  
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,xorGC);  
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,colorGC);  
         XSetForeground(display,drawGC,forePixel);  
         XSetForeground(display,scaleGC,forePixel);  
         XSetForeground(display,clearGC,backPixel);  
         XSetForeground(display,xorGC,forePixel^backPixel);  
         XSetFunction(display,xorGC,GXxor);  
         XSetForeground(display,dashGC,dashPixel);  
         XSetLineAttributes(display,dashGC,1,LineOnOffDash,CapButt,JoinRound);  
   
         color.red = color.green = color.blue = 0xffff/2;  
         XAllocColor(display,DefaultColormap(display,scrn),&color);  
         XSetForeground(display,hlGC,color.pixel);  
         color.red = 0xffff; color.green = color.blue = 0;  
         XAllocColor(display,DefaultColormap(display,scrn),&color);  
         XSetForeground(display,colorGC,color.pixel);  
 }  
   
 create_cursors() {  
         static XColor fg = {0, 0x0, 0x0, 0x0,DoRed|DoGreen|DoBlue,0};  
         static XColor bg = {0, 0xffff, 0xffff, 0xffff,DoRed|DoGreen|DoBlue,0};  
   
         XAllocColor(display,DefaultColormap(display,scrn),&fg);  
         XAllocColor(display,DefaultColormap(display,scrn),&bg);  
         normalcur = create_cursor(h_bits,h_m_bits,h_width,h_height,  
                 h_x_hot,h_y_hot,&fg,&bg);  
         runningcur = create_cursor(ht_bits,ht_m_bits,ht_width,ht_height,  
                 ht_width/2,ht_height/2,&fg,&bg);  
         errorcur = create_cursor(m_bits,m_m_bits,m_width,m_height,  
                 m_width/2,m_height/2,&fg,&bg);  
 }  
   
 Cursor create_cursor(image,mask,width,height,xhot,yhot,fg,bg)  
 char *image,*mask;  
 int width,height,xhot,yhot;  
 XColor *fg,*bg;  
 {  
         Pixmap ipix,mpix;  
   
         ipix = XCreateBitmapFromData(display,rootwin,image,width,height);  
         mpix = XCreateBitmapFromData(display,rootwin,mask,width,height);  
         return XCreatePixmapCursor(display,ipix,mpix,fg,bg,xhot,yhot);  
 }  
   
 copy_to_canvas(can)  
 struct canvas *can;  
 {  
         if ( display ) {  
                 XCopyArea(display,can->pix,can->window,  
                         drawGC,0,0,can->width,can->height,0,0);  
                 pline(display,can,can->window);  
                 XFlush(display);  
         }  
 }  
   
 copy_subimage(subcan,can,pos)  
 struct canvas *subcan,*can;  
 XPoint pos;  
 {  
         if ( display ) {  
                 XCopyArea(display,subcan->pix,can->pix,  
                         drawGC,0,0,subcan->width,subcan->height,pos.x,pos.y);  
                 XFlush(display);  
         }  
 }  
   
 #include <signal.h>  
 #include <fcntl.h>  
   
 set_selection() {  
         if ( current_can ) {  
                 XSelectInput(display,current_can->window,0);  
                 XFlush(display);  
         }  
 }  
   
 reset_selection() {  
         if ( current_can ) {  
                 XSelectInput(display,current_can->window,NormalSelection);  
                 XFlush(display);  
         }  
 }  
   
 set_busy(can)  
 struct canvas *can;  
 {  
         busy = 1;  
         XtSetSensitive(can->wideb,False);  
         XtSetSensitive(can->preciseb,False);  
         XtSetSensitive(can->noaxisb,False);  
         XFlush(display);  
 }  
   
 reset_busy(can)  
 struct canvas *can;  
 {  
         busy = 0;  
         if ( can->window ) {  
                 XtSetSensitive(can->wideb,True);  
                 XtSetSensitive(can->noaxisb,True);  
                 if ( can->mode == MODE_IFPLOT && qpcheck((Obj)can->formula) )  
                         XtSetSensitive(can->preciseb,True);  
                 XFlush(display);  
         }  
 }  
   
 reset_current_computation()  
 {  
         if ( current_can ) {  
                 reset_selection(); reset_busy(current_can);  
                 define_cursor(current_can->window,normalcur);  
         }  
 }  
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.35
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>