[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.29

version 1.4, 2000/10/14 07:43:52 version 1.29, 2007/01/30 03:25:52
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.28 2007/01/30 00:28:26 noro 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);
   
   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);
   }
   
   static void quit(Widget w, XEvent *ev, String *params,Cardinal *nparams)
   {
       XBell(display,0);
   }
   
   /* 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)
   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;
   
Line 72  static struct PlotResources {
Line 114  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 124  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)
Line 147  XButtonEvent *ev;
Line 193  XButtonEvent *ev;
                 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 != MODE_INTERACTIVE
                           && can->mode != MODE_POLARPLOT) {
                                 if ( can->mode == MODE_PLOT )                                  if ( can->mode == MODE_PLOT )
                                         plot_resize(can,spos,e);                                          plot_resize(can,spos,e);
                                 else                                  else
Line 335  search_active_canvas()
Line 383  search_active_canvas()
         return -1;          return -1;
 }  }
   
   void popup_canvas(index)
 #define PRINT_XOFFSET   100  
 #define PRINT_YOFFSET   100  
 static struct canvas *Can;  
 /* void print_canvas(Widget w,struct canvas *can, XtPointer calldata); */  
 static void output_to_file(Widget , XtPointer, XtPointer );  
 static void output_to_ps_printer(Widget , XtPointer, XtPointer );  
 static void cancel_output_to_file(Widget , XtPointer,XtPointer);  
 static void generate_psfile(struct canvas *can, FILE *fp);  
 static Widget PrintDialog;  
 static Widget PrintDialog_lp;  
 static Widget W;  
   
 static void print_canvas(w,can,calldata)  
          Widget w;  
          struct canvas *can;  
          XtPointer calldata;  
 {  {
   Widget fshell,fdialog;          clear_pixmap(canvas[index]);
   extern struct canvas *Can;          XtPopup(canvas[index]->shell,XtGrabNone);
   extern Widget W;          copy_to_canvas(canvas[index]);
   static void output_to_printer();  
   static void print_canvas_to_file();  
   
   W = w;  
   Can = can;  
   create_popup(can->shell,"Print/Output PS file","",&fshell,&fdialog);  
   XawDialogAddButton(fdialog,"print",output_to_printer,w);  
   XawDialogAddButton(fdialog,"Output PS file",print_canvas_to_file,w);  
   XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);  
   XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);  
 }  }
 static void print_canvas_to_file(w,can,calldata)  
          Widget w;  
          struct canvas *can;  
          XtPointer calldata;  
 {  
   FILE *fp;  
   Arg arg[10];  
   int n;  
   char psfile[50];  
   Widget fshell,fdialog;  
   extern struct canvas *Can;  
   extern Widget PrintDialog;  
   
   w = W;  
   can = Can;  
   strcpy(psfile,"ox_plot.eps");  
   create_popup(can->shell,"Output as PS file",psfile,&fshell,&fdialog);  
   n = 0;  
   XtSetArg(arg[n], XtNlabel, "File : "); n++;  
   XtSetArg(arg[n], XtNvalue, psfile); n++;  
   XtSetValues(fdialog,arg,n);  
   XawDialogAddButton(fdialog,"output to file",output_to_file,w);  
   XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);  
   PrintDialog = fdialog;  
   XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);  
 }  
 static void output_to_printer(w,can,calldata)  
          Widget w;  
          struct canvas *can;  
          XtPointer calldata;  
 {  
   FILE *fp;  
   Arg arg[10];  
   int n;  
   char psfile[50];  
   Widget fshell,fdialog;  
   extern struct canvas *Can;  
   extern Widget PrintDialog_lp;  
   
   w = W;  
   can = Can;  
   strcpy(psfile,"xerox");  
   create_popup(can->shell,"Output PS file to printer",psfile,&fshell,&fdialog);  
   n = 0;  
   XtSetArg(arg[n], XtNlabel, "PS Printer Name : "); n++;  
   XtSetArg(arg[n], XtNvalue, psfile); n++;  
   XtSetValues(fdialog,arg,n);  
   XawDialogAddButton(fdialog,"output to PS printer",output_to_ps_printer,w);  
   XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);  
   PrintDialog_lp = fdialog;  
   XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);  
 }  
   
 static void cancel_output_to_file(w,fbutton,call)  
          Widget w;  
          XtPointer fbutton, call;  
 {  
   Widget shell = XtParent(XtParent(w));  
   XtPopdown(shell); XtDestroyWidget(shell);  
   XtSetSensitive(fbutton,True);  
 }  
   
 static void output_to_file(w,fbutton,call)  
          Widget w;  
          XtPointer fbutton, call;  
 {  
   char *fname;  
   FILE *fp;  
   extern struct canvas *Can;  
   extern Widget PrintDialog;  
   Widget shell = XtParent(XtParent(w));  
   
   fname = XawDialogGetValueString(PrintDialog);  
   fprintf(stderr,"fname=%s\n",fname); fflush(NULL);  
   fp = fopen(fname,"w");  
   if (fp == NULL) {  
         warning(Can,"Could not open the output file.");  
   }else{  
         generate_psfile(Can,fp);  
         fclose(fp);  
   }  
   
   XtPopdown(shell); XtDestroyWidget(shell);  
   XtSetSensitive(fbutton,True);  
 }  
   
 static void output_to_ps_printer(w,fbutton,call)  
          Widget w;  
          XtPointer fbutton, call;  
 {  
   char *printerName;  
   FILE *fp;  
   extern struct canvas *Can;  
   extern Widget PrintDialog_lp;  
   char fname[256];  
   char cmd[512];  
   static int id = 0;  
   Widget shell = XtParent(XtParent(w));  
   
   sprintf(fname,"/tmp/ox_plot_%d.eps",(int) getpid(),id++);  
   
   printerName = XawDialogGetValueString(PrintDialog_lp);  
   fprintf(stderr,"printerName=%s\n",printerName); fflush(NULL);  
   fp = fopen(fname,"w");  
   if (fp == NULL) {  
         warning(Can,"Could not open the output file.");  
   }else{  
         generate_psfile(Can,fp);  
         fclose(fp);  
   }  
   
   sprintf(cmd,"lpr -P%s %s",printerName,fname);  
   if (system(cmd)) {  
         warning(Can,"Unknown printer?");  
   }  
   sprintf(cmd,"rm -f %s",fname);  
   system(cmd);  
   XtPopdown(shell); XtDestroyWidget(shell);  
   XtSetSensitive(fbutton,True);  
 }  
   
   
 /* test sequence  
    ox_launch(0,"ox_plot");  
    ifplot(x^2-y^3);  
    drawcircle(0,0,100,0,0);  
    */  
 static void generate_psfile(can,fp)  
          struct canvas *can;  
          FILE *fp;  
 {  
   int x,y;  
   XImage *image;  
   int color;  
   fprintf(stderr,"generate_psfile\n");  
   if ( display ) {  
         fprintf(stderr,"generate_psfile: output to a file.\n");  
         fprintf(fp,"%%!\n");  
         fprintf(fp,"%%%%BoundingBox: %d %d %d %d \n",PRINT_XOFFSET,PRINT_YOFFSET,  
                         PRINT_XOFFSET+can->width+1,PRINT_YOFFSET+can->height+1);  
         fprintf(fp,"%%This is generated by ifplot\n");  
     fprintf(fp,"/ifplot_putpixel { /oxcolor 2 1 roll def  \n");  
         fprintf(fp,"    /yyy 2 1 roll def /xxx 2 1 roll def \n");  
         fprintf(fp,"    gsave newpath xxx yyy .5 0 360 arc \n");  
     fprintf(fp,"    .3 oxcolor .04 mul add setgray  fill grestore \n");  
         fprintf(fp,"} def \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{  
         fprintf(stderr,"Cannot print on this system\n");  
   }  
   fflush(NULL);  
 }  
   
 void destroy_canvas(w,can,calldata)  void destroy_canvas(w,can,calldata)
 Widget w;  Widget w;
 struct canvas *can;  struct canvas *can;
 XtPointer calldata;  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] )
                   XtDestroyWidget(closed_canvas[can->index]->shell);
           closed_canvas[can->index] = can;
         canvas[can->index] = 0;          canvas[can->index] = 0;
 }  }
   
Line 653  char *s;
Line 512  char *s;
         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);
 }  }
   
 void popdown_warning(w,client,call)  void popdown_warning(w,client,call)
Line 675  XtPointer calldata;
Line 535  XtPointer calldata;
         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);
 }  }
   
 void popdown_formula(w,fbutton,call)  void popdown_formula(w,fbutton,call)
Line 700  struct canvas *can;
Line 561  struct canvas *can;
         Arg arg[6];          Arg arg[6];
         char buf[BUFSIZ];          char buf[BUFSIZ];
   
           XImage *image;
   
         width = can->width; height = can->height;          width = can->width; height = can->height;
   
         sprintf(buf,"%s : %d/%d", can->wname?can->wname:"Plot",          sprintf(buf,"%s : %d", can->wname?can->wname:"Plot",can->index);
                 remotes,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);
Line 795  struct canvas *can;
Line 657  struct canvas *can;
         if ( can->mode != MODE_IFPLOT || !qpcheck((Obj)can->formula) )          if ( can->mode != MODE_IFPLOT || !qpcheck((Obj)can->formula) )
                 XtSetSensitive(precise,False);                  XtSetSensitive(precise,False);
         XtPopup(can->shell,XtGrabNone);          XtPopup(can->shell,XtGrabNone);
           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,
                   -1, ZPixmap);
           BackPixel = XGetPixel(image,0,0);
         XDefineCursor(display,window,normalcur);          XDefineCursor(display,window,normalcur);
         XFlush(display);          XFlush(display);
         current_can = can;          current_can = can;
Line 813  struct canvas *can;
Line 678  struct canvas *can;
 }  }
   
 static XrmOptionDescRec options[] = {  static XrmOptionDescRec options[] = {
   {"-upsidedown","*upsidedown",XrmoptionNoArg,"on"},
 {"-reverse","*reverse",XrmoptionNoArg,"on"},  {"-reverse","*reverse",XrmoptionNoArg,"on"},
 {"-fg","*foreground",XrmoptionSepArg,NULL},  {"-fg","*foreground",XrmoptionSepArg,NULL},
 {"-bg","*background",XrmoptionSepArg,NULL},  {"-bg","*background",XrmoptionSepArg,NULL},
Line 821  static XrmOptionDescRec options[] = {
Line 687  static XrmOptionDescRec options[] = {
 #define offset(name) XtOffset(struct PlotResources *,name)  #define offset(name) XtOffset(struct PlotResources *,name)
   
 static XtResource resources[] = {  static XtResource resources[] = {
   {"upsidedown","UpsideDown",XtRBoolean,sizeof(Boolean),
           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 *),
Line 837  static XtResource resources[] = {
Line 705  static XtResource resources[] = {
         offset(DashPixel),XtRPixel,(XtPointer)&dashPixel},          offset(DashPixel),XtRPixel,(XtPointer)&dashPixel},
 };  };
   
 init_plot_display(argc,argv)  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(argc,argv)
 int argc;  int argc;
 char **argv;  char **argv;
 {  {
Line 846  char **argv;
Line 723  char **argv;
         unsigned int tmp;          unsigned int tmp;
   
         for ( ac = argc, av = argv; ac; ac--, av++ )          for ( ac = argc, av = argv; ac; ac--, av++ )
                 if ( index(*av,':') )                  if ( !strcmp(*av,"nox") )
                           return 0;
                   else if ( index(*av,':') )
                         dname = *av;                          dname = *av;
         XtToolkitInitialize();          XtToolkitInitialize();
         app_con = XtCreateApplicationContext();          app_con = XtCreateApplicationContext();
           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");
                 exit(1);                  return 0;
         }          }
         toplevel = XtAppCreateShell(0,"Plot",applicationShellWidgetClass,          toplevel = XtAppCreateShell(0,"Plot",applicationShellWidgetClass,
                 display,0,0);                  display,0,0);
Line 868  char **argv;
Line 748  char **argv;
         depth = DefaultDepth(display,scrn);          depth = DefaultDepth(display,scrn);
         rootwin = RootWindow(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 ) {          if ( reverse ) {
                 tmp = forePixel; forePixel = backPixel; backPixel = tmp;                  tmp = forePixel; forePixel = backPixel; backPixel = tmp;
         }          }
Line 875  char **argv;
Line 760  char **argv;
         create_gc();          create_gc();
         create_font();          create_font();
         create_cursors();          create_cursors();
           return 1;
 }  }
   
 static char *scalefont = "*-8-80-*";  static char *scalefont = "*-8-80-*";
Line 898  create_gc() {
Line 784  create_gc() {
         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);
         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);
         XSetForeground(display,drawGC,forePixel);          XSetForeground(display,drawGC,forePixel);
         XSetForeground(display,scaleGC,forePixel);          XSetForeground(display,scaleGC,forePixel);
         XSetForeground(display,clearGC,backPixel);          XSetForeground(display,clearGC,backPixel);
Line 920  create_gc() {
Line 808  create_gc() {
         XSetForeground(display,colorGC,color.pixel);          XSetForeground(display,colorGC,color.pixel);
 }  }
   
   set_drawcolor(c)
   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);
   }
   
 create_cursors() {  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};
Line 950  copy_to_canvas(can)
Line 850  copy_to_canvas(can)
 struct canvas *can;  struct canvas *can;
 {  {
         if ( display ) {          if ( display ) {
                 XCopyArea(display,can->pix,can->window,                  if ( can->color ) {
                         drawGC,0,0,can->width,can->height,0,0);                          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);                  pline(display,can,can->window);
                 XFlush(display);                  XFlush(display);
         }          }
Line 1014  reset_current_computation()
Line 919  reset_current_computation()
                 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;
   /* void print_canvas(Widget w,struct canvas *can, XtPointer calldata); */
   static void output_to_file(Widget , XtPointer, XtPointer );
   static void output_to_ps_printer(Widget , XtPointer, XtPointer );
   static void cancel_output_to_file(Widget , XtPointer,XtPointer);
   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_lp;
   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 Widget create_printing_method_bar(Widget parent) {
     Widget panel, button;
     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(w,can,calldata)
            Widget w;
            struct canvas *can;
            XtPointer calldata;
   {
           Widget fshell,fdialog;
           extern struct canvas *Can;
           extern Widget W;
           Widget entry;
           int i;
           Arg arg[1];
   
           W = w;
           Can = can;
           create_popup(can->shell,"Print/Output PS file","",&fshell,&fdialog);
           XawDialogAddButton(fdialog,"print",output_to_printer,w);
           XawDialogAddButton(fdialog,"output PS file",print_canvas_to_file,w);
           XawDialogAddButton(fdialog,"method",printing_method,w);
           XawDialogAddButton(fdialog,"dismiss",cancel_output_to_file,w);
           XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
           SetWM_Proto(fshell);
   }
   
   static void set_printing_method(Widget w,XtPointer number,XtPointer call_data)
   {
           Widget shell;
           extern int PrintingMethod;
           PrintingMethod = (int) number;
           fprintf(stderr,"PrintingMethod=%d\n",number);
           shell = XtParent(XtParent(w));
           XtPopdown(shell); XtDestroyWidget(shell);
   }
   
   static void printing_method(w,can,calldata)
           Widget w;
           struct canvas *can;
           XtPointer calldata;
   {
           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(w,can,calldata)
           Widget w;
           struct canvas *can;
           XtPointer calldata;
   {
           FILE *fp;
           Arg arg[10];
           int n;
           static char *psfile = NULL;
           Widget fshell,fdialog;
           extern struct canvas *Can;
           extern Widget PrintDialog;
           extern char *Fname;
   
           w = W;
           can = Can;
           if (psfile == NULL || Fname == NULL) psfile = "ox_plot.eps";
           else psfile = Fname;
           create_popup(can->shell,"Output as PS file",psfile,&fshell,&fdialog);
           n = 0;
           XtSetArg(arg[n], XtNlabel, "File : "); n++;
           XtSetArg(arg[n], XtNvalue, psfile); n++;
           XtSetValues(fdialog,arg,n);
           XawDialogAddButton(fdialog,"output to file",output_to_file,w);
           XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);
           PrintDialog = fdialog;
           XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
           SetWM_Proto(fshell);
   }
   static void output_to_printer(w,can,calldata)
           Widget w;
           struct canvas *can;
           XtPointer calldata;
   {
           FILE *fp;
           Arg arg[10];
           int n;
           static char *psfile = NULL;
           Widget fshell,fdialog;
           extern struct canvas *Can;
           extern Widget PrintDialog_lp;
           extern char *PrinterName;
   
           w = W;
           can = Can;
           if (psfile  == NULL || PrinterName == NULL) psfile = "lp";
           else psfile = PrinterName;
           create_popup(can->shell,"Output PS file to printer",psfile,&fshell,&fdialog);
           n = 0;
           XtSetArg(arg[n], XtNlabel, "PS Printer Name : "); n++;
           XtSetArg(arg[n], XtNvalue, psfile); n++;
           XtSetValues(fdialog,arg,n);
           XawDialogAddButton(fdialog,"output to PS printer",output_to_ps_printer,w);
           XawDialogAddButton(fdialog,"cancel",cancel_output_to_file,w);
           PrintDialog_lp = fdialog;
           XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
           SetWM_Proto(fshell);
   }
   
   static void cancel_output_to_file(w,fbutton,call)
           Widget w;
           XtPointer fbutton, call;
   {
           Widget shell = XtParent(XtParent(w));
           XtPopdown(shell); XtDestroyWidget(shell);
           XtSetSensitive(fbutton,True);
   }
   
   static void output_to_file(w,fbutton,call)
           Widget w;
           XtPointer fbutton, call;
   {
           char *fname;
           FILE *fp;
           int i;
           char *m;
           extern struct canvas *Can;
           extern Widget PrintDialog;
           extern int PrintingMethod;
           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 = (char *)malloc(sizeof(char)*strlen(fname)+1);
           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) {
                   warning(Can,"Could not open the output file.");
           }else{
                   generate_psfile(Can,fp);
                   fclose(fp);
           }
   
           XtPopdown(shell); XtDestroyWidget(shell);
           XtSetSensitive(fbutton,True);
   }
   
   static void output_to_ps_printer(w,fbutton,call)
           Widget w;
           XtPointer fbutton, call;
   {
           char *printerName;
           FILE *fp;
           extern struct canvas *Can;
           extern Widget PrintDialog_lp;
           char fname[256];
           char cmd[512];
           static int id = 0;
           int i;
           Widget shell = XtParent(XtParent(w));
   
           if (PrintingMethod == PRINTING_METHOD_BITMAP) {
           }else{
                   method_is_not_available();
                   XtPopdown(shell); XtDestroyWidget(shell);
                   XtSetSensitive(fbutton,True);
                   return;
           }
   
           sprintf(fname,"/tmp/ox_plot_%d.eps",(int) getpid(),id++);
   
           printerName = XawDialogGetValueString(PrintDialog_lp);
           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");
           if (fp == NULL) {
                   warning(Can,"Could not open the output file.");
           }else{
                   generate_psfile(Can,fp);
                   fclose(fp);
           }
   
           sprintf(cmd,"lpr -P%s %s",PrinterName,fname);
           if (system(cmd)) {
                   warning(Can,"Unknown printer?");
           }
           sprintf(cmd,"rm -f %s",fname);
           system(cmd);
           XtPopdown(shell); XtDestroyWidget(shell);
           XtSetSensitive(fbutton,True);
   }
   
   /* test sequence
      ox_launch(0,"ox_plot");
      ifplot(x^2-y^3);
      drawcircle(0,0,100,0xff000,0);
      */
   static int getColorSizeOfImageForPS(int xsize,int ysize,XImage *image,
                                       struct xcolorForPS **tableOfxcolorForPS);
   
   static void generate_psfile(can,fp)
           struct canvas *can;
           FILE *fp;
   {
           int x,y;
           XImage *image;
           int color[1];
           int colorSize = 1;
           char *m;
           struct xcolorForPS *tableOfxcolorForPS;
           extern int PrintingMethod;
           fprintf(stderr,"generate_psfile\n");
           if (PrintingMethod == PRINTING_METHOD_BITMAP) {
                   if ( display ) {
                           fprintf(stderr,"generate_psfile: output to a file.\n");
                           image = XGetImage(display,can->pix,
                                                   0,0,can->width,can->height,-1,ZPixmap);
                           color[0] = 0; /* black line */
                           PSFromImage(fp,image,can);
                   }else{
                   fprintf(stderr,"Cannot print on this system\n");
                   }
           }else{
                   method_is_not_available();
           }
           fflush(NULL);
   }
   
   static void method_is_not_available() {
     char *m;
   #define MSG1 "Printing method \""
   #define MSG2 "\" is not available for this picture."
     m = (char *)malloc(strlen(MSG1)+strlen(MSG2)+strlen(Printing_methods[PrintingMethod])+1);
     strcpy(m,MSG1);
     strcat(m,Printing_methods[PrintingMethod]);
     strcat(m,MSG2);
     warning(Can,m);
   }
   
   clear_pixmap(can)
   struct canvas *can;
   {
           XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);
           XFlush(display);
   }
   
   /*
      The following functions are used to generate color postscript file.
   */
   /* In order to count colorSize, binary tree (sm_btree) is used. */
   static struct sm_btree *sm_newNode(unsigned long v);
   static int sm_insert(struct sm_btree *node,unsigned long v);
   static int sm_count(struct sm_btree *rootp);
   
   struct sm_btree {
     unsigned long p;
     struct sm_btree * left;
     struct sm_btree * right;
   };
   static struct sm_btree *sm_newNode(unsigned long v) {
     struct sm_btree * n;
     n = (struct sm_btree *)MALLOC(sizeof(struct sm_btree));
     if (n == NULL) { fprintf(stderr,"No more memory.\n"); exit(10); }
     n->p = v;
     n->left = NULL;
     n->right = NULL;
     return n;
   }
   static int sm_insert(struct sm_btree *node,unsigned long v)
   {
     if (node->p == v) return;
     if (node->p > v) {
       if (node->left == NULL) {
         node->left = sm_newNode(v);
         return;
       }
       sm_insert(node->left,v);
     }
     if (node->p < v) {
       if (node->right == NULL) {
         node->right = sm_newNode(v);
         return;
       }
       sm_insert(node->right,v);
     }
   }
   static int sm_count(struct sm_btree *rootp)
   {
     if (rootp == NULL) return 0;
     return (1+sm_count(rootp->left)+sm_count(rootp->right));
   }
   
   static int setTableOfxcolorForPS(struct sm_btree *rootp,
                                    struct xcolorForPS *table,int k,int size)
   {
     int m;
     m = k;
     if (rootp == NULL) return;
     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;
   }
   
   
   static int getColorSizeOfImageForPS(int xsize,int ysize,XImage *image,
                                       struct xcolorForPS **tableOfxcolorForPS)
   {
     int x,y;
     int size;
     struct sm_btree root;
     struct xcolorForPS *table;
     XStandardColormap scm;
     Colormap cm;
     XColor color;
     XColor white;
     int screen,i;
   
     root.p = 0;
     root.left = NULL; root.right=NULL;
     /* get color size */
     for (x=0; x<xsize; x++) {
       for (y=0; y<ysize; y++) {
         sm_insert(&root,XGetPixel(image,x,y));
       }
     }
     size=sm_count(&root);
   
     table = (struct xcolorForPS *)MALLOC((size+1)*sizeof(struct xcolorForPS));
     if (table == NULL) {
           fprintf(stderr,"No more memory in getColorSizeOfImageForPS.\n");
           return 0;
     }
     /* Set rgb values standing for the pixel values.
     */
     if (setTableOfxcolorForPS(&root,table,0,size) != size) {
           warning(Can,"internal error.");
           return ;
     }
   
     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;
       }
     }
   
     *tableOfxcolorForPS = table;
     return size;
 }  }
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.29
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>