[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.34 and 1.35

version 1.34, 2015/08/14 13:51:56 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.33 2015/08/06 10:01:53 fujimoto 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"
Line 82  static Atom wm_delete_window;
Line 82  static Atom wm_delete_window;
   
 void SetWM_Proto(Widget w)  void SetWM_Proto(Widget w)
 {  {
         XtOverrideTranslations(w,    XtOverrideTranslations(w,
                 XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));      XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));
         XSetWMProtocols(display,XtWindow(w),&wm_delete_window,1);    XSetWMProtocols(display,XtWindow(w),&wm_delete_window,1);
 }  }
   
 #if 0  #if 0
Line 130  static XtAppContext app_con;
Line 130  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;    Boolean UpsideDown;
 } PlotResources;  } PlotResources;
   
 #define forePixel PlotResources.ForePixel  #define forePixel PlotResources.ForePixel
Line 149  Pixel BackPixel;
Line 149  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
   
 void 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 */
Line 169  static POINT spos,cpos;
Line 169  static POINT spos,cpos;
   
 void press(Widget w,struct canvas *can,XButtonEvent *ev)  void press(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(Widget w,struct canvas *can,XMotionEvent *ev)  void motion(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(Widget w,struct canvas *can,XButtonEvent *ev)  void release(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)        && can->mode != modeNO(INTERACTIVE)
                         && can->mode != modeNO(POLARPLOT)) plot_resize(can,spos,e);        && can->mode != modeNO(POLARPLOT)) plot_resize(can,spos,e);
                         break;        break;
                 default:      default:
                         break;        break;
         }    }
 }  }
   
 void structure(Widget w,struct canvas *can,XEvent *ev)  void structure(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(Widget w,struct canvas *can,XButtonEvent *ev)  void lpress(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(Widget w,struct canvas *can,float *percent)  void jumpproc(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(Widget w,struct canvas *can,float *percent)  void jumpproc_m(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(Widget w,struct canvas *can,XButtonEvent *ev)  void lrelease(Widget w,struct canvas *can,XButtonEvent *ev)
 {  {
         draw_level(can,lindex,drawGC); lindex = -1;    draw_level(can,lindex,drawGC); lindex = -1;
 }  }
   
 void lrelease_m(Widget w,struct canvas *can,XButtonEvent *ev)  void lrelease_m(Widget w,struct canvas *can,XButtonEvent *ev)
 {  {
         lindex = -1;    lindex = -1;
 }  }
   
 void draw_level(struct canvas *can,int index,GC gc)  void draw_level(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);
 }  }
   
 void draw_frame(Window window,POINT spos,POINT opos,POINT epos)  void draw_frame(Window window,POINT spos,POINT opos,POINT 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);
 }  }
   
 void draw_frame0(Window window,POINT spos,POINT epos)  void draw_frame0(Window window,POINT spos,POINT 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);
 }  }
   
 void draw_coord(struct canvas *can,POINT pos)  void draw_coord(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);
 }  }
   
 void redraw_canvas(struct canvas *can)  void redraw_canvas(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);
 }  }
   
 int 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;    return -1;
 }  }
   
 int 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)  void popup_canvas(int index)
 {  {
         clear_pixmap(canvas[index]);    clear_pixmap(canvas[index]);
         XtPopup(canvas[index]->shell,XtGrabNone);    XtPopup(canvas[index]->shell,XtGrabNone);
         copy_to_canvas(canvas[index]);    copy_to_canvas(canvas[index]);
 }  }
   
 void destroy_canvas(Widget w,struct canvas *can,XtPointer calldata)  void destroy_canvas(Widget w,struct canvas *can,XtPointer calldata)
 {  {
         XtPopdown(can->shell);    XtPopdown(can->shell);
 /*      XtDestroyWidget(can->shell); */  /*  XtDestroyWidget(can->shell); */
         XFlush(display);    XFlush(display);
         if ( can == current_can ) {    if ( can == current_can ) {
                 reset_busy(can); current_can = 0;      reset_busy(can); current_can = 0;
         }    }
         if ( closed_canvas[can->index] )    if ( closed_canvas[can->index] )
                 XtDestroyWidget(closed_canvas[can->index]->shell);      XtDestroyWidget(closed_canvas[can->index]->shell);
         closed_canvas[can->index] = can;    closed_canvas[can->index] = can;
         canvas[can->index] = 0;    canvas[can->index] = 0;
 }  }
   
 void precise_canvas(Widget w,struct canvas *can,XtPointer calldata)  void precise_canvas(Widget w,struct canvas *can,XtPointer calldata)
 {  {
         if ( can->precise )    if ( can->precise )
                 can->precise = 0;      can->precise = 0;
         else    else
                 can->precise = 1;      can->precise = 1;
 }  }
   
 void wide_canvas(Widget w,struct canvas *can,XtPointer calldata)  void wide_canvas(Widget w,struct canvas *can,XtPointer calldata)
 {  {
         if ( can->wide ) {    if ( can->wide ) {
                 can->wide = 0; copy_to_canvas(can);      can->wide = 0; copy_to_canvas(can);
         } else {    } else {
                 can->wide = 1; draw_wideframe(can);      can->wide = 1; draw_wideframe(can);
         }    }
 }  }
   
 void noaxis_canvas(Widget w,struct canvas *can,XtPointer calldata)  void noaxis_canvas(Widget w,struct canvas *can,XtPointer calldata)
 {  {
         if ( can->noaxis )    if ( can->noaxis )
                 can->noaxis = 0;      can->noaxis = 0;
         else    else
                 can->noaxis = 1;      can->noaxis = 1;
         if ( can->wide )    if ( can->wide )
                 draw_wideframe(can);      draw_wideframe(can);
         else    else
                 copy_to_canvas(can);      copy_to_canvas(can);
 }  }
   
 void toggle_button(Widget w,int flag)  void toggle_button(Widget w,int flag)
 {  {
         Arg arg[2];    Arg arg[2];
   
         if ( flag ) {    if ( flag ) {
                 XtSetArg(arg[0],XtNforeground,backPixel);      XtSetArg(arg[0],XtNforeground,backPixel);
                 XtSetArg(arg[1],XtNbackground,forePixel);      XtSetArg(arg[1],XtNbackground,forePixel);
         } else {    } else {
                 XtSetArg(arg[0],XtNforeground,forePixel);      XtSetArg(arg[0],XtNforeground,forePixel);
                 XtSetArg(arg[1],XtNbackground,backPixel);      XtSetArg(arg[1],XtNbackground,backPixel);
         }    }
         XtSetValues(w,arg,2); XFlush(display);    XtSetValues(w,arg,2); XFlush(display);
 }  }
   
 void draw_wideframe(struct canvas *can)  void draw_wideframe(struct canvas *can)
 {  {
         struct canvas fakecan;    struct canvas fakecan;
         double xmid,ymid,dx,dy;    double xmid,ymid,dx,dy;
         POINT s,e;    POINT s,e;
   
         fakecan = *can;    fakecan = *can;
         dx = 10*(can->xmax-can->xmin); dy = 10*(can->ymax-can->ymin);    dx = 10*(can->xmax-can->xmin); dy = 10*(can->ymax-can->ymin);
         xmid = (can->xmax+can->xmin)/2; ymid = (can->ymax+can->ymin)/2;    xmid = (can->xmax+can->xmin)/2; ymid = (can->ymax+can->ymin)/2;
   
         fakecan.xmin = xmid-dx/2; fakecan.xmax = xmid+dx/2;    fakecan.xmin = xmid-dx/2; fakecan.xmax = xmid+dx/2;
         fakecan.ymin = ymid-dy/2; fakecan.ymax = ymid+dy/2;    fakecan.ymin = ymid-dy/2; fakecan.ymax = ymid+dy/2;
   
         XFillRectangle(display,can->window,clearGC,    XFillRectangle(display,can->window,clearGC,
                 0,0,can->width,can->height);      0,0,can->width,can->height);
         pline(display,&fakecan,can->window);    pline(display,&fakecan,can->window);
         XC(s) = can->width*9/20; YC(s) = can->height*9/20;    XC(s) = can->width*9/20; YC(s) = can->height*9/20;
         XC(e) = can->width*11/20; YC(e) = can->height*11/20;    XC(e) = can->width*11/20; YC(e) = can->height*11/20;
         draw_frame0(can->window,s,e);    draw_frame0(can->window,s,e);
 }  }
   
 void create_popup(Widget parent,char *name,char *str,Widget *shell,Widget *dialog)  void create_popup(Widget parent,char *name,char *str,Widget *shell,Widget *dialog)
 {  {
         Arg arg[3];    Arg arg[3];
         Position x,y;    Position x,y;
   
         XtTranslateCoords(parent,0,0,&x,&y);    XtTranslateCoords(parent,0,0,&x,&y);
         XtSetArg(arg[0],XtNx,x); XtSetArg(arg[1],XtNy,y);    XtSetArg(arg[0],XtNx,x); XtSetArg(arg[1],XtNy,y);
         *shell = XtCreatePopupShell(name,transientShellWidgetClass,parent,arg,2);    *shell = XtCreatePopupShell(name,transientShellWidgetClass,parent,arg,2);
         XtSetArg(arg[0],XtNlabel,str);    XtSetArg(arg[0],XtNlabel,str);
         *dialog = XtCreateManagedWidget("dialog",dialogWidgetClass,*shell,arg,1);    *dialog = XtCreateManagedWidget("dialog",dialogWidgetClass,*shell,arg,1);
 }  }
   
 void warning(struct canvas *can,char *s)  void warning(struct canvas *can,char *s)
 {  {
         void popdown_warning();    void popdown_warning();
         Widget warnshell,warndialog;    Widget warnshell,warndialog;
   
         if ( !can->shell )    if ( !can->shell )
                 return;      return;
         create_popup(can->shell,"warning",s,&warnshell,&warndialog);    create_popup(can->shell,"warning",s,&warnshell,&warndialog);
         XawDialogAddButton(warndialog,"dismiss",popdown_warning,warnshell);    XawDialogAddButton(warndialog,"dismiss",popdown_warning,warnshell);
         XtPopup(warnshell,XtGrabNone);    XtPopup(warnshell,XtGrabNone);
         SetWM_Proto(warnshell);    SetWM_Proto(warnshell);
 }  }
   
 void popdown_warning(Widget w,XtPointer client,XtPointer call)  void popdown_warning(Widget w,XtPointer client,XtPointer call)
 {  {
         XtPopdown(client); XtDestroyWidget(client);    XtPopdown(client); XtDestroyWidget(client);
 }  }
   
 void show_formula(Widget w,struct canvas *can,XtPointer calldata)  void show_formula(Widget w,struct canvas *can,XtPointer calldata)
 {  {
         void popdown_formula();    void popdown_formula();
         Widget fshell,fdialog;    Widget fshell,fdialog;
         char buf[BUFSIZ];    char buf[BUFSIZ];
   
         soutput_init(buf); sprintexpr(CO,(Obj)can->formula);    soutput_init(buf); sprintexpr(CO,(Obj)can->formula);
         create_popup(can->shell,"formula",buf,&fshell,&fdialog);    create_popup(can->shell,"formula",buf,&fshell,&fdialog);
         XawDialogAddButton(fdialog,"dismiss",popdown_formula,w);    XawDialogAddButton(fdialog,"dismiss",popdown_formula,w);
         XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);    XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
         SetWM_Proto(fshell);    SetWM_Proto(fshell);
 }  }
   
 void popdown_formula(Widget w,Widget fbutton,XtPointer call)  void popdown_formula(Widget w,Widget fbutton,XtPointer 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);
 }  }
   
 #define NormalSelection ButtonPressMask|ButtonReleaseMask|Button1MotionMask|Button3MotionMask|StructureNotifyMask| ExposureMask  #define NormalSelection ButtonPressMask|ButtonReleaseMask|Button1MotionMask|Button3MotionMask|StructureNotifyMask| ExposureMask
   
 void create_canvas(struct canvas *can)  void create_canvas(struct canvas *can)
 {  {
         Widget box,frame,commands,    Widget box,frame,commands,
                 coords,quit,print,wide,precise,canvas,formula;      coords,quit,print,wide,precise,canvas,formula;
         Window window;    Window window;
         Pixmap pix;    Pixmap pix;
         int width,height;    int width,height;
         Arg arg[6];    Arg arg[6];
         char buf[BUFSIZ];    char buf[BUFSIZ];
   
         XImage *image;    XImage *image;
   
         width = can->width; height = can->height;    width = can->width; height = can->height;
   
         sprintf(buf,"%s : %d", can->wname?can->wname:"Plot",can->index);    sprintf(buf,"%s : %d", can->wname?can->wname:"Plot",can->index);
         XtSetArg(arg[0],XtNiconName,buf);    XtSetArg(arg[0],XtNiconName,buf);
         can->shell =    can->shell =
                 XtCreatePopupShell("shell",topLevelShellWidgetClass,toplevel,arg,1);      XtCreatePopupShell("shell",topLevelShellWidgetClass,toplevel,arg,1);
   
         XtSetArg(arg[0],XtNhSpace,0);    XtSetArg(arg[0],XtNhSpace,0);
         XtSetArg(arg[1],XtNvSpace,0);    XtSetArg(arg[1],XtNvSpace,0);
         XtSetArg(arg[2],XtNborderWidth,0);    XtSetArg(arg[2],XtNborderWidth,0);
         box = XtCreateManagedWidget("box",boxWidgetClass,can->shell,arg,3);    box = XtCreateManagedWidget("box",boxWidgetClass,can->shell,arg,3);
   
         frame = XtCreateManagedWidget("form",formWidgetClass,box,NULL,0);    frame = XtCreateManagedWidget("form",formWidgetClass,box,NULL,0);
   
         XtSetArg(arg[0],XtNorientation,XtorientHorizontal);    XtSetArg(arg[0],XtNorientation,XtorientHorizontal);
         XtSetArg(arg[1],XtNborderWidth,0);    XtSetArg(arg[1],XtNborderWidth,0);
         commands = XtCreateManagedWidget("commands",boxWidgetClass,frame,arg,2);    commands = XtCreateManagedWidget("commands",boxWidgetClass,frame,arg,2);
   
         quit = XtCreateManagedWidget("quit",commandWidgetClass,commands,NULL,0);    quit = XtCreateManagedWidget("quit",commandWidgetClass,commands,NULL,0);
         XtAddCallback(quit,XtNcallback,(XtCallbackProc)destroy_canvas,can);    XtAddCallback(quit,XtNcallback,(XtCallbackProc)destroy_canvas,can);
         print = XtCreateManagedWidget("print",commandWidgetClass,commands,NULL,0);    print = XtCreateManagedWidget("print",commandWidgetClass,commands,NULL,0);
         XtAddCallback(print,XtNcallback,(XtCallbackProc)print_canvas,can);    XtAddCallback(print,XtNcallback,(XtCallbackProc)print_canvas,can);
         can->wideb = wide =    can->wideb = wide =
                 XtCreateManagedWidget("wide",toggleWidgetClass,commands,NULL,0);      XtCreateManagedWidget("wide",toggleWidgetClass,commands,NULL,0);
         XtAddCallback(wide,XtNcallback,(XtCallbackProc)wide_canvas,can);    XtAddCallback(wide,XtNcallback,(XtCallbackProc)wide_canvas,can);
         can->preciseb = precise =    can->preciseb = precise =
                 XtCreateManagedWidget("precise",toggleWidgetClass,commands,NULL,0);      XtCreateManagedWidget("precise",toggleWidgetClass,commands,NULL,0);
         XtAddCallback(precise,XtNcallback,(XtCallbackProc)precise_canvas,can);    XtAddCallback(precise,XtNcallback,(XtCallbackProc)precise_canvas,can);
         formula =    formula =
                 XtCreateManagedWidget("formula",commandWidgetClass,commands,NULL,0);      XtCreateManagedWidget("formula",commandWidgetClass,commands,NULL,0);
         XtAddCallback(formula,XtNcallback,(XtCallbackProc)show_formula,can);    XtAddCallback(formula,XtNcallback,(XtCallbackProc)show_formula,can);
         can->noaxisb =    can->noaxisb =
                 XtCreateManagedWidget("noaxis",toggleWidgetClass,commands,NULL,0);      XtCreateManagedWidget("noaxis",toggleWidgetClass,commands,NULL,0);
         XtAddCallback(can->noaxisb,XtNcallback,(XtCallbackProc)noaxis_canvas,can);    XtAddCallback(can->noaxisb,XtNcallback,(XtCallbackProc)noaxis_canvas,can);
   
         XtSetArg(arg[0],XtNfromVert,commands);    XtSetArg(arg[0],XtNfromVert,commands);
         XtSetArg(arg[1],XtNwidth,width);    XtSetArg(arg[1],XtNwidth,width);
         XtSetArg(arg[2],XtNheight,height);    XtSetArg(arg[2],XtNheight,height);
         canvas = XtCreateManagedWidget("canvas",simpleWidgetClass,frame,arg,3);    canvas = XtCreateManagedWidget("canvas",simpleWidgetClass,frame,arg,3);
   
         XtSetArg(arg[0],XtNfromVert,canvas);    XtSetArg(arg[0],XtNfromVert,canvas);
         XtSetArg(arg[1],XtNheight,5);    XtSetArg(arg[1],XtNheight,5);
         XtSetArg(arg[2],XtNwidth,width);    XtSetArg(arg[2],XtNwidth,width);
         XtSetArg(arg[3],XtNorientation,XtorientHorizontal);    XtSetArg(arg[3],XtNorientation,XtorientHorizontal);
         XtSetArg(arg[4],XtNsensitive,False);    XtSetArg(arg[4],XtNsensitive,False);
         can->xdone =    can->xdone =
                 XtCreateManagedWidget("xdone",scrollbarWidgetClass,frame,arg,5);      XtCreateManagedWidget("xdone",scrollbarWidgetClass,frame,arg,5);
   
         XtSetArg(arg[0],XtNfromHoriz,canvas);    XtSetArg(arg[0],XtNfromHoriz,canvas);
         XtSetArg(arg[1],XtNfromVert,commands);    XtSetArg(arg[1],XtNfromVert,commands);
         XtSetArg(arg[2],XtNwidth,5);    XtSetArg(arg[2],XtNwidth,5);
         XtSetArg(arg[3],XtNheight,height);    XtSetArg(arg[3],XtNheight,height);
         XtSetArg(arg[4],XtNorientation,XtorientVertical);    XtSetArg(arg[4],XtNorientation,XtorientVertical);
         XtSetArg(arg[5],XtNsensitive,False);    XtSetArg(arg[5],XtNsensitive,False);
         can->ydone =    can->ydone =
                 XtCreateManagedWidget("ydone",scrollbarWidgetClass,frame,arg,6);      XtCreateManagedWidget("ydone",scrollbarWidgetClass,frame,arg,6);
   
         XtSetArg(arg[0],XtNfromVert,can->xdone);    XtSetArg(arg[0],XtNfromVert,can->xdone);
         XtSetArg(arg[1],XtNorientation,XtorientHorizontal);    XtSetArg(arg[1],XtNorientation,XtorientHorizontal);
         XtSetArg(arg[2],XtNborderWidth,0);    XtSetArg(arg[2],XtNborderWidth,0);
         coords = XtCreateManagedWidget("coords",boxWidgetClass,frame,arg,3);    coords = XtCreateManagedWidget("coords",boxWidgetClass,frame,arg,3);
   
         XtSetArg(arg[0],XtNwidth,LABELWIDTH);    XtSetArg(arg[0],XtNwidth,LABELWIDTH);
         can->xcoord = XtCreateManagedWidget("xcoord",labelWidgetClass,coords,arg,1);    can->xcoord = XtCreateManagedWidget("xcoord",labelWidgetClass,coords,arg,1);
         XtSetArg(arg[0],XtNwidth,LABELWIDTH);    XtSetArg(arg[0],XtNwidth,LABELWIDTH);
         can->ycoord = XtCreateManagedWidget("ycoord",labelWidgetClass,coords,arg,1);    can->ycoord = XtCreateManagedWidget("ycoord",labelWidgetClass,coords,arg,1);
   
         XtAddEventHandler(canvas,ButtonPressMask,False,(XtEventHandler)press,can);    XtAddEventHandler(canvas,ButtonPressMask,False,(XtEventHandler)press,can);
         XtAddEventHandler(canvas,ButtonReleaseMask,False,(XtEventHandler)release,can);    XtAddEventHandler(canvas,ButtonReleaseMask,False,(XtEventHandler)release,can);
         XtAddEventHandler(canvas,Button1MotionMask,False,(XtEventHandler)motion,can);    XtAddEventHandler(canvas,Button1MotionMask,False,(XtEventHandler)motion,can);
         XtAddEventHandler(canvas,Button3MotionMask,False,(XtEventHandler)motion,can);    XtAddEventHandler(canvas,Button3MotionMask,False,(XtEventHandler)motion,can);
         XtAddEventHandler(canvas,StructureNotifyMask,False,(XtEventHandler)structure,can);    XtAddEventHandler(canvas,StructureNotifyMask,False,(XtEventHandler)structure,can);
         XtAddEventHandler(canvas,ExposureMask,False,(XtEventHandler)structure,can);    XtAddEventHandler(canvas,ExposureMask,False,(XtEventHandler)structure,can);
   
         if ( can->mode == modeNO(CONPLOT) ) {    if ( can->mode == modeNO(CONPLOT) ) {
                 XtSetArg(arg[0],XtNwidth,LABELWIDTH);      XtSetArg(arg[0],XtNwidth,LABELWIDTH);
                 can->level = XtCreateManagedWidget("level",labelWidgetClass,      can->level = XtCreateManagedWidget("level",labelWidgetClass,
                         commands,arg,1);        commands,arg,1);
   
                 XtSetArg(arg[0],XtNsensitive,True);      XtSetArg(arg[0],XtNsensitive,True);
                 XtSetValues(can->ydone,arg,1);      XtSetValues(can->ydone,arg,1);
                 if ( depth >= 2 ) {      if ( depth >= 2 ) {
                         XtAddCallback(can->ydone,XtNjumpProc,(XtCallbackProc)jumpproc,can);        XtAddCallback(can->ydone,XtNjumpProc,(XtCallbackProc)jumpproc,can);
                         XtAddEventHandler(can->ydone,ButtonReleaseMask,False,(XtEventHandler)lrelease,can);        XtAddEventHandler(can->ydone,ButtonReleaseMask,False,(XtEventHandler)lrelease,can);
                 } else {      } else {
                         XtAddCallback(can->ydone,XtNjumpProc,(XtCallbackProc)jumpproc_m,can);        XtAddCallback(can->ydone,XtNjumpProc,(XtCallbackProc)jumpproc_m,can);
                         XtAddEventHandler(can->ydone,ButtonReleaseMask,False,(XtEventHandler)lrelease_m,can);        XtAddEventHandler(can->ydone,ButtonReleaseMask,False,(XtEventHandler)lrelease_m,can);
                 }      }
         }    }
         if ( can->mode != modeNO(IFPLOT) || !qpcheck((Obj)can->formula) )    if ( can->mode != modeNO(IFPLOT) || !qpcheck((Obj)can->formula) )
                 XtSetSensitive(precise,False);      XtSetSensitive(precise,False);
         XtPopup(can->shell,XtGrabNone);    XtPopup(can->shell,XtGrabNone);
         SetWM_Proto(can->shell);    SetWM_Proto(can->shell);
         window = can->window = XtWindow(canvas);    window = can->window = XtWindow(canvas);
         pix = can->pix = XCreatePixmap(display,window,width,height,depth);    pix = can->pix = XCreatePixmap(display,window,width,height,depth);
         XFillRectangle(display,pix,clearGC,0,0,width,height);    XFillRectangle(display,pix,clearGC,0,0,width,height);
         image = XGetImage(display, can->pix, 0, 0, can->width, can->height,    image = XGetImage(display, can->pix, 0, 0, can->width, can->height,
                 -1, ZPixmap);      -1, ZPixmap);
         BackPixel = XGetPixel(image,0,0);    BackPixel = XGetPixel(image,0,0);
         XDefineCursor(display,window,normalcur);    XDefineCursor(display,window,normalcur);
         XFlush(display);    XFlush(display);
         current_can = can;    current_can = can;
 }  }
   
 void alloc_pixmap(struct canvas *can)  void alloc_pixmap(struct canvas *can)
 {  {
         can->pix = XCreatePixmap(display,can->window,    can->pix = XCreatePixmap(display,can->window,
                 can->width,can->height,depth);      can->width,can->height,depth);
         XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);    XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);
 }  }
   
 static XrmOptionDescRec options[] = {  static XrmOptionDescRec options[] = {
Line 631  static XrmOptionDescRec options[] = {
Line 631  static XrmOptionDescRec options[] = {
   
 static XtResource resources[] = {  static XtResource resources[] = {
 {"upsidedown","UpsideDown",XtRBoolean,sizeof(Boolean),  {"upsidedown","UpsideDown",XtRBoolean,sizeof(Boolean),
         offset(UpsideDown),XtRBoolean,&upsidedown},    offset(UpsideDown),XtRBoolean,&upsidedown},
 {"reverse","Reverse",XtRBoolean,sizeof(Boolean),  {"reverse","Reverse",XtRBoolean,sizeof(Boolean),
         offset(Reverse),XtRBoolean,&reverse},    offset(Reverse),XtRBoolean,&reverse},
 {"foreground","Foreground",XtRString,sizeof(char *),  {"foreground","Foreground",XtRString,sizeof(char *),
         offset(ForeName),XtRString,NULL},    offset(ForeName),XtRString,NULL},
 {"foreground","Foreground",XtRPixel,sizeof(Pixel),  {"foreground","Foreground",XtRPixel,sizeof(Pixel),
         offset(ForePixel),XtRPixel,(XtPointer)&forePixel},    offset(ForePixel),XtRPixel,(XtPointer)&forePixel},
 {"background","Background",XtRString,sizeof(char *),  {"background","Background",XtRString,sizeof(char *),
         offset(BackName),XtRString,NULL},    offset(BackName),XtRString,NULL},
 {"background","Background",XtRPixel,sizeof(Pixel),  {"background","Background",XtRPixel,sizeof(Pixel),
         offset(BackPixel),XtRPixel,(XtPointer)&backPixel},    offset(BackPixel),XtRPixel,(XtPointer)&backPixel},
 {"dash","Dash",XtRString,sizeof(char *),  {"dash","Dash",XtRString,sizeof(char *),
         offset(DashName),XtRString,NULL},    offset(DashName),XtRString,NULL},
 {"dash","Dash",XtRPixel,sizeof(Pixel),  {"dash","Dash",XtRPixel,sizeof(Pixel),
         offset(DashPixel),XtRPixel,(XtPointer)&dashPixel},    offset(DashPixel),XtRPixel,(XtPointer)&dashPixel},
 };  };
   
 static XtActionsRec actions_table[] = {  static XtActionsRec actions_table[] = {
         {"quit",Quit},    {"quit",Quit},
 };  };
   
 static void Quit(Widget w, XEvent *ev, String *params,Cardinal *nparams)  static void Quit(Widget w, XEvent *ev, String *params,Cardinal *nparams)
Line 659  static void Quit(Widget w, XEvent *ev, String *params,
Line 659  static void Quit(Widget w, XEvent *ev, String *params,
   
 int init_plot_display(int argc,char **argv)  int init_plot_display(int argc,char **argv)
 {  {
         int ac;    int ac;
         char **av;    char **av;
         unsigned int tmp;    unsigned int tmp;
   
         for ( ac = argc, av = argv; ac; ac--, av++ )    for ( ac = argc, av = argv; ac; ac--, av++ )
                 if ( !strcmp(*av,"nox") )      if ( !strcmp(*av,"nox") )
                         return 0;        return 0;
                 else if ( index(*av,':') )      else if ( index(*av,':') )
                         dname = *av;        dname = *av;
         XtToolkitInitialize();    XtToolkitInitialize();
         app_con = XtCreateApplicationContext();    app_con = XtCreateApplicationContext();
         XtAppAddActions(app_con,actions_table, XtNumber(actions_table));    XtAppAddActions(app_con,actions_table, XtNumber(actions_table));
         display = XtOpenDisplay(app_con,dname,"plot","Plot",    display = XtOpenDisplay(app_con,dname,"plot","Plot",
                 options,XtNumber(options),&argc,argv);      options,XtNumber(options),&argc,argv);
         if ( !display ) {    if ( !display ) {
                 fprintf(stderr,"Can't open display\n");      fprintf(stderr,"Can't open display\n");
                 return 0;      return 0;
         }    }
         toplevel = XtAppCreateShell(0,"Plot",applicationShellWidgetClass,    toplevel = XtAppCreateShell(0,"Plot",applicationShellWidgetClass,
                 display,0,0);      display,0,0);
   
         forePixel = blackPixel; backPixel = whitePixel;    forePixel = blackPixel; backPixel = whitePixel;
         dashPixel = blackPixel;    dashPixel = blackPixel;
         XtGetApplicationResources(toplevel,&PlotResources,    XtGetApplicationResources(toplevel,&PlotResources,
                 resources,XtNumber(resources),NULL,0);      resources,XtNumber(resources),NULL,0);
         display = XtDisplay(toplevel);    display = XtDisplay(toplevel);
         scrn = DefaultScreen(display);    scrn = DefaultScreen(display);
         depth = DefaultDepth(display,scrn);    depth = DefaultDepth(display,scrn);
         rootwin = RootWindow(display,scrn);    rootwin = RootWindow(display,scrn);
   
         /* for handling DELETE message */    /* for handling DELETE message */
         wm_delete_window = XInternAtom(display,"WM_DELETE_WINDOW",False);    wm_delete_window = XInternAtom(display,"WM_DELETE_WINDOW",False);
         XtOverrideTranslations(toplevel,    XtOverrideTranslations(toplevel,
                 XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));      XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));
   
         if ( reverse ) {    if ( reverse ) {
                 tmp = forePixel; forePixel = backPixel; backPixel = tmp;      tmp = forePixel; forePixel = backPixel; backPixel = tmp;
         }    }
   
         create_gc();    create_gc();
         create_font();    create_font();
         create_cursors();    create_cursors();
         return 1;    return 1;
 }  }
   
 static char *scalefont = "*-8-80-*";  static char *scalefont = "*-8-80-*";
   
 void create_font() {  void create_font() {
         Font sfid;    Font sfid;
   
         sfid = XLoadFont(display,scalefont);    sfid = XLoadFont(display,scalefont);
         sffs = XQueryFont(display,sfid);    sffs = XQueryFont(display,sfid);
         XSetFont(display,scaleGC,sfid);    XSetFont(display,scaleGC,sfid);
 }  }
   
 void create_gc() {  void create_gc() {
         static XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};    static XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};
   
         drawGC = XCreateGC(display,rootwin,0,NULL);    drawGC = XCreateGC(display,rootwin,0,NULL);
         dashGC = XCreateGC(display,rootwin,0,NULL);    dashGC = XCreateGC(display,rootwin,0,NULL);
         hlGC = XCreateGC(display,rootwin,0,NULL);    hlGC = XCreateGC(display,rootwin,0,NULL);
         clearGC = XCreateGC(display,rootwin,0,NULL);    clearGC = XCreateGC(display,rootwin,0,NULL);
         scaleGC = XCreateGC(display,rootwin,0,NULL);    scaleGC = XCreateGC(display,rootwin,0,NULL);
         xorGC = XCreateGC(display,rootwin,0,NULL);    xorGC = XCreateGC(display,rootwin,0,NULL);
         colorGC = XCreateGC(display,rootwin,0,NULL);    colorGC = XCreateGC(display,rootwin,0,NULL);
         cdrawGC = 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,drawGC);
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,dashGC);    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,clearGC);
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,scaleGC);    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,xorGC);
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,colorGC);    XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,colorGC);
         XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,cdrawGC);    XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,cdrawGC);
         XSetForeground(display,drawGC,forePixel);    XSetForeground(display,drawGC,forePixel);
         XSetForeground(display,scaleGC,forePixel);    XSetForeground(display,scaleGC,forePixel);
         XSetForeground(display,clearGC,backPixel);    XSetForeground(display,clearGC,backPixel);
         XSetForeground(display,xorGC,forePixel^backPixel);    XSetForeground(display,xorGC,forePixel^backPixel);
         XSetFunction(display,xorGC,GXxor);    XSetFunction(display,xorGC,GXxor);
         XSetForeground(display,dashGC,dashPixel);    XSetForeground(display,dashGC,dashPixel);
         XSetLineAttributes(display,dashGC,1,LineOnOffDash,CapButt,JoinRound);    XSetLineAttributes(display,dashGC,1,LineOnOffDash,CapButt,JoinRound);
   
         color.red = color.green = color.blue = 0xffff/2;    color.red = color.green = color.blue = 0xffff/2;
         XAllocColor(display,DefaultColormap(display,scrn),&color);    XAllocColor(display,DefaultColormap(display,scrn),&color);
         XSetForeground(display,hlGC,color.pixel);    XSetForeground(display,hlGC,color.pixel);
         color.red = 0xffff; color.green = color.blue = 0;    color.red = 0xffff; color.green = color.blue = 0;
         XAllocColor(display,DefaultColormap(display,scrn),&color);    XAllocColor(display,DefaultColormap(display,scrn),&color);
         XSetForeground(display,colorGC,color.pixel);    XSetForeground(display,colorGC,color.pixel);
 }  }
   
 void set_drawcolor(unsigned int c)  void set_drawcolor(unsigned int c)
 {  {
         XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};    XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};
   
         color.red = (c&0xff0000)>>8;    color.red = (c&0xff0000)>>8;
         color.green = (c&0xff00);    color.green = (c&0xff00);
         color.blue = (c&0xff)<<8;    color.blue = (c&0xff)<<8;
         XAllocColor(display,DefaultColormap(display,scrn),&color);    XAllocColor(display,DefaultColormap(display,scrn),&color);
         XSetForeground(display,cdrawGC,color.pixel);    XSetForeground(display,cdrawGC,color.pixel);
 }  }
   
 void create_cursors() {  void create_cursors() {
         static XColor fg = {0, 0x0, 0x0, 0x0,DoRed|DoGreen|DoBlue,0};    static XColor fg = {0, 0x0, 0x0, 0x0,DoRed|DoGreen|DoBlue,0};
         static XColor bg = {0, 0xffff, 0xffff, 0xffff,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),&fg);
         XAllocColor(display,DefaultColormap(display,scrn),&bg);    XAllocColor(display,DefaultColormap(display,scrn),&bg);
         normalcur = create_cursor(h_bits,h_m_bits,h_width,h_height,    normalcur = create_cursor(h_bits,h_m_bits,h_width,h_height,
                 h_x_hot,h_y_hot,&fg,&bg);      h_x_hot,h_y_hot,&fg,&bg);
         runningcur = create_cursor(ht_bits,ht_m_bits,ht_width,ht_height,    runningcur = create_cursor(ht_bits,ht_m_bits,ht_width,ht_height,
                 ht_width/2,ht_height/2,&fg,&bg);      ht_width/2,ht_height/2,&fg,&bg);
         errorcur = create_cursor(m_bits,m_m_bits,m_width,m_height,    errorcur = create_cursor(m_bits,m_m_bits,m_width,m_height,
                 m_width/2,m_height/2,&fg,&bg);      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)  Cursor create_cursor(char *image,char *mask,int width,int height,int xhot,int yhot,XColor *fg,XColor *bg)
 {  {
         Pixmap ipix,mpix;    Pixmap ipix,mpix;
   
         ipix = XCreateBitmapFromData(display,rootwin,image,width,height);    ipix = XCreateBitmapFromData(display,rootwin,image,width,height);
         mpix = XCreateBitmapFromData(display,rootwin,mask,width,height);    mpix = XCreateBitmapFromData(display,rootwin,mask,width,height);
         return XCreatePixmapCursor(display,ipix,mpix,fg,bg,xhot,yhot);    return XCreatePixmapCursor(display,ipix,mpix,fg,bg,xhot,yhot);
 }  }
   
 void copy_to_canvas(struct canvas *can)  void copy_to_canvas(struct canvas *can)
 {  {
         if ( display ) {    if ( display ) {
                 if ( can->color ) {      if ( can->color ) {
                         set_drawcolor(can->color);        set_drawcolor(can->color);
                         XCopyArea(display,can->pix,can->window,        XCopyArea(display,can->pix,can->window,
                                 cdrawGC,0,0,can->width,can->height,0,0);          cdrawGC,0,0,can->width,can->height,0,0);
                 } else      } else
                         XCopyArea(display,can->pix,can->window,        XCopyArea(display,can->pix,can->window,
                                 drawGC,0,0,can->width,can->height,0,0);          drawGC,0,0,can->width,can->height,0,0);
                 pline(display,can,can->window);      pline(display,can,can->window);
                 XFlush(display);      XFlush(display);
         }    }
 }  }
   
 void copy_subimage(struct canvas *subcan,struct canvas *can,XPoint pos)  void copy_subimage(struct canvas *subcan,struct canvas *can,XPoint pos)
 {  {
         if ( display ) {    if ( display ) {
                 XCopyArea(display,subcan->pix,can->pix,      XCopyArea(display,subcan->pix,can->pix,
                         drawGC,0,0,subcan->width,subcan->height,pos.x,pos.y);        drawGC,0,0,subcan->width,subcan->height,pos.x,pos.y);
                 XFlush(display);      XFlush(display);
         }    }
 }  }
   
 #include <signal.h>  #include <signal.h>
 #include <fcntl.h>  #include <fcntl.h>
   
 void set_selection() {  void set_selection() {
         if ( current_can ) {    if ( current_can ) {
                 XSelectInput(display,current_can->window,0);      XSelectInput(display,current_can->window,0);
                 XFlush(display);      XFlush(display);
         }    }
 }  }
   
 void reset_selection() {  void reset_selection() {
         if ( current_can ) {    if ( current_can ) {
                 XSelectInput(display,current_can->window,NormalSelection);      XSelectInput(display,current_can->window,NormalSelection);
                 XFlush(display);      XFlush(display);
         }    }
 }  }
   
 void set_busy(struct canvas *can)  void set_busy(struct canvas *can)
 {  {
         busy = 1;    busy = 1;
         XtSetSensitive(can->wideb,False);    XtSetSensitive(can->wideb,False);
         XtSetSensitive(can->preciseb,False);    XtSetSensitive(can->preciseb,False);
         XtSetSensitive(can->noaxisb,False);    XtSetSensitive(can->noaxisb,False);
         XFlush(display);    XFlush(display);
 }  }
   
 void reset_busy(struct canvas *can)  void reset_busy(struct canvas *can)
 {  {
         busy = 0;    busy = 0;
         if ( can->window ) {    if ( can->window ) {
                 XtSetSensitive(can->wideb,True);      XtSetSensitive(can->wideb,True);
                 XtSetSensitive(can->noaxisb,True);      XtSetSensitive(can->noaxisb,True);
                 if ( can->mode == modeNO(IFPLOT) && qpcheck((Obj)can->formula) )      if ( can->mode == modeNO(IFPLOT) && qpcheck((Obj)can->formula) )
                         XtSetSensitive(can->preciseb,True);        XtSetSensitive(can->preciseb,True);
                 XFlush(display);      XFlush(display);
         }    }
 }  }
   
 void reset_current_computation()  void reset_current_computation()
 {  {
         if ( current_can ) {    if ( current_can ) {
                 reset_selection(); reset_busy(current_can);      reset_selection(); reset_busy(current_can);
                 define_cursor(current_can->window,normalcur);      define_cursor(current_can->window,normalcur);
         }    }
 }  }
   
 static struct canvas *Can;  static struct canvas *Can;
Line 879  static Widget create_printing_method_bar(Widget parent
Line 879  static Widget create_printing_method_bar(Widget parent
   int i,n;    int i,n;
   Arg wargs[1];    Arg wargs[1];
   panel = XtCreateManagedWidget("printing methods",panedWidgetClass,    panel = XtCreateManagedWidget("printing methods",panedWidgetClass,
                                                                 parent,NULL,0);                  parent,NULL,0);
   for (i=0; i<N_printing_methods; i++) {    for (i=0; i<N_printing_methods; i++) {
         button = XtCreateManagedWidget(Printing_methods[i],menuButtonWidgetClass,    button = XtCreateManagedWidget(Printing_methods[i],menuButtonWidgetClass,
                                                                    panel,NULL,0);                     panel,NULL,0);
         fprintf(stderr,"button=%x\n",(int) button);    fprintf(stderr,"button=%x\n",(int) button);
         XtAddCallback(button,XtNcallback,set_printing_method,(XtPointer) i);    XtAddCallback(button,XtNcallback,set_printing_method,(XtPointer) i);
   }    }
   return(panel);    return(panel);
 }  }
Line 893  static Widget create_printing_method_bar(Widget parent
Line 893  static Widget create_printing_method_bar(Widget parent
   
 static void print_canvas(Widget w,struct canvas *can,XtPointer calldata)  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;
   
         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",(XtCallbackProc)output_to_printer,w);    XawDialogAddButton(fdialog,"print",(XtCallbackProc)output_to_printer,w);
         XawDialogAddButton(fdialog,"output PS file",(XtCallbackProc)print_canvas_to_file,w);    XawDialogAddButton(fdialog,"output PS file",(XtCallbackProc)print_canvas_to_file,w);
         XawDialogAddButton(fdialog,"method",(XtCallbackProc)printing_method,w);    XawDialogAddButton(fdialog,"method",(XtCallbackProc)printing_method,w);
         XawDialogAddButton(fdialog,"dismiss",(XtCallbackProc)cancel_output_to_file,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);    SetWM_Proto(fshell);
 }  }
   
 static void set_printing_method(Widget w,XtPointer number,XtPointer call_data)  static void set_printing_method(Widget w,XtPointer number,XtPointer call_data)
 {  {
         Widget shell;    Widget shell;
         extern int PrintingMethod;    extern int PrintingMethod;
         PrintingMethod = (int) number;    PrintingMethod = (int) number;
         fprintf(stderr,"PrintingMethod=%d\n",(int)number);    fprintf(stderr,"PrintingMethod=%d\n",(int)number);
         shell = XtParent(XtParent(w));    shell = XtParent(XtParent(w));
         XtPopdown(shell); XtDestroyWidget(shell);    XtPopdown(shell); XtDestroyWidget(shell);
 }  }
   
 static void printing_method(Widget w,struct canvas *can,XtPointer calldata)  static void printing_method(Widget w,struct canvas *can,XtPointer calldata)
 {  {
         Arg arg[10];    Arg arg[10];
         int i,n;    int i,n;
         Widget fshell,fdialog;    Widget fshell,fdialog;
         extern struct canvas *Can;    extern struct canvas *Can;
         extern int PrintingMethod;    extern int PrintingMethod;
   
         w = W;    w = W;
         can = Can;    can = Can;
         create_popup(can->shell,"Printing method",Printing_methods[PrintingMethod],    create_popup(can->shell,"Printing method",Printing_methods[PrintingMethod],
                         &fshell,&fdialog);        &fshell,&fdialog);
         n = 0;    n = 0;
         XtSetArg(arg[n], XtNlabel, "Method: "); n++;    XtSetArg(arg[n], XtNlabel, "Method: "); n++;
         XtSetArg(arg[n], XtNvalue, Printing_methods[PrintingMethod]); n++;    XtSetArg(arg[n], XtNvalue, Printing_methods[PrintingMethod]); n++;
         XtSetValues(fdialog,arg,n);    XtSetValues(fdialog,arg,n);
         for (i=0; i<N_printing_methods; i++) {    for (i=0; i<N_printing_methods; i++) {
                 XawDialogAddButton(      XawDialogAddButton(
                         fdialog,Printing_methods[i],set_printing_method,(XtPointer) i);        fdialog,Printing_methods[i],set_printing_method,(XtPointer) i);
         }    }
         XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);    XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
         SetWM_Proto(fshell);    SetWM_Proto(fshell);
 }  }
   
 static void print_canvas_to_file(Widget w,struct canvas *can,XtPointer calldata)  static void print_canvas_to_file(Widget w,struct canvas *can,XtPointer calldata)
 {  {
         Arg arg[10];    Arg arg[10];
         int n;    int n;
         static char *psfile = NULL;    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;    extern char *Fname;
   
         w = W;    w = W;
         can = Can;    can = Can;
         if (psfile == NULL || Fname == NULL) psfile = "ox_plot.eps";    if (psfile == NULL || Fname == NULL) psfile = "ox_plot.eps";
         else psfile = Fname;    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++;
         XtSetArg(arg[n], XtNvalue, psfile); n++;    XtSetArg(arg[n], XtNvalue, psfile); n++;
         XtSetValues(fdialog,arg,n);    XtSetValues(fdialog,arg,n);
         XawDialogAddButton(fdialog,"output to file",output_to_file,w);    XawDialogAddButton(fdialog,"output to file",output_to_file,w);
         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);    SetWM_Proto(fshell);
 }  }
   
 static void output_to_printer(Widget w,struct canvas *can,XtPointer calldata)  static void output_to_printer(Widget w,struct canvas *can,XtPointer calldata)
 {  {
         Arg arg[10];    Arg arg[10];
         int n;    int n;
         static char *psfile = NULL;    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;    extern char *PrinterName;
   
         w = W;    w = W;
         can = Can;    can = Can;
         if (psfile  == NULL || PrinterName == NULL) psfile = "lp";    if (psfile  == NULL || PrinterName == NULL) psfile = "lp";
         else psfile = PrinterName;    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++;
         XtSetArg(arg[n], XtNvalue, psfile); n++;    XtSetArg(arg[n], XtNvalue, psfile); n++;
         XtSetValues(fdialog,arg,n);    XtSetValues(fdialog,arg,n);
         XawDialogAddButton(fdialog,"output to PS printer",output_to_ps_printer,w);    XawDialogAddButton(fdialog,"output to PS printer",output_to_ps_printer,w);
         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);    SetWM_Proto(fshell);
 }  }
   
 static void cancel_output_to_file(Widget w,XtPointer fbutton,XtPointer call)  static void cancel_output_to_file(Widget w,XtPointer fbutton,XtPointer 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(Widget w,XtPointer fbutton,XtPointer call)  static void output_to_file(Widget w,XtPointer fbutton,XtPointer call)
 {  {
         char *fname;    char *fname;
         FILE *fp;    FILE *fp;
         int i;    int i;
   
         extern struct canvas *Can;    extern struct canvas *Can;
         extern Widget PrintDialog;    extern Widget PrintDialog;
         extern int PrintingMethod;    extern int PrintingMethod;
         Widget shell = XtParent(XtParent(w));    Widget shell = XtParent(XtParent(w));
   
         if (PrintingMethod == PRINTING_METHOD_BITMAP) {    if (PrintingMethod == PRINTING_METHOD_BITMAP) {
                 TODO;      TODO;
         }else{    }else{
                 method_is_not_available();      method_is_not_available();
                 XtPopdown(shell); XtDestroyWidget(shell);      XtPopdown(shell); XtDestroyWidget(shell);
                 XtSetSensitive(fbutton,True);      XtSetSensitive(fbutton,True);
                 return;      return;
         }    }
   
         fname = XawDialogGetValueString(PrintDialog);    fname = XawDialogGetValueString(PrintDialog);
         Fname = (char *)malloc(sizeof(char)*strlen(fname)+1);    Fname = (char *)malloc(sizeof(char)*strlen(fname)+1);
         strcpy(Fname,fname);    strcpy(Fname,fname);
         for (i=0; i<strlen(Fname); i++) {    for (i=0; i<strlen(Fname); i++) {
                 if (Fname[i] == 0xd || Fname[i] == 0xa) {      if (Fname[i] == 0xd || Fname[i] == 0xa) {
                         Fname[i] = 0; break;        Fname[i] = 0; break;
                 }      }
         }    }
         fprintf(stderr,"fname=%s\n",Fname); fflush(NULL);    fprintf(stderr,"fname=%s\n",Fname); 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);
         }    }
   
         XtPopdown(shell); XtDestroyWidget(shell);    XtPopdown(shell); XtDestroyWidget(shell);
         XtSetSensitive(fbutton,True);    XtSetSensitive(fbutton,True);
 }  }
   
 static void output_to_ps_printer(Widget w, XtPointer fbutton, XtPointer call)  static void output_to_ps_printer(Widget w, XtPointer fbutton, XtPointer call)
 {  {
         char *printerName;    char *printerName;
         FILE *fp;    FILE *fp;
         extern struct canvas *Can;    extern struct canvas *Can;
         extern Widget PrintDialog_lp;    extern Widget PrintDialog_lp;
         char fname[256];    char fname[256];
         char cmd[512];    char cmd[512];
         static int id = 0;    static int id = 0;
         int i;    int i;
         Widget shell = XtParent(XtParent(w));    Widget shell = XtParent(XtParent(w));
   
         if (PrintingMethod == PRINTING_METHOD_BITMAP) {    if (PrintingMethod == PRINTING_METHOD_BITMAP) {
         }else{    }else{
                 method_is_not_available();      method_is_not_available();
                 XtPopdown(shell); XtDestroyWidget(shell);      XtPopdown(shell); XtDestroyWidget(shell);
                 XtSetSensitive(fbutton,True);      XtSetSensitive(fbutton,True);
                 return;      return;
         }    }
   
         sprintf(fname,"/tmp/ox_plot_%d_%d.eps",(int) getpid(),id++);    sprintf(fname,"/tmp/ox_plot_%d_%d.eps",(int) getpid(),id++);
   
         printerName = XawDialogGetValueString(PrintDialog_lp);    printerName = XawDialogGetValueString(PrintDialog_lp);
         PrinterName = (char *)malloc(sizeof(char)*strlen(printerName)+1);    PrinterName = (char *)malloc(sizeof(char)*strlen(printerName)+1);
         strcpy(PrinterName,printerName);    strcpy(PrinterName,printerName);
         for (i=0; i<strlen(PrinterName); i++) {    for (i=0; i<strlen(PrinterName); i++) {
                 if (PrinterName[i] == 0xd || PrinterName[i] == 0xa) {      if (PrinterName[i] == 0xd || PrinterName[i] == 0xa) {
                 PrinterName[i] = 0; break;        PrinterName[i] = 0; break;
                 }      }
         }    }
         fprintf(stderr,"printerName=%s\n",PrinterName); fflush(NULL);    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);
         XtPopdown(shell); XtDestroyWidget(shell);    XtPopdown(shell); XtDestroyWidget(shell);
         XtSetSensitive(fbutton,True);    XtSetSensitive(fbutton,True);
 }  }
   
 /* test sequence  /* test sequence
Line 1098  static void output_to_ps_printer(Widget w, XtPointer f
Line 1098  static void output_to_ps_printer(Widget w, XtPointer f
    */     */
 static void generate_psfile(struct canvas *can, FILE *fp)  static void generate_psfile(struct canvas *can, FILE *fp)
 {  {
         XImage *image;    XImage *image;
         int color[1];    int color[1];
         extern int PrintingMethod;    extern int PrintingMethod;
   
         fprintf(stderr,"generate_psfile\n");    fprintf(stderr,"generate_psfile\n");
         if (PrintingMethod == PRINTING_METHOD_BITMAP) {    if (PrintingMethod == PRINTING_METHOD_BITMAP) {
                 if ( display ) {      if ( display ) {
                         fprintf(stderr,"generate_psfile: output to a file.\n");        fprintf(stderr,"generate_psfile: output to a file.\n");
                         image = XGetImage(display,can->pix,        image = XGetImage(display,can->pix,
                                                 0,0,can->width,can->height,-1,ZPixmap);              0,0,can->width,can->height,-1,ZPixmap);
                         color[0] = 0; /* black line */        color[0] = 0; /* black line */
                         PSFromImage(fp,image,can);        PSFromImage(fp,image,can);
                 }else{      }else{
                 fprintf(stderr,"Cannot print on this system\n");      fprintf(stderr,"Cannot print on this system\n");
                 }      }
         }else{    }else{
                 method_is_not_available();      method_is_not_available();
         }    }
         fflush(NULL);    fflush(NULL);
 }  }
   
 static void method_is_not_available() {  static void method_is_not_available() {
Line 1132  static void method_is_not_available() {
Line 1132  static void method_is_not_available() {
   
 void clear_pixmap(struct canvas *can)  void clear_pixmap(struct canvas *can)
 {  {
         XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);    XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);
         XFlush(display);    XFlush(display);
 }  }
   
 #if 0  #if 0
Line 1235  static int getColorSizeOfImageForPS(int xsize,int ysiz
Line 1235  static int getColorSizeOfImageForPS(int xsize,int ysiz
   
   table = (struct xcolorForPS *)MALLOC((size+1)*sizeof(struct xcolorForPS));    table = (struct xcolorForPS *)MALLOC((size+1)*sizeof(struct xcolorForPS));
   if (table == NULL) {    if (table == NULL) {
         fprintf(stderr,"No more memory in getColorSizeOfImageForPS.\n");    fprintf(stderr,"No more memory in getColorSizeOfImageForPS.\n");
         return 0;    return 0;
   }    }
   /* Set rgb values standing for the pixel values.    /* Set rgb values standing for the pixel values.
   */    */
   if (setTableOfxcolorForPS(&root,table,0,size) != size) {    if (setTableOfxcolorForPS(&root,table,0,size) != size) {
         warning(Can,"internal error.");    warning(Can,"internal error.");
         return 0;    return 0;
   }    }
   
   screen = DefaultScreen(display);    screen = DefaultScreen(display);
   cm = DefaultColormap(display,screen);    cm = DefaultColormap(display,screen);
   /*  BUG: it does not work.    /*  BUG: it does not work.
   if (!XGetStandardColormap(display,RootWindow(display,DefaultScreen(display)),&scm,XA_RGB_DEFAULT_MAP)) {    if (!XGetStandardColormap(display,RootWindow(display,DefaultScreen(display)),&scm,XA_RGB_DEFAULT_MAP)) {
         warning(Can,"failed to open the X Standard Colormap.");    warning(Can,"failed to open the X Standard Colormap.");
         scm.red_max = 0xffff;    scm.red_max = 0xffff;
         scm.green_max = 0xffff;    scm.green_max = 0xffff;
         scm.blue_max = 0xffff;    scm.blue_max = 0xffff;
   }    }
   */    */
   /* Set by hand. */    /* Set by hand. */
Legend:
Removed from v.1.34  
changed lines
  Added in v.1.35
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>