===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2000/plot/ox_plot_xevent.c,v
retrieving revision 1.3
retrieving revision 1.34
diff -u -p -r1.3 -r1.34
--- OpenXM_contrib2/asir2000/plot/ox_plot_xevent.c	2000/08/22 05:04:31	1.3
+++ OpenXM_contrib2/asir2000/plot/ox_plot_xevent.c	2015/08/14 13:51:56	1.34
@@ -45,24 +45,85 @@
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *
- * $OpenXM: OpenXM_contrib2/asir2000/plot/ox_plot_xevent.c,v 1.2 2000/08/21 08:31:51 noro Exp $ 
+ * $OpenXM: OpenXM_contrib2/asir2000/plot/ox_plot_xevent.c,v 1.33 2015/08/06 10:01:53 fujimoto Exp $ 
 */
 #include "ca.h"
 #include "parse.h"
 #include "ox.h"
 #include "ifplot.h"
 #include "cursor.h"
+#include <X11/Xaw/MenuButton.h>
+#include <X11/Xaw/Paned.h>
 
+static void Quit();
+static void print_canvas(Widget w, struct canvas *can, XtPointer calldata);
+static void output_to_printer(Widget w, struct canvas *can, XtPointer calldata);
+static void print_canvas_to_file(Widget w, struct canvas *can, XtPointer calldata);
+static void printing_method(Widget w, struct canvas *can, XtPointer calldata);
+void clear_pixmap(struct canvas *);
+void create_gc();
+void create_font();
+void create_cursors();
+void copy_to_canvas(struct canvas *can);
+void draw_level(struct canvas *can,int index,GC gc);
+void draw_frame(Window window,POINT spos,POINT opos,POINT epos);
+void draw_frame0( Window window,POINT spos,POINT epos);
+void draw_coord(struct canvas *can,POINT pos);
+void draw_wideframe(struct canvas *can);
+void redraw_canvas(struct canvas *can);
+void reset_busy(struct canvas *can);
+int search_canvas();
+int search_active_canvas();
+void PSFromImage(FILE *fp,XImage *image,struct canvas *can);
+
+
+
+static Atom wm_delete_window;
+
+void SetWM_Proto(Widget w)
+{
+	XtOverrideTranslations(w,
+		XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));
+	XSetWMProtocols(display,XtWindow(w),&wm_delete_window,1);
+}
+
+#if 0
+static void quit(Widget w, XEvent *ev, String *params,Cardinal *nparams)
+{
+    XBell(display,0);
+}
+#endif
+
+/* XXX : these lines are in plotg.c, but ld says they are not defined */
+#if __DARWIN__
+int stream;
+
+DISPLAY *display;
+CURSOR normalcur,runningcur,errorcur;
+
+#if defined(VISUAL) || defined(__MINGW32__)
+POINT start_point, end_point;
+SIZE cansize;
+#else
+Window rootwin;
+GC drawGC,dashGC,hlGC,scaleGC,clearGC,xorGC,colorGC,cdrawGC;
+XFontStruct *sffs;
+#endif
+
+struct canvas *canvas[MAXCANVAS];
+struct canvas *closed_canvas[MAXCANVAS];
+struct canvas *current_can;
+#endif /* __DARWIN__ */
+
 #ifdef ABS
 #undef ABS
 #define ABS(a) ((a)>0?(a):-(a))
 #endif
 
 static char *dname;
-static int remotes;
 static int depth,scrn;
 
-extern jmp_buf ox_env;
+extern JMP_BUF ox_env;
 static Widget toplevel;
 static XtAppContext app_con;
 
@@ -72,6 +133,7 @@ static struct PlotResources {
 	Pixel ForePixel,BackPixel,DashPixel;
 	char *ForeName,*BackName,*DashName;
 	Boolean Reverse;
+	Boolean UpsideDown;
 } PlotResources;
 
 #define forePixel PlotResources.ForePixel
@@ -81,7 +143,10 @@ static struct PlotResources {
 #define backName PlotResources.BackName
 #define dashName PlotResources.DashName
 #define reverse PlotResources.Reverse
+#define upsidedown PlotResources.UpsideDown
 
+Pixel BackPixel;
+
 Cursor create_cursor();
 
 #define blackPixel	BlackPixel(display,scrn)
@@ -89,7 +154,7 @@ Cursor create_cursor();
 
 #define LABELWIDTH 150
 
-process_xevent() {
+void process_xevent() {
 	XEvent ev;
 
 	while ( XPending(display) ) {
@@ -102,10 +167,7 @@ process_xevent() {
 
 static POINT spos,cpos;
 
-void press(w,can,ev)
-Widget w;
-struct canvas *can;
-XButtonEvent *ev;
+void press(Widget w,struct canvas *can,XButtonEvent *ev)
 {
 	POINT p;
 
@@ -113,16 +175,13 @@ XButtonEvent *ev;
 		case Button1:
 			XC(spos) = ev->x; YC(spos) = ev->y; cpos = spos; break;
 		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:
 			break;
 	}
 }
 
-void motion(w,can,ev)
-Widget w;
-struct canvas *can;
-XMotionEvent *ev;
+void motion(Widget w,struct canvas *can,XMotionEvent *ev)
 {
 
 	POINT o,p;
@@ -136,33 +195,23 @@ XMotionEvent *ev;
 	}
 }
 
-void release(w,can,ev)
-Widget w;
-struct canvas *can;
-XButtonEvent *ev;
+void release(Widget w,struct canvas *can,XButtonEvent *ev)
 {
 	POINT e;
-
 	switch ( ev->button ) {
 		case Button1:
 			e.x = ev->x; e.y = ev->y;
 			draw_frame0(can->window,spos,e);
-			if ( !busy ) {
-				if ( can->mode == MODE_PLOT )
-					plot_resize(can,spos,e);
-				else
-					ifplot_resize(can,spos,e);
-			}
+			if(!busy 
+			&& can->mode != modeNO(INTERACTIVE)
+			&& can->mode != modeNO(POLARPLOT)) plot_resize(can,spos,e);
 			break;
 		default:
 			break;
 	}
 }
 
-void structure(w,can,ev)
-Widget w;
-struct canvas *can;
-XEvent *ev;
+void structure(Widget w,struct canvas *can,XEvent *ev)
 {
 	switch ( ev->xany.type ) {
 		case Expose: 
@@ -178,19 +227,13 @@ XEvent *ev;
 
 static int lindex;
 
-void lpress(w,can,ev)
-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);
 	draw_level(can,lindex,hlGC);
 }
 
-void jumpproc(w,can,percent)
-Widget w;
-struct canvas *can;
-float *percent;
+void jumpproc(Widget w,struct canvas *can,float *percent)
 {
 	int index;
 
@@ -203,10 +246,7 @@ float *percent;
 	draw_level(can,lindex,hlGC); 
 }
 
-void jumpproc_m(w,can,percent)
-Widget w;
-struct canvas *can;
-float *percent;
+void jumpproc_m(Widget w,struct canvas *can,float *percent)
 {
 	int index;
 
@@ -217,26 +257,17 @@ float *percent;
 	}
 }
 
-void lrelease(w,can,ev)
-Widget w;
-struct canvas *can;
-XButtonEvent *ev;
+void lrelease(Widget w,struct canvas *can,XButtonEvent *ev)
 {
 	draw_level(can,lindex,drawGC); lindex = -1;
 }
 
-void lrelease_m(w,can,ev)
-Widget w;
-struct canvas *can;
-XButtonEvent *ev;
+void lrelease_m(Widget w,struct canvas *can,XButtonEvent *ev)
 {
 	lindex = -1;
 }
 
-draw_level(can,index,gc)
-struct canvas *can;
-int index;
-GC gc;
+void draw_level(struct canvas *can,int index,GC gc)
 {
 	Pixmap pix;
 	struct pa *pa;
@@ -256,18 +287,14 @@ GC gc;
 	copy_to_canvas(can);
 }
 
-draw_frame(window,spos,opos,epos)
-Window window;
-POINT spos,opos,epos;
+void draw_frame(Window window,POINT spos,POINT opos,POINT epos)
 {
 	if ( XC(opos) != XC(epos) || YC(opos) != YC(epos) )
 		draw_frame0(window,spos,opos);
 	draw_frame0(window,spos,epos);
 }
 
-draw_frame0(window,spos,epos)
-Window window;
-POINT spos,epos;
+void draw_frame0(Window window,POINT spos,POINT epos)
 {
 	int ulx,uly,w,h;
 
@@ -279,9 +306,7 @@ POINT spos,epos;
 	XFlush(display);
 }
 
-draw_coord(can,pos)
-struct canvas *can;
-POINT pos;
+void draw_coord(struct canvas *can,POINT pos)
 {
 	char buf[BUFSIZ];
 	Arg arg[2];
@@ -305,8 +330,7 @@ POINT pos;
 	XtSetValues(can->ycoord,arg,2);
 }
 
-redraw_canvas(can)
-struct canvas *can;
+void redraw_canvas(struct canvas *can)
 {
 	if ( can->wide )
 		draw_wideframe(can);
@@ -314,7 +338,7 @@ struct canvas *can;
 		copy_to_canvas(can);
 }
 
-search_canvas()
+int search_canvas()
 {
 	int i;
 
@@ -323,9 +347,10 @@ search_canvas()
 			canvas[i] = (struct canvas *)MALLOC(sizeof(struct canvas));
 			canvas[i]->index = i; return i;
 		}
+	return -1;
 }
 
-search_active_canvas()
+int search_active_canvas()
 {
 	int i;
 
@@ -335,24 +360,28 @@ search_active_canvas()
 	return -1;
 }
 
-void destroy_canvas(w,can,calldata)
-Widget w;
-struct canvas *can;
-XtPointer calldata;
+void popup_canvas(int index)
 {
+	clear_pixmap(canvas[index]);
+	XtPopup(canvas[index]->shell,XtGrabNone);
+	copy_to_canvas(canvas[index]);
+}
+
+void destroy_canvas(Widget w,struct canvas *can,XtPointer calldata)
+{
 	XtPopdown(can->shell); 
-	XtDestroyWidget(can->shell);
+/*	XtDestroyWidget(can->shell); */
 	XFlush(display);
 	if ( can == current_can ) {
 		reset_busy(can); current_can = 0;
 	}
+	if ( closed_canvas[can->index] )
+		XtDestroyWidget(closed_canvas[can->index]->shell);
+	closed_canvas[can->index] = can;
 	canvas[can->index] = 0;
 }
 
-void precise_canvas(w,can,calldata)
-Widget w;
-struct canvas *can;
-XtPointer calldata;
+void precise_canvas(Widget w,struct canvas *can,XtPointer calldata)
 {
 	if ( can->precise )
 		can->precise = 0;
@@ -360,10 +389,7 @@ XtPointer calldata;
 		can->precise = 1;
 }
 
-void wide_canvas(w,can,calldata)
-Widget w;
-struct canvas *can;
-XtPointer calldata;
+void wide_canvas(Widget w,struct canvas *can,XtPointer calldata)
 {
 	if ( can->wide ) {
 		can->wide = 0; copy_to_canvas(can); 
@@ -372,10 +398,7 @@ XtPointer calldata;
 	}
 }
 
-void noaxis_canvas(w,can,calldata)
-Widget w;
-struct canvas *can;
-XtPointer calldata;
+void noaxis_canvas(Widget w,struct canvas *can,XtPointer calldata)
 {
 	if ( can->noaxis )
 		can->noaxis = 0;
@@ -387,9 +410,7 @@ XtPointer calldata;
 		copy_to_canvas(can); 
 }
 
-toggle_button(w,flag)
-Widget w;
-int flag;
+void toggle_button(Widget w,int flag)
 {
 	Arg arg[2];
 
@@ -403,11 +424,10 @@ int flag;
 	XtSetValues(w,arg,2); XFlush(display);
 }
 
-draw_wideframe(can)
-struct canvas *can;
+void draw_wideframe(struct canvas *can)
 {
 	struct canvas fakecan;
-	double xmin,xmax,ymin,ymax,xmid,ymid,dx,dy;
+	double xmid,ymid,dx,dy;
 	POINT s,e;
 
 	fakecan = *can;
@@ -425,10 +445,7 @@ struct canvas *can;
 	draw_frame0(can->window,s,e);
 }
 
-create_popup(parent,name,str,shell,dialog)
-Widget parent;
-char *name,*str;
-Widget *shell,*dialog;
+void create_popup(Widget parent,char *name,char *str,Widget *shell,Widget *dialog)
 {
 	Arg arg[3];
 	Position x,y;
@@ -440,33 +457,25 @@ Widget *shell,*dialog;
 	*dialog = XtCreateManagedWidget("dialog",dialogWidgetClass,*shell,arg,1);
 }
 
-warning(can,s)
-struct canvas *can;
-char *s;
+void warning(struct canvas *can,char *s)
 {
 	void popdown_warning();
 	Widget warnshell,warndialog;
-	Position x,y;
-	Arg arg[3];
 
 	if ( !can->shell )
 		return;
 	create_popup(can->shell,"warning",s,&warnshell,&warndialog);
 	XawDialogAddButton(warndialog,"dismiss",popdown_warning,warnshell);
 	XtPopup(warnshell,XtGrabNone);
+	SetWM_Proto(warnshell);
 }
 
-void popdown_warning(w,client,call) 
-Widget w;
-XtPointer client,call;
+void popdown_warning(Widget w,XtPointer client,XtPointer call)
 {
 	XtPopdown(client); XtDestroyWidget(client);
 }
 
-void show_formula(w,can,calldata)
-Widget w;
-struct canvas *can;
-XtPointer calldata;
+void show_formula(Widget w,struct canvas *can,XtPointer calldata)
 {
 	void popdown_formula();
 	Widget fshell,fdialog;
@@ -476,11 +485,10 @@ XtPointer calldata;
 	create_popup(can->shell,"formula",buf,&fshell,&fdialog);
 	XawDialogAddButton(fdialog,"dismiss",popdown_formula,w);
 	XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
+	SetWM_Proto(fshell);
 }
 
-void popdown_formula(w,fbutton,call) 
-Widget w,fbutton;
-XtPointer call;
+void popdown_formula(Widget w,Widget fbutton,XtPointer call)
 {
 	Widget shell = XtParent(XtParent(w));
 	XtPopdown(shell); XtDestroyWidget(shell);
@@ -489,22 +497,21 @@ XtPointer call;
 
 #define NormalSelection ButtonPressMask|ButtonReleaseMask|Button1MotionMask|Button3MotionMask|StructureNotifyMask| ExposureMask
 
-create_canvas(can)
-struct canvas *can;
+void create_canvas(struct canvas *can)
 {
-	XEvent event;
 	Widget box,frame,commands,
-		coords,quit,wide,precise,canvas,formula;
+		coords,quit,print,wide,precise,canvas,formula;
 	Window window;
 	Pixmap pix;
-	int i,width,height;
+	int width,height;
 	Arg arg[6];
 	char buf[BUFSIZ];
 
+	XImage *image;
+
 	width = can->width; height = can->height;
 
-	sprintf(buf,"%s : %d/%d", can->wname?can->wname:"Plot",
-		remotes,can->index);
+	sprintf(buf,"%s : %d", can->wname?can->wname:"Plot",can->index);
 	XtSetArg(arg[0],XtNiconName,buf);
 	can->shell =
 		XtCreatePopupShell("shell",topLevelShellWidgetClass,toplevel,arg,1);
@@ -521,19 +528,21 @@ struct canvas *can;
 	commands = XtCreateManagedWidget("commands",boxWidgetClass,frame,arg,2);
 
 	quit = XtCreateManagedWidget("quit",commandWidgetClass,commands,NULL,0);
-	XtAddCallback(quit,XtNcallback,destroy_canvas,can);
+	XtAddCallback(quit,XtNcallback,(XtCallbackProc)destroy_canvas,can);
+	print = XtCreateManagedWidget("print",commandWidgetClass,commands,NULL,0);
+	XtAddCallback(print,XtNcallback,(XtCallbackProc)print_canvas,can);
 	can->wideb = wide = 
 		XtCreateManagedWidget("wide",toggleWidgetClass,commands,NULL,0);
-	XtAddCallback(wide,XtNcallback,wide_canvas,can);
+	XtAddCallback(wide,XtNcallback,(XtCallbackProc)wide_canvas,can);
 	can->preciseb = precise = 
 		XtCreateManagedWidget("precise",toggleWidgetClass,commands,NULL,0);
-	XtAddCallback(precise,XtNcallback,precise_canvas,can);
+	XtAddCallback(precise,XtNcallback,(XtCallbackProc)precise_canvas,can);
 	formula = 
 		XtCreateManagedWidget("formula",commandWidgetClass,commands,NULL,0);
-	XtAddCallback(formula,XtNcallback,show_formula,can);
+	XtAddCallback(formula,XtNcallback,(XtCallbackProc)show_formula,can);
 	can->noaxisb =
 		XtCreateManagedWidget("noaxis",toggleWidgetClass,commands,NULL,0);
-	XtAddCallback(can->noaxisb,XtNcallback,noaxis_canvas,can);
+	XtAddCallback(can->noaxisb,XtNcallback,(XtCallbackProc)noaxis_canvas,can);
 
 	XtSetArg(arg[0],XtNfromVert,commands);
 	XtSetArg(arg[1],XtNwidth,width); 
@@ -567,16 +576,14 @@ struct canvas *can;
 	XtSetArg(arg[0],XtNwidth,LABELWIDTH);
 	can->ycoord = XtCreateManagedWidget("ycoord",labelWidgetClass,coords,arg,1);
 
-	XtAddEventHandler(canvas,ButtonPressMask,False,press,can);
-	XtAddEventHandler(canvas,ButtonReleaseMask,False,release,can);
-	XtAddEventHandler(canvas,Button1MotionMask,False,motion,can);
-	XtAddEventHandler(canvas,Button3MotionMask,False,motion,can);
-	XtAddEventHandler(canvas,StructureNotifyMask,False,structure,can);
-	XtAddEventHandler(canvas,ExposureMask,False,structure,can);
+	XtAddEventHandler(canvas,ButtonPressMask,False,(XtEventHandler)press,can);
+	XtAddEventHandler(canvas,ButtonReleaseMask,False,(XtEventHandler)release,can);
+	XtAddEventHandler(canvas,Button1MotionMask,False,(XtEventHandler)motion,can);
+	XtAddEventHandler(canvas,Button3MotionMask,False,(XtEventHandler)motion,can);
+	XtAddEventHandler(canvas,StructureNotifyMask,False,(XtEventHandler)structure,can);
+	XtAddEventHandler(canvas,ExposureMask,False,(XtEventHandler)structure,can);
 
-	if ( can->mode == MODE_CONPLOT ) {
-		Widget scale;
-
+	if ( can->mode == modeNO(CONPLOT) ) {
 		XtSetArg(arg[0],XtNwidth,LABELWIDTH);
 		can->level = XtCreateManagedWidget("level",labelWidgetClass,
 			commands,arg,1);
@@ -584,27 +591,29 @@ struct canvas *can;
 		XtSetArg(arg[0],XtNsensitive,True); 
 		XtSetValues(can->ydone,arg,1);
 		if ( depth >= 2 ) {
-			XtAddCallback(can->ydone,XtNjumpProc,jumpproc,can);
-			XtAddEventHandler(can->ydone,ButtonReleaseMask,False,lrelease,can);
+			XtAddCallback(can->ydone,XtNjumpProc,(XtCallbackProc)jumpproc,can);
+			XtAddEventHandler(can->ydone,ButtonReleaseMask,False,(XtEventHandler)lrelease,can);
 		} else {
-			XtAddCallback(can->ydone,XtNjumpProc,jumpproc_m,can);
-			XtAddEventHandler(can->ydone,ButtonReleaseMask,False,lrelease_m,can);
+			XtAddCallback(can->ydone,XtNjumpProc,(XtCallbackProc)jumpproc_m,can);
+			XtAddEventHandler(can->ydone,ButtonReleaseMask,False,(XtEventHandler)lrelease_m,can);
 		}
 	}
-	if ( can->mode != MODE_IFPLOT || !qpcheck((Obj)can->formula) )
+	if ( can->mode != modeNO(IFPLOT) || !qpcheck((Obj)can->formula) )
 		XtSetSensitive(precise,False);
 	XtPopup(can->shell,XtGrabNone);
-
+	SetWM_Proto(can->shell);
 	window = can->window = XtWindow(canvas);
 	pix = can->pix = XCreatePixmap(display,window,width,height,depth);
 	XFillRectangle(display,pix,clearGC,0,0,width,height);
+	image = XGetImage(display, can->pix, 0, 0, can->width, can->height,
+		-1, ZPixmap);
+	BackPixel = XGetPixel(image,0,0);
 	XDefineCursor(display,window,normalcur);
 	XFlush(display);
 	current_can = can;
 }
 
-alloc_pixmap(can)
-struct canvas *can;
+void alloc_pixmap(struct canvas *can)
 {
 	can->pix = XCreatePixmap(display,can->window,
 		can->width,can->height,depth);
@@ -612,6 +621,7 @@ struct canvas *can;
 }
 
 static XrmOptionDescRec options[] = {
+{"-upsidedown","*upsidedown",XrmoptionNoArg,"on"},
 {"-reverse","*reverse",XrmoptionNoArg,"on"},
 {"-fg","*foreground",XrmoptionSepArg,NULL},
 {"-bg","*background",XrmoptionSepArg,NULL},
@@ -620,6 +630,8 @@ static XrmOptionDescRec options[] = {
 #define offset(name) XtOffset(struct PlotResources *,name)
 
 static XtResource resources[] = {
+{"upsidedown","UpsideDown",XtRBoolean,sizeof(Boolean),
+	offset(UpsideDown),XtRBoolean,&upsidedown},
 {"reverse","Reverse",XtRBoolean,sizeof(Boolean),
 	offset(Reverse),XtRBoolean,&reverse},
 {"foreground","Foreground",XtRString,sizeof(char *),
@@ -636,24 +648,34 @@ static XtResource resources[] = {
 	offset(DashPixel),XtRPixel,(XtPointer)&dashPixel},
 };
 
-init_plot_display(argc,argv)
-int argc;
-char **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(int argc,char **argv)
+{
 	int ac;
 	char **av;
 	unsigned int tmp;
 
 	for ( ac = argc, av = argv; ac; ac--, av++ )
-		if ( index(*av,':') )
+		if ( !strcmp(*av,"nox") )
+			return 0;	
+		else if ( index(*av,':') )
 			dname = *av;
 	XtToolkitInitialize();
 	app_con = XtCreateApplicationContext();
+	XtAppAddActions(app_con,actions_table, XtNumber(actions_table));
 	display = XtOpenDisplay(app_con,dname,"plot","Plot",
 		options,XtNumber(options),&argc,argv);
 	if ( !display ) {
 		fprintf(stderr,"Can't open display\n");
-		exit(1);
+		return 0;	
 	}
 	toplevel = XtAppCreateShell(0,"Plot",applicationShellWidgetClass,
 		display,0,0);
@@ -667,6 +689,11 @@ char **argv;
 	depth = DefaultDepth(display,scrn);
 	rootwin = RootWindow(display,scrn);
 
+	/* for handling DELETE message */
+	wm_delete_window = XInternAtom(display,"WM_DELETE_WINDOW",False);
+	XtOverrideTranslations(toplevel,
+		XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));
+
 	if ( reverse ) {
 		tmp = forePixel; forePixel = backPixel; backPixel = tmp;
 	}
@@ -674,11 +701,12 @@ char **argv;
 	create_gc();
 	create_font();
 	create_cursors();
+	return 1;
 }
 
 static char *scalefont = "*-8-80-*";
 
-create_font() {
+void create_font() {
 	Font sfid;
 
 	sfid = XLoadFont(display,scalefont);
@@ -686,9 +714,8 @@ create_font() {
 	XSetFont(display,scaleGC,sfid);
 }
 
-create_gc() {
+void create_gc() {
 	static XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};
-	int i,b,step;
 
 	drawGC = XCreateGC(display,rootwin,0,NULL);
 	dashGC = XCreateGC(display,rootwin,0,NULL);
@@ -697,12 +724,14 @@ create_gc() {
 	scaleGC = XCreateGC(display,rootwin,0,NULL);
 	xorGC = XCreateGC(display,rootwin,0,NULL);
 	colorGC = XCreateGC(display,rootwin,0,NULL);
+	cdrawGC = XCreateGC(display,rootwin,0,NULL);
 	XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,drawGC);
 	XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,dashGC);
 	XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,clearGC);
 	XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,scaleGC);
 	XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,xorGC);
 	XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,colorGC);
+	XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,cdrawGC);
 	XSetForeground(display,drawGC,forePixel);
 	XSetForeground(display,scaleGC,forePixel);
 	XSetForeground(display,clearGC,backPixel);
@@ -719,7 +748,18 @@ create_gc() {
 	XSetForeground(display,colorGC,color.pixel);
 }
 
-create_cursors() {
+void set_drawcolor(unsigned int c)
+{
+	XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};
+
+	color.red = (c&0xff0000)>>8;
+	color.green = (c&0xff00);
+	color.blue = (c&0xff)<<8;
+	XAllocColor(display,DefaultColormap(display,scrn),&color);
+	XSetForeground(display,cdrawGC,color.pixel);
+}
+
+void create_cursors() {
 	static XColor fg = {0, 0x0, 0x0, 0x0,DoRed|DoGreen|DoBlue,0};
 	static XColor bg = {0, 0xffff, 0xffff, 0xffff,DoRed|DoGreen|DoBlue,0};
 
@@ -733,10 +773,7 @@ create_cursors() {
 		m_width/2,m_height/2,&fg,&bg);
 }
 
-Cursor create_cursor(image,mask,width,height,xhot,yhot,fg,bg)
-char *image,*mask;
-int width,height,xhot,yhot;
-XColor *fg,*bg;
+Cursor create_cursor(char *image,char *mask,int width,int height,int xhot,int yhot,XColor *fg,XColor *bg)
 {
 	Pixmap ipix,mpix;
 
@@ -745,20 +782,22 @@ XColor *fg,*bg;
 	return XCreatePixmapCursor(display,ipix,mpix,fg,bg,xhot,yhot);
 }
 
-copy_to_canvas(can)
-struct canvas *can;
+void copy_to_canvas(struct canvas *can)
 {
 	if ( display ) {
-		XCopyArea(display,can->pix,can->window,
-			drawGC,0,0,can->width,can->height,0,0);
+		if ( can->color ) {
+			set_drawcolor(can->color);
+			XCopyArea(display,can->pix,can->window,
+				cdrawGC,0,0,can->width,can->height,0,0);
+		} else
+			XCopyArea(display,can->pix,can->window,
+				drawGC,0,0,can->width,can->height,0,0);
 		pline(display,can,can->window);
 		XFlush(display);
 	}
 }
 
-copy_subimage(subcan,can,pos)
-struct canvas *subcan,*can;
-XPoint pos;
+void copy_subimage(struct canvas *subcan,struct canvas *can,XPoint pos)
 {
 	if ( display ) {
 		XCopyArea(display,subcan->pix,can->pix,
@@ -770,22 +809,21 @@ XPoint pos;
 #include <signal.h>
 #include <fcntl.h>
 
-set_selection() {
+void set_selection() {
 	if ( current_can ) {
 		XSelectInput(display,current_can->window,0);
 		XFlush(display);
 	}
 }
 
-reset_selection() {
+void reset_selection() {
 	if ( current_can ) {
 		XSelectInput(display,current_can->window,NormalSelection);
 		XFlush(display);
 	}
 }
 
-set_busy(can)
-struct canvas *can;
+void set_busy(struct canvas *can)
 {
 	busy = 1;
 	XtSetSensitive(can->wideb,False);
@@ -794,23 +832,460 @@ struct canvas *can;
 	XFlush(display);
 }
 
-reset_busy(can)
-struct canvas *can;
+void reset_busy(struct canvas *can)
 {
 	busy = 0;
 	if ( can->window ) {
 		XtSetSensitive(can->wideb,True);
 		XtSetSensitive(can->noaxisb,True);
-		if ( can->mode == MODE_IFPLOT && qpcheck((Obj)can->formula) )
+		if ( can->mode == modeNO(IFPLOT) && qpcheck((Obj)can->formula) )
 			XtSetSensitive(can->preciseb,True);
 		XFlush(display);
 	}
 }
 
-reset_current_computation()
+void reset_current_computation()
 {
 	if ( current_can ) {
 		reset_selection(); reset_busy(current_can);
 		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(Widget w,struct canvas *can,XtPointer calldata)
+{
+	Widget fshell,fdialog;
+	extern struct canvas *Can;
+	extern Widget W;
+
+	W = w;
+	Can = can;
+	create_popup(can->shell,"Print/Output PS file","",&fshell,&fdialog);
+	XawDialogAddButton(fdialog,"print",(XtCallbackProc)output_to_printer,w);
+	XawDialogAddButton(fdialog,"output PS file",(XtCallbackProc)print_canvas_to_file,w);
+	XawDialogAddButton(fdialog,"method",(XtCallbackProc)printing_method,w);
+	XawDialogAddButton(fdialog,"dismiss",(XtCallbackProc)cancel_output_to_file,w);
+	XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone); 
+	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",(int)number);
+	shell = XtParent(XtParent(w));
+	XtPopdown(shell); XtDestroyWidget(shell);
+}
+
+static void printing_method(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(Widget w,struct canvas *can,XtPointer calldata)
+{
+	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(Widget w,struct canvas *can,XtPointer calldata)
+{
+	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(Widget w,XtPointer fbutton,XtPointer call)
+{
+	Widget shell = XtParent(XtParent(w));
+	XtPopdown(shell); XtDestroyWidget(shell);
+	XtSetSensitive(fbutton,True);
+}
+
+static void output_to_file(Widget w,XtPointer fbutton,XtPointer call)
+{
+	char *fname;
+	FILE *fp;
+	int i;
+
+	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(Widget w, XtPointer fbutton, XtPointer 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_%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 void generate_psfile(struct canvas *can, FILE *fp)
+{
+	XImage *image;
+	int color[1];
+	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);
+}
+
+void clear_pixmap(struct canvas *can)
+{
+	XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);
+	XFlush(display);
+}
+
+#if 0
+/* 
+   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 void sm_insert(struct sm_btree *node,unsigned long v);
+static int sm_count(struct sm_btree *rootp);
+static int getColorSizeOfImageForPS(int xsize,int ysize,XImage *image,
+                                    struct xcolorForPS **tableOfxcolorForPS);
+
+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 void 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 0;
+  if (k >= size) {
+    warning(Can,"internal error of setTableOfxcolorForPS");
+  }
+  if (rootp->left != NULL) {
+    m = setTableOfxcolorForPS(rootp->left,table,k,size);
+  }
+  
+  (table[m]).pixel = rootp->p;
+  m++;
+  if (rootp->right != NULL) {
+    m = setTableOfxcolorForPS(rootp->right,table,m,size);
+  }
+  return m;
+}
+
+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 0;
+  }
+
+  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;
+}
+#endif
+