[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.28 and 1.29

version 1.28, 2007/01/30 00:28:26 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.27 2006/11/09 15:54:35 saito 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"
Line 126  static struct PlotResources {
Line 126  static struct PlotResources {
 #define reverse PlotResources.Reverse  #define reverse PlotResources.Reverse
 #define upsidedown PlotResources.UpsideDown  #define upsidedown PlotResources.UpsideDown
   
   Pixel BackPixel;
   
 Cursor create_cursor();  Cursor create_cursor();
   
 #define blackPixel      BlackPixel(display,scrn)  #define blackPixel      BlackPixel(display,scrn)
Line 559  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", can->wname?can->wname:"Plot",can->index);          sprintf(buf,"%s : %d", can->wname?can->wname:"Plot",can->index);
Line 657  struct canvas *can;
Line 661  struct canvas *can;
         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 958  static void print_canvas(w,can,calldata)
Line 965  static void print_canvas(w,can,calldata)
          struct canvas *can;           struct canvas *can;
          XtPointer calldata;           XtPointer calldata;
 {  {
   Widget fshell,fdialog;          Widget fshell,fdialog;
   extern struct canvas *Can;          extern struct canvas *Can;
   extern Widget W;          extern Widget W;
   Widget entry;          Widget entry;
   int i;          int i;
   Arg arg[1];          Arg arg[1];
   
   W = w;          W = w;
   Can = can;          Can = can;
   create_popup(can->shell,"Print/Output PS file","",&fshell,&fdialog);          create_popup(can->shell,"Print/Output PS file","",&fshell,&fdialog);
   XawDialogAddButton(fdialog,"print",output_to_printer,w);          XawDialogAddButton(fdialog,"print",output_to_printer,w);
   XawDialogAddButton(fdialog,"output PS file",print_canvas_to_file,w);          XawDialogAddButton(fdialog,"output PS file",print_canvas_to_file,w);
   XawDialogAddButton(fdialog,"method",printing_method,w);          XawDialogAddButton(fdialog,"method",printing_method,w);
   XawDialogAddButton(fdialog,"dismiss",cancel_output_to_file,w);          XawDialogAddButton(fdialog,"dismiss",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;  {
   extern int PrintingMethod;          Widget shell;
   PrintingMethod = (int) number;          extern int PrintingMethod;
   fprintf(stderr,"PrintingMethod=%d\n",number);          PrintingMethod = (int) number;
   shell = XtParent(XtParent(w));          fprintf(stderr,"PrintingMethod=%d\n",number);
   XtPopdown(shell); XtDestroyWidget(shell);          shell = XtParent(XtParent(w));
           XtPopdown(shell); XtDestroyWidget(shell);
 }  }
   
 static void printing_method(w,can,calldata)  static void printing_method(w,can,calldata)
          Widget w;          Widget w;
          struct canvas *can;          struct canvas *can;
          XtPointer calldata;          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(fdialog,Printing_methods[i],set_printing_method,(XtPointer) i);                  XawDialogAddButton(
   }                          fdialog,Printing_methods[i],set_printing_method,(XtPointer) i);
   XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);          }
   SetWM_Proto(fshell);          XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
           SetWM_Proto(fshell);
 }  }
 static void print_canvas_to_file(w,can,calldata)  static void print_canvas_to_file(w,can,calldata)
          Widget w;          Widget w;
          struct canvas *can;          struct canvas *can;
          XtPointer calldata;          XtPointer calldata;
 {  {
   FILE *fp;          FILE *fp;
   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(w,can,calldata)  static void output_to_printer(w,can,calldata)
          Widget w;          Widget w;
          struct canvas *can;          struct canvas *can;
          XtPointer calldata;          XtPointer calldata;
 {  {
   FILE *fp;          FILE *fp;
   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(w,fbutton,call)  static void cancel_output_to_file(w,fbutton,call)
          Widget w;          Widget w;
          XtPointer fbutton, call;          XtPointer fbutton, call;
 {  {
   Widget shell = XtParent(XtParent(w));          Widget shell = XtParent(XtParent(w));
   XtPopdown(shell); XtDestroyWidget(shell);          XtPopdown(shell); XtDestroyWidget(shell);
   XtSetSensitive(fbutton,True);          XtSetSensitive(fbutton,True);
 }  }
   
 static void output_to_file(w,fbutton,call)  static void output_to_file(w,fbutton,call)
          Widget w;          Widget w;
          XtPointer fbutton, call;          XtPointer fbutton, call;
 {  {
   char *fname;          char *fname;
   FILE *fp;          FILE *fp;
   int i;          int i;
   char *m;          char *m;
   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) {
   }else{                  TODO;
         method_is_not_available();          }else{
         XtPopdown(shell); XtDestroyWidget(shell);                  method_is_not_available();
         XtSetSensitive(fbutton,True);                  XtPopdown(shell); XtDestroyWidget(shell);
         return;                  XtSetSensitive(fbutton,True);
   }                  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(w,fbutton,call)  static void output_to_ps_printer(w,fbutton,call)
          Widget w;          Widget w;
          XtPointer fbutton, call;          XtPointer fbutton, 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.eps",(int) getpid(),id++);          sprintf(fname,"/tmp/ox_plot_%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
    ox_launch(0,"ox_plot");     ox_launch(0,"ox_plot");
    ifplot(x^2-y^3);     ifplot(x^2-y^3);
Line 1181  static int getColorSizeOfImageForPS(int xsize,int ysiz
Line 1190  static int getColorSizeOfImageForPS(int xsize,int ysiz
                                     struct xcolorForPS **tableOfxcolorForPS);                                      struct xcolorForPS **tableOfxcolorForPS);
   
 static void generate_psfile(can,fp)  static void generate_psfile(can,fp)
          struct canvas *can;          struct canvas *can;
          FILE *fp;          FILE *fp;
 {  {
 #if 0          int x,y;
   int x,y;          XImage *image;
   XImage *image;          int color[1];
   int color[1];          int colorSize = 1;
   int colorSize = 1;          char *m;
   char *m;          struct xcolorForPS *tableOfxcolorForPS;
   struct xcolorForPS *tableOfxcolorForPS;          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);
           colorSize =                          color[0] = 0; /* black line */
                 getColorSizeOfImageForPS(can->width,can->height,image,&tableOfxcolorForPS);                          PSFromImage(fp,image,can);
           color[0] = 0; /* black line */                  }else{
           generatePS_from_image(fp,image,can->width,can->height,color,colorSize,can,tableOfxcolorForPS,upsidedown);                  fprintf(stderr,"Cannot print on this system\n");
                   }
         }else{          }else{
           fprintf(stderr,"Cannot print on this system\n");                  method_is_not_available();
         }          }
   }else{          fflush(NULL);
         method_is_not_available();  
   }  
   fflush(NULL);  
 #endif  
 }  }
   
 static void method_is_not_available() {  static void method_is_not_available() {
Line 1375  static int getColorSizeOfImageForPS(int xsize,int ysiz
Line 1380  static int getColorSizeOfImageForPS(int xsize,int ysiz
   *tableOfxcolorForPS = table;    *tableOfxcolorForPS = table;
   return size;    return size;
 }  }
   
Legend:
Removed from v.1.28  
changed lines
  Added in v.1.29
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>