Annotation of OpenXM_contrib2/asir2000/plot/ox_plot_xevent.c, Revision 1.1.1.1
1.1 noro 1: /* $OpenXM: OpenXM/src/asir99/plot/ox_plot_xevent.c,v 1.1.1.1 1999/11/10 08:12:34 noro Exp $ */
2: #include "ca.h"
3: #include "parse.h"
4: #include "ox.h"
5: #include "ifplot.h"
6: #include "cursor.h"
7:
8: #ifdef ABS
9: #undef ABS
10: #define ABS(a) ((a)>0?(a):-(a))
11: #endif
12:
13: static char *dname;
14: static int remotes;
15: static int depth,scrn;
16:
17: extern jmp_buf ox_env;
18: static Widget toplevel;
19: static XtAppContext app_con;
20:
21: static int busy;
22:
23: static struct PlotResources {
24: Pixel ForePixel,BackPixel,DashPixel;
25: char *ForeName,*BackName,*DashName;
26: Boolean Reverse;
27: } PlotResources;
28:
29: #define forePixel PlotResources.ForePixel
30: #define backPixel PlotResources.BackPixel
31: #define dashPixel PlotResources.DashPixel
32: #define foreName PlotResources.ForeName
33: #define backName PlotResources.BackName
34: #define dashName PlotResources.DashName
35: #define reverse PlotResources.Reverse
36:
37: Cursor create_cursor();
38:
39: #define blackPixel BlackPixel(display,scrn)
40: #define whitePixel WhitePixel(display,scrn)
41:
42: #define LABELWIDTH 150
43:
44: process_xevent() {
45: XEvent ev;
46:
47: while ( XPending(display) ) {
48: XtAppNextEvent(app_con,&ev);
49: XtDispatchEvent(&ev);
50: }
51: }
52:
53: /* event handlers */
54:
55: static POINT spos,cpos;
56:
57: void press(w,can,ev)
58: Widget w;
59: struct canvas *can;
60: XButtonEvent *ev;
61: {
62: POINT p;
63:
64: switch ( ev->button ) {
65: case Button1:
66: XC(spos) = ev->x; YC(spos) = ev->y; cpos = spos; break;
67: case Button3:
68: XC(p) = ev->x; YC(p) = ev->y; draw_coord(can,&p); break;
69: default:
70: break;
71: }
72: }
73:
74: void motion(w,can,ev)
75: Widget w;
76: struct canvas *can;
77: XMotionEvent *ev;
78: {
79:
80: POINT o,p;
81:
82: if ( ev->state & Button1Mask ) {
83: o = cpos; XC(cpos) = ev->x; YC(cpos) = ev->y;
84: draw_frame(can->window,spos,o,cpos);
85: } else if ( ev->state & Button3Mask ) {
86: XC(p) = ev->x; YC(p) = ev->y;
87: draw_coord(can,p);
88: }
89: }
90:
91: void release(w,can,ev)
92: Widget w;
93: struct canvas *can;
94: XButtonEvent *ev;
95: {
96: POINT e;
97:
98: switch ( ev->button ) {
99: case Button1:
100: e.x = ev->x; e.y = ev->y;
101: draw_frame0(can->window,spos,e);
102: if ( !busy ) {
103: if ( can->mode == MODE_PLOT )
104: plot_resize(can,spos,e);
105: else
106: ifplot_resize(can,spos,e);
107: }
108: break;
109: default:
110: break;
111: }
112: }
113:
114: void structure(w,can,ev)
115: Widget w;
116: struct canvas *can;
117: XEvent *ev;
118: {
119: switch ( ev->xany.type ) {
120: case Expose:
121: if ( !ev->xexpose.count )
122: redraw_canvas(can);
123: break;
124: case ConfigureNotify:
125: redraw_canvas(can); break;
126: default:
127: break;
128: }
129: }
130:
131: static int lindex;
132:
133: void lpress(w,can,ev)
134: Widget w;
135: struct canvas *can;
136: XButtonEvent *ev;
137: {
138: lindex = (can->height-ev->y)/(can->height/can->nzstep);
139: draw_level(can,lindex,hlGC);
140: }
141:
142: void jumpproc(w,can,percent)
143: Widget w;
144: struct canvas *can;
145: float *percent;
146: {
147: int index;
148:
149: index = can->nzstep * (1.0-*percent);
150: if ( index == lindex )
151: return;
152: if ( lindex >= 0 )
153: draw_level(can,lindex,drawGC);
154: lindex = index;
155: draw_level(can,lindex,hlGC);
156: }
157:
158: void jumpproc_m(w,can,percent)
159: Widget w;
160: struct canvas *can;
161: float *percent;
162: {
163: int index;
164:
165: index = can->nzstep * (1.0-*percent);
166: if ( index != lindex ) {
167: draw_level(can,lindex,drawGC);
168: draw_level(can,lindex,hlGC);
169: }
170: }
171:
172: void lrelease(w,can,ev)
173: Widget w;
174: struct canvas *can;
175: XButtonEvent *ev;
176: {
177: draw_level(can,lindex,drawGC); lindex = -1;
178: }
179:
180: void lrelease_m(w,can,ev)
181: Widget w;
182: struct canvas *can;
183: XButtonEvent *ev;
184: {
185: lindex = -1;
186: }
187:
188: draw_level(can,index,gc)
189: struct canvas *can;
190: int index;
191: GC gc;
192: {
193: Pixmap pix;
194: struct pa *pa;
195: int i,len;
196: POINT *p;
197: Arg arg[2];
198: char buf[BUFSIZ];
199:
200: if ( busy || can->wide || index < 0 || index > can->nzstep )
201: return;
202: pix = can->pix; pa = &can->pa[index]; len = pa->length; p = pa->pos;
203: for ( i = 0; i < len; i++ )
204: XDrawPoint(display,pix,gc,p[i].x,p[i].y);
205: sprintf(buf,"level:%g",can->zmin+(can->zmax-can->zmin)*index/can->nzstep);
206: XtSetArg(arg[0],XtNlabel,buf); XtSetArg(arg[1],XtNwidth,LABELWIDTH);
207: XtSetValues(can->level,arg,2);
208: copy_to_canvas(can);
209: }
210:
211: draw_frame(window,spos,opos,epos)
212: Window window;
213: POINT spos,opos,epos;
214: {
215: if ( XC(opos) != XC(epos) || YC(opos) != YC(epos) )
216: draw_frame0(window,spos,opos);
217: draw_frame0(window,spos,epos);
218: }
219:
220: draw_frame0(window,spos,epos)
221: Window window;
222: POINT spos,epos;
223: {
224: int ulx,uly,w,h;
225:
226: ulx = MIN(XC(spos),XC(epos)); uly = MIN(YC(spos),YC(epos));
227: w = ABS(XC(spos)-XC(epos)); h = ABS(YC(spos)-YC(epos));
228: if ( !w || !h )
229: return;
230: XDrawRectangle(display,window,xorGC,ulx,uly,w,h);
231: XFlush(display);
232: }
233:
234: draw_coord(can,pos)
235: struct canvas *can;
236: POINT pos;
237: {
238: char buf[BUFSIZ];
239: Arg arg[2];
240: double x,y,xmin,ymax,dx,dy;
241:
242: if ( can->wide ) {
243: dx = 10*(can->xmax-can->xmin); dy = 10*(can->ymax-can->ymin);
244: xmin = (can->xmax+can->xmin-dx)/2;
245: ymax = (can->ymax+can->ymin+dy)/2;
246: } else {
247: dx = can->xmax-can->xmin; dy = can->ymax-can->ymin;
248: xmin = can->xmin; ymax = can->ymax;
249: }
250: x = xmin+XC(pos)*dx/can->width;
251: y = ymax-YC(pos)*dy/can->height;
252: sprintf(buf,"%s:%g",can->vx?can->vx->name:"horiz",x);
253: XtSetArg(arg[0],XtNlabel,buf); XtSetArg(arg[1],XtNwidth,LABELWIDTH);
254: XtSetValues(can->xcoord,arg,2);
255: sprintf(buf,"%s:%g",can->vy?can->vy->name:"vert",y);
256: XtSetArg(arg[0],XtNlabel,buf); XtSetArg(arg[1],XtNwidth,LABELWIDTH);
257: XtSetValues(can->ycoord,arg,2);
258: }
259:
260: redraw_canvas(can)
261: struct canvas *can;
262: {
263: if ( can->wide )
264: draw_wideframe(can);
265: else
266: copy_to_canvas(can);
267: }
268:
269: search_canvas()
270: {
271: int i;
272:
273: for ( i = 0; i < MAXCANVAS; i++ )
274: if ( !canvas[i] ) {
275: canvas[i] = (struct canvas *)MALLOC(sizeof(struct canvas));
276: canvas[i]->index = i; return i;
277: }
278: }
279:
280: search_active_canvas()
281: {
282: int i;
283:
284: for ( i = 0; i < MAXCANVAS; i++ )
285: if ( canvas[i] )
286: return i;
287: return -1;
288: }
289:
290: void destroy_canvas(w,can,calldata)
291: Widget w;
292: struct canvas *can;
293: XtPointer calldata;
294: {
295: XtPopdown(can->shell);
296: XtDestroyWidget(can->shell);
297: XFlush(display);
298: if ( can == current_can ) {
299: reset_busy(can); current_can = 0;
300: }
301: canvas[can->index] = 0;
302: }
303:
304: void precise_canvas(w,can,calldata)
305: Widget w;
306: struct canvas *can;
307: XtPointer calldata;
308: {
309: if ( can->precise )
310: can->precise = 0;
311: else
312: can->precise = 1;
313: }
314:
315: void wide_canvas(w,can,calldata)
316: Widget w;
317: struct canvas *can;
318: XtPointer calldata;
319: {
320: if ( can->wide ) {
321: can->wide = 0; copy_to_canvas(can);
322: } else {
323: can->wide = 1; draw_wideframe(can);
324: }
325: }
326:
327: void noaxis_canvas(w,can,calldata)
328: Widget w;
329: struct canvas *can;
330: XtPointer calldata;
331: {
332: if ( can->noaxis )
333: can->noaxis = 0;
334: else
335: can->noaxis = 1;
336: if ( can->wide )
337: draw_wideframe(can);
338: else
339: copy_to_canvas(can);
340: }
341:
342: toggle_button(w,flag)
343: Widget w;
344: int flag;
345: {
346: Arg arg[2];
347:
348: if ( flag ) {
349: XtSetArg(arg[0],XtNforeground,backPixel);
350: XtSetArg(arg[1],XtNbackground,forePixel);
351: } else {
352: XtSetArg(arg[0],XtNforeground,forePixel);
353: XtSetArg(arg[1],XtNbackground,backPixel);
354: }
355: XtSetValues(w,arg,2); XFlush(display);
356: }
357:
358: draw_wideframe(can)
359: struct canvas *can;
360: {
361: struct canvas fakecan;
362: double xmin,xmax,ymin,ymax,xmid,ymid,dx,dy;
363: POINT s,e;
364:
365: fakecan = *can;
366: dx = 10*(can->xmax-can->xmin); dy = 10*(can->ymax-can->ymin);
367: xmid = (can->xmax+can->xmin)/2; ymid = (can->ymax+can->ymin)/2;
368:
369: fakecan.xmin = xmid-dx/2; fakecan.xmax = xmid+dx/2;
370: fakecan.ymin = ymid-dy/2; fakecan.ymax = ymid+dy/2;
371:
372: XFillRectangle(display,can->window,clearGC,
373: 0,0,can->width,can->height);
374: pline(display,&fakecan,can->window);
375: XC(s) = can->width*9/20; YC(s) = can->height*9/20;
376: XC(e) = can->width*11/20; YC(e) = can->height*11/20;
377: draw_frame0(can->window,s,e);
378: }
379:
380: create_popup(parent,name,str,shell,dialog)
381: Widget parent;
382: char *name,*str;
383: Widget *shell,*dialog;
384: {
385: Arg arg[3];
386: Position x,y;
387:
388: XtTranslateCoords(parent,0,0,&x,&y);
389: XtSetArg(arg[0],XtNx,x); XtSetArg(arg[1],XtNy,y);
390: *shell = XtCreatePopupShell(name,transientShellWidgetClass,parent,arg,2);
391: XtSetArg(arg[0],XtNlabel,str);
392: *dialog = XtCreateManagedWidget("dialog",dialogWidgetClass,*shell,arg,1);
393: }
394:
395: warning(can,s)
396: struct canvas *can;
397: char *s;
398: {
399: void popdown_warning();
400: Widget warnshell,warndialog;
401: Position x,y;
402: Arg arg[3];
403:
404: if ( !can->shell )
405: return;
406: create_popup(can->shell,"warning",s,&warnshell,&warndialog);
407: XawDialogAddButton(warndialog,"dismiss",popdown_warning,warnshell);
408: XtPopup(warnshell,XtGrabNone);
409: }
410:
411: void popdown_warning(w,client,call)
412: Widget w;
413: XtPointer client,call;
414: {
415: XtPopdown(client); XtDestroyWidget(client);
416: }
417:
418: void show_formula(w,can,calldata)
419: Widget w;
420: struct canvas *can;
421: XtPointer calldata;
422: {
423: void popdown_formula();
424: Widget fshell,fdialog;
425: char buf[BUFSIZ];
426:
427: soutput_init(buf); sprintexpr(CO,(Obj)can->formula);
428: create_popup(can->shell,"formula",buf,&fshell,&fdialog);
429: XawDialogAddButton(fdialog,"dismiss",popdown_formula,w);
430: XtSetSensitive(w,False); XtPopup(fshell,XtGrabNone);
431: }
432:
433: void popdown_formula(w,fbutton,call)
434: Widget w,fbutton;
435: XtPointer call;
436: {
437: Widget shell = XtParent(XtParent(w));
438: XtPopdown(shell); XtDestroyWidget(shell);
439: XtSetSensitive(fbutton,True);
440: }
441:
442: #define NormalSelection ButtonPressMask|ButtonReleaseMask|Button1MotionMask|Button3MotionMask|StructureNotifyMask| ExposureMask
443:
444: create_canvas(can)
445: struct canvas *can;
446: {
447: XEvent event;
448: Widget box,frame,commands,
449: coords,quit,wide,precise,canvas,formula;
450: Window window;
451: Pixmap pix;
452: int i,width,height;
453: Arg arg[6];
454: char buf[BUFSIZ];
455:
456: width = can->width; height = can->height;
457:
458: sprintf(buf,"%s : %d/%d", can->wname?can->wname:"Plot",
459: remotes,can->index);
460: XtSetArg(arg[0],XtNiconName,buf);
461: can->shell =
462: XtCreatePopupShell("shell",topLevelShellWidgetClass,toplevel,arg,1);
463:
464: XtSetArg(arg[0],XtNhSpace,0);
465: XtSetArg(arg[1],XtNvSpace,0);
466: XtSetArg(arg[2],XtNborderWidth,0);
467: box = XtCreateManagedWidget("box",boxWidgetClass,can->shell,arg,3);
468:
469: frame = XtCreateManagedWidget("form",formWidgetClass,box,NULL,0);
470:
471: XtSetArg(arg[0],XtNorientation,XtorientHorizontal);
472: XtSetArg(arg[1],XtNborderWidth,0);
473: commands = XtCreateManagedWidget("commands",boxWidgetClass,frame,arg,2);
474:
475: quit = XtCreateManagedWidget("quit",commandWidgetClass,commands,NULL,0);
476: XtAddCallback(quit,XtNcallback,destroy_canvas,can);
477: can->wideb = wide =
478: XtCreateManagedWidget("wide",toggleWidgetClass,commands,NULL,0);
479: XtAddCallback(wide,XtNcallback,wide_canvas,can);
480: can->preciseb = precise =
481: XtCreateManagedWidget("precise",toggleWidgetClass,commands,NULL,0);
482: XtAddCallback(precise,XtNcallback,precise_canvas,can);
483: formula =
484: XtCreateManagedWidget("formula",commandWidgetClass,commands,NULL,0);
485: XtAddCallback(formula,XtNcallback,show_formula,can);
486: can->noaxisb =
487: XtCreateManagedWidget("noaxis",toggleWidgetClass,commands,NULL,0);
488: XtAddCallback(can->noaxisb,XtNcallback,noaxis_canvas,can);
489:
490: XtSetArg(arg[0],XtNfromVert,commands);
491: XtSetArg(arg[1],XtNwidth,width);
492: XtSetArg(arg[2],XtNheight,height);
493: canvas = XtCreateManagedWidget("canvas",simpleWidgetClass,frame,arg,3);
494:
495: XtSetArg(arg[0],XtNfromVert,canvas);
496: XtSetArg(arg[1],XtNheight,5);
497: XtSetArg(arg[2],XtNwidth,width);
498: XtSetArg(arg[3],XtNorientation,XtorientHorizontal);
499: XtSetArg(arg[4],XtNsensitive,False);
500: can->xdone =
501: XtCreateManagedWidget("xdone",scrollbarWidgetClass,frame,arg,5);
502:
503: XtSetArg(arg[0],XtNfromHoriz,canvas);
504: XtSetArg(arg[1],XtNfromVert,commands);
505: XtSetArg(arg[2],XtNwidth,5);
506: XtSetArg(arg[3],XtNheight,height);
507: XtSetArg(arg[4],XtNorientation,XtorientVertical);
508: XtSetArg(arg[5],XtNsensitive,False);
509: can->ydone =
510: XtCreateManagedWidget("ydone",scrollbarWidgetClass,frame,arg,6);
511:
512: XtSetArg(arg[0],XtNfromVert,can->xdone);
513: XtSetArg(arg[1],XtNorientation,XtorientHorizontal);
514: XtSetArg(arg[2],XtNborderWidth,0);
515: coords = XtCreateManagedWidget("coords",boxWidgetClass,frame,arg,3);
516:
517: XtSetArg(arg[0],XtNwidth,LABELWIDTH);
518: can->xcoord = XtCreateManagedWidget("xcoord",labelWidgetClass,coords,arg,1);
519: XtSetArg(arg[0],XtNwidth,LABELWIDTH);
520: can->ycoord = XtCreateManagedWidget("ycoord",labelWidgetClass,coords,arg,1);
521:
522: XtAddEventHandler(canvas,ButtonPressMask,False,press,can);
523: XtAddEventHandler(canvas,ButtonReleaseMask,False,release,can);
524: XtAddEventHandler(canvas,Button1MotionMask,False,motion,can);
525: XtAddEventHandler(canvas,Button3MotionMask,False,motion,can);
526: XtAddEventHandler(canvas,StructureNotifyMask,False,structure,can);
527: XtAddEventHandler(canvas,ExposureMask,False,structure,can);
528:
529: if ( can->mode == MODE_CONPLOT ) {
530: Widget scale;
531:
532: XtSetArg(arg[0],XtNwidth,LABELWIDTH);
533: can->level = XtCreateManagedWidget("level",labelWidgetClass,
534: commands,arg,1);
535:
536: XtSetArg(arg[0],XtNsensitive,True);
537: XtSetValues(can->ydone,arg,1);
538: if ( depth >= 2 ) {
539: XtAddCallback(can->ydone,XtNjumpProc,jumpproc,can);
540: XtAddEventHandler(can->ydone,ButtonReleaseMask,False,lrelease,can);
541: } else {
542: XtAddCallback(can->ydone,XtNjumpProc,jumpproc_m,can);
543: XtAddEventHandler(can->ydone,ButtonReleaseMask,False,lrelease_m,can);
544: }
545: }
546: if ( can->mode != MODE_IFPLOT || !qpcheck((Obj)can->formula) )
547: XtSetSensitive(precise,False);
548: XtPopup(can->shell,XtGrabNone);
549:
550: window = can->window = XtWindow(canvas);
551: pix = can->pix = XCreatePixmap(display,window,width,height,depth);
552: XFillRectangle(display,pix,clearGC,0,0,width,height);
553: XDefineCursor(display,window,normalcur);
554: XFlush(display);
555: current_can = can;
556: }
557:
558: alloc_pixmap(can)
559: struct canvas *can;
560: {
561: can->pix = XCreatePixmap(display,can->window,
562: can->width,can->height,depth);
563: XFillRectangle(display,can->pix,clearGC,0,0,can->width,can->height);
564: }
565:
566: static XrmOptionDescRec options[] = {
567: {"-reverse","*reverse",XrmoptionNoArg,"on"},
568: {"-fg","*foreground",XrmoptionSepArg,NULL},
569: {"-bg","*background",XrmoptionSepArg,NULL},
570: };
571:
572: #define offset(name) XtOffset(struct PlotResources *,name)
573:
574: static XtResource resources[] = {
575: {"reverse","Reverse",XtRBoolean,sizeof(Boolean),
576: offset(Reverse),XtRBoolean,&reverse},
577: {"foreground","Foreground",XtRString,sizeof(char *),
578: offset(ForeName),XtRString,NULL},
579: {"foreground","Foreground",XtRPixel,sizeof(Pixel),
580: offset(ForePixel),XtRPixel,(XtPointer)&forePixel},
581: {"background","Background",XtRString,sizeof(char *),
582: offset(BackName),XtRString,NULL},
583: {"background","Background",XtRPixel,sizeof(Pixel),
584: offset(BackPixel),XtRPixel,(XtPointer)&backPixel},
585: {"dash","Dash",XtRString,sizeof(char *),
586: offset(DashName),XtRString,NULL},
587: {"dash","Dash",XtRPixel,sizeof(Pixel),
588: offset(DashPixel),XtRPixel,(XtPointer)&dashPixel},
589: };
590:
591: init_plot_display(argc,argv)
592: int argc;
593: char **argv;
594: {
595: int ac;
596: char **av;
597: unsigned int tmp;
598:
599: for ( ac = argc, av = argv; ac; ac--, av++ )
600: if ( index(*av,':') )
601: dname = *av;
602: XtToolkitInitialize();
603: app_con = XtCreateApplicationContext();
604: display = XtOpenDisplay(app_con,dname,"plot","Plot",
605: options,XtNumber(options),&argc,argv);
606: if ( !display ) {
607: fprintf(stderr,"Can't open display\n");
608: exit(1);
609: }
610: toplevel = XtAppCreateShell(0,"Plot",applicationShellWidgetClass,
611: display,0,0);
612:
613: forePixel = blackPixel; backPixel = whitePixel;
614: dashPixel = blackPixel;
615: XtGetApplicationResources(toplevel,&PlotResources,
616: resources,XtNumber(resources),NULL,0);
617: display = XtDisplay(toplevel);
618: scrn = DefaultScreen(display);
619: depth = DefaultDepth(display,scrn);
620: rootwin = RootWindow(display,scrn);
621:
622: if ( reverse ) {
623: tmp = forePixel; forePixel = backPixel; backPixel = tmp;
624: }
625:
626: create_gc();
627: create_font();
628: create_cursors();
629: }
630:
631: static char *scalefont = "*-8-80-*";
632:
633: create_font() {
634: Font sfid;
635:
636: sfid = XLoadFont(display,scalefont);
637: sffs = XQueryFont(display,sfid);
638: XSetFont(display,scaleGC,sfid);
639: }
640:
641: create_gc() {
642: static XColor color = {0,0x0,0x0,0x0,DoRed|DoGreen|DoBlue,0};
643: int i,b,step;
644:
645: drawGC = XCreateGC(display,rootwin,0,NULL);
646: dashGC = XCreateGC(display,rootwin,0,NULL);
647: hlGC = XCreateGC(display,rootwin,0,NULL);
648: clearGC = XCreateGC(display,rootwin,0,NULL);
649: scaleGC = XCreateGC(display,rootwin,0,NULL);
650: xorGC = XCreateGC(display,rootwin,0,NULL);
651: colorGC = XCreateGC(display,rootwin,0,NULL);
652: XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,drawGC);
653: XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,dashGC);
654: XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,clearGC);
655: XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,scaleGC);
656: XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,xorGC);
657: XCopyGC(display,DefaultGC(display,scrn),(1L<<(GCLastBit+1))-1,colorGC);
658: XSetForeground(display,drawGC,forePixel);
659: XSetForeground(display,scaleGC,forePixel);
660: XSetForeground(display,clearGC,backPixel);
661: XSetForeground(display,xorGC,forePixel^backPixel);
662: XSetFunction(display,xorGC,GXxor);
663: XSetForeground(display,dashGC,dashPixel);
664: XSetLineAttributes(display,dashGC,1,LineOnOffDash,CapButt,JoinRound);
665:
666: color.red = color.green = color.blue = 0xffff/2;
667: XAllocColor(display,DefaultColormap(display,scrn),&color);
668: XSetForeground(display,hlGC,color.pixel);
669: color.red = 0xffff; color.green = color.blue = 0;
670: XAllocColor(display,DefaultColormap(display,scrn),&color);
671: XSetForeground(display,colorGC,color.pixel);
672: }
673:
674: create_cursors() {
675: static XColor fg = {0, 0x0, 0x0, 0x0,DoRed|DoGreen|DoBlue,0};
676: static XColor bg = {0, 0xffff, 0xffff, 0xffff,DoRed|DoGreen|DoBlue,0};
677:
678: XAllocColor(display,DefaultColormap(display,scrn),&fg);
679: XAllocColor(display,DefaultColormap(display,scrn),&bg);
680: normalcur = create_cursor(h_bits,h_m_bits,h_width,h_height,
681: h_x_hot,h_y_hot,&fg,&bg);
682: runningcur = create_cursor(ht_bits,ht_m_bits,ht_width,ht_height,
683: ht_width/2,ht_height/2,&fg,&bg);
684: errorcur = create_cursor(m_bits,m_m_bits,m_width,m_height,
685: m_width/2,m_height/2,&fg,&bg);
686: }
687:
688: Cursor create_cursor(image,mask,width,height,xhot,yhot,fg,bg)
689: char *image,*mask;
690: int width,height,xhot,yhot;
691: XColor *fg,*bg;
692: {
693: Pixmap ipix,mpix;
694:
695: ipix = XCreateBitmapFromData(display,rootwin,image,width,height);
696: mpix = XCreateBitmapFromData(display,rootwin,mask,width,height);
697: return XCreatePixmapCursor(display,ipix,mpix,fg,bg,xhot,yhot);
698: }
699:
700: copy_to_canvas(can)
701: struct canvas *can;
702: {
703: if ( display ) {
704: XCopyArea(display,can->pix,can->window,
705: drawGC,0,0,can->width,can->height,0,0);
706: pline(display,can,can->window);
707: XFlush(display);
708: }
709: }
710:
711: copy_subimage(subcan,can,pos)
712: struct canvas *subcan,*can;
713: XPoint pos;
714: {
715: if ( display ) {
716: XCopyArea(display,subcan->pix,can->pix,
717: drawGC,0,0,subcan->width,subcan->height,pos.x,pos.y);
718: XFlush(display);
719: }
720: }
721:
722: #include <signal.h>
723: #include <fcntl.h>
724:
725: set_selection() {
726: if ( current_can ) {
727: XSelectInput(display,current_can->window,0);
728: XFlush(display);
729: }
730: }
731:
732: reset_selection() {
733: if ( current_can ) {
734: XSelectInput(display,current_can->window,NormalSelection);
735: XFlush(display);
736: }
737: }
738:
739: set_busy(can)
740: struct canvas *can;
741: {
742: busy = 1;
743: XtSetSensitive(can->wideb,False);
744: XtSetSensitive(can->preciseb,False);
745: XtSetSensitive(can->noaxisb,False);
746: XFlush(display);
747: }
748:
749: reset_busy(can)
750: struct canvas *can;
751: {
752: busy = 0;
753: if ( can->window ) {
754: XtSetSensitive(can->wideb,True);
755: XtSetSensitive(can->noaxisb,True);
756: if ( can->mode == MODE_IFPLOT && qpcheck((Obj)can->formula) )
757: XtSetSensitive(can->preciseb,True);
758: XFlush(display);
759: }
760: }
761:
762: reset_current_computation()
763: {
764: if ( current_can ) {
765: reset_selection(); reset_busy(current_can);
766: define_cursor(current_can->window,normalcur);
767: }
768: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ox_plot_xevent.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / plot