?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@16053 f3b2605a-c512-4ea7-a41b...
[lammps.git] / tools / xmovie / scene.c
blobe021aa580f479b1aabf2b7dca2f0022a741ef0a9
1 /* **************************************************************** */
2 /* functions to deal with drawing atoms, etc. */
3
4 #include <stdio.h>
5
6 #include <X11/Intrinsic.h>
7 #include <X11/StringDefs.h>
8 #include <X11/Shell.h>
9
10 #include <X11/Xaw/Label.h>
11 #include <X11/Xaw/Cardinals.h>
12
13 #include <X11/xpm.h>
14
15 #include "xmovie.h"
16
17 /* hard offsets so we dont draw on exact edge of screen */
18
19 #define HOFFSET 5
20 #define VOFFSET 5
21
22 typedef XArc POINT;
23 typedef XSegment LINE;
24
25 /* **************************************************************** */
26 /* local prototypes */
27
28 PRIVATE LINE *ClipAndScaleLines(BOND *b, int cnt, int *nlines);
29 PRIVATE POINT *ClipAndScalePoints(POSITION *p, int cnt, Dimension diam,
30 int *npoints);
31 PRIVATE void DrawPoints(Display *display, Drawable drawable, GC gc,
32 POINT *points, int npoints);
33 PRIVATE void DrawLines(Display *display, Drawable drawable, GC gc,
34 LINE *lines, int nlines);
35 PRIVATE void SceneDraw(void);
36 PRIVATE void SetAllColors(void);
37 PRIVATE void MotionUpdate(void);
38
39 /* **************************************************************** */
40 /* local data */
41
42 static Widget Scene;
43 static Widget Shell;
44 static Pixmap Buffer;
45
46 static GC *gc = (GC *) NULL;
47 static GC *bondgc = (GC *) NULL;
48 static GC bggc;
49 static int first = 1;
50 static Dimension Height, Width;
51
52 XtIntervalId TimeOut = (XtIntervalId) NULL;
53 static String null_string = "";
54
55 /* **************************************************************** */
56
57 Widget CreateScene(Widget parent, char *name)
58 {
59 Shell = XtCreatePopupShell("sceneshell", transientShellWidgetClass,
60 parent, NULL, ZERO);
61
62 Scene = XtVaCreateManagedWidget(name, labelWidgetClass, Shell,
63 XtNlabel, &null_string, NULL);
64
65 gc = (GC *) XtMalloc(Common.natomcolors * sizeof(GC));
66 bondgc = (GC *) XtMalloc(Common.nbondcolors * sizeof(GC));
67
68 XtPopup(Shell, XtGrabNone);
69
70 return(Scene);
71 }
72
73 PRIVATE void SceneDraw(void)
74 {
75 DATA *dptr;
76 POINT *points;
77 LINE *lines;
78 POSITION *p;
79 BOND *b;
80 int i;
81 int npoints, nlines;
82 char s[40];
83 static int last_step = -1;
84
85 if (!XtIsRealized(Scene)) return;
86
87 if (first) {
88 SetAllColors();
89 first = 0;
90 }
91
92 /* Clear everything */
93
94 if (Common.step >= Common.ndata) return;
95 if (Common.step < 0) return;
96
97 XFillRectangle(XtDisplay(Scene), Buffer, bggc, 0, 0,
98 Width, Height);
99
100 /* XClearWindow(XtDisplay(Scene), XtWindow(Scene)); */
101
102 /* find the data */
103
104 dptr = Common.dataptr + Common.step;
105
106 /* loop over colors */
107
108 b = dptr->bonds;
109 for(i = 0; i < Common.nbondcolors; i++) {
110 if (Common.bonds_visible[i]) {
111 lines = ClipAndScaleLines(b, dptr->nbtypes[i],&nlines);
112 DrawLines(XtDisplay(Scene), Buffer, bondgc[i],
113 lines, nlines);
114 }
115 b += dptr->nbtypes[i];
116 }
117
118 p = dptr->positions;
119 for(i = 0; i < Common.natomcolors; i++){
120 if (Common.atoms_visible[i]) {
121 points = ClipAndScalePoints(p, dptr->natypes[i],
122 Common.diameter[i], &npoints);
123 DrawPoints(XtDisplay(Scene), Buffer, gc[i], points,
124 npoints);
125 }
126 p += dptr->natypes[i];
127 }
128
129 XCopyArea(XtDisplay(Scene), Buffer, XtWindow(Scene), bggc,
130 0, 0, Width, Height, 0, 0);
131
132 XFlush(XtDisplay(Scene));
133
134 if (Common.step == last_step) return;
135 last_step = Common.step;
136
137 sprintf(s,"Time: %g Frame: %i", dptr->time, Common.step+1);
138 SetTime(s);
139 }
140
141 PRIVATE void MotionUpdate(void)
142 {
143 int next_step;
144
145 SceneUpdate();
146
147 if (Common.saveflag) {
148 char str[24];
149 if (Common.step < 10)
150 sprintf(str,"image00%d.xpm",Common.step);
151 else if (Common.step < 100)
152 sprintf(str,"image0%d.xpm",Common.step);
153 else
154 sprintf(str,"image%d.xpm",Common.step);
155 XpmWriteFileFromPixmap(XtDisplay(Scene),str,Buffer,NULL,NULL);
156 }
157
158 if (!Common.motion) return;
159
160 next_step = CoerceStep(Common.step + Common.dstep);
161
162 if (next_step == Common.step) {
163 RemoveMotion();
164 return;
165 }
166
167 Common.step = next_step;
168
169 TimeOut = (XtIntervalId) NULL;
170
171 InstallMotion();
172 }
173
174 void SceneUpdate(void)
175 {
176
177 if (!Common.init) return;
178
179 /* Common.step = CoerceStep(Common.step); */
180
181 SceneDraw();
182 }
183
184 void SceneSave(void)
185 {
186 char str[24];
187 sprintf(str,"image.%d.xpm",Common.step);
188 XpmWriteFileFromPixmap(XtDisplay(Scene),str,Buffer,NULL,NULL);
189 }
190
191 int CoerceStep(int step)
192 {
193 if (step >= Common.ndata) return (Common.ndata-1);
194 if (step < 0) return(0);
195 return(step);
196 }
197
198 void ExposeScene(Widget w, XEvent *event, String *strings,
199 Cardinal *nstrings)
200 {
201 NewDataSetup();
202 SceneDraw();
203 }
204
205
206 void InstallMotion(void)
207 {
208 Common.motion = 1;
209
210 if (TimeOut == (XtIntervalId) NULL)
211 TimeOut = XtAppAddTimeOut(XtWidgetToApplicationContext(Scene),
212 Common.delay,
213 (XtTimerCallbackProc) MotionUpdate, NULL);
214 }
215
216 void RemoveMotion(void)
217 {
218 if (!Common.motion) return;
219
220 Common.motion = 0;
221 Common.step = CoerceStep(Common.step - Common.dstep);
222
223 if (TimeOut != (XtIntervalId) NULL) XtRemoveTimeOut(TimeOut);
224 TimeOut = (XtIntervalId) NULL;
225 }
226
227 void SceneSize(Dimension *width, Dimension *height)
228 {
229 XtVaGetValues(Scene, XtNwidth, width, XtNheight, height, NULL);
230 }
231
232 PRIVATE POINT *ClipAndScalePoints(POSITION *pos, int cnt, Dimension diam,
233 int *npoints)
234 {
235 register int i;
236 BOUND range;
237 register POINT *p;
238 Dimension width, height;
239 static int max_points = 0;
240 static POINT *points = (POINT *) NULL;
241
242 range.low = Common.position - Common.thickness * 0.5;
243 range.high = Common.position + Common.thickness * 0.5;
244
245 /* use a static buffer so minimize number of allocations */
246 /* didnt use Realloc because dont want data copied */
247
248 *npoints = cnt;
249 if (*npoints > max_points) {
250 XtFree((char *) points);
251 points = (POINT *) XtMalloc( *npoints * sizeof(POINT));
252 max_points = *npoints;
253 }
254 p = points;
255
256 if (cnt < 1) return(points);
257
258 SceneSize(&width, &height);
259 width -= 2*HOFFSET;
260 height -= 2*VOFFSET;
261
262 /* translate x, y, z to x and y in window. */
263 /* note: index and type are also passed, but may not be used */
264
265 switch(3*Common.direction + Common.axis){
266 case 0: /* negative direction, x axis */
267 for(i = cnt; i; i--, pos++) {
268 if (pos->x > range.high) continue;
269 if (pos->x < range.low) continue;
270 p->x = width -
271 (pos->z * Common.scale + Common.offset[2]);
272 p->y = height -
273 (pos->y * Common.scale + Common.offset[1]);
274 p->width = diam;
275 p->height = diam;
276 p++;
277 }
278 break;
279 case 1: /* negative direction, y axis */
280 for(i = cnt; i; i--, pos++) {
281 if (pos->y > range.high) continue;
282 if (pos->y < range.low) continue;
283 p->x = pos->x * Common.scale + Common.offset[0];
284 p->y = pos->z * Common.scale + Common.offset[2];
285 p->width = diam;
286 p->height = diam;
287 p++;
288 }
289 break;
290 case 2: /* negative direction, z axis */
291 for(i = cnt; i; i--, pos++) {
292 if (pos->z > range.high) continue;
293 if (pos->z < range.low) continue;
294 p->x = pos->x * Common.scale + Common.offset[0];
295 p->y = height -
296 (pos->y * Common.scale + Common.offset[1]);
297 p->width = diam;
298 p->height = diam;
299 p++;
300 }
301 break;
302 case 3: /* positive direction, x axis */
303 for(i = cnt; i; i--, pos++) {
304 if (pos->x > range.high) continue;
305 if (pos->x < range.low) continue;
306 p->x = pos->z * Common.scale + Common.offset[2];
307 p->y = height -
308 (pos->y * Common.scale + Common.offset[1]);
309 p->width = diam;
310 p->height = diam;
311 p++;
312 }
313 break;
314
315 case 4: /* positive direction, y axis */
316 for(i = cnt; i; i--, pos++) {
317 if (pos->y > range.high) continue;
318 if (pos->y < range.low) continue;
319 p->x = pos->x * Common.scale + Common.offset[0];
320 p->y = height -
321 (pos->z * Common.scale + Common.offset[2]);
322 p->width = diam;
323 p->height = diam;
324 p++;
325 }
326 break;
327
328
329 case 5: /* postive direction, z axis */
330 for(i = cnt; i; i--, pos++) {
331 if (pos->z > range.high) continue;
332 if (pos->z < range.low) continue;
333 p->x = pos->x * Common.scale + Common.offset[0];
334 p->y = pos->y * Common.scale + Common.offset[1];
335 p->width = diam;
336 p->height = diam;
337 p++;
338 }
339 break;
340 }
341
342 *npoints = p - points;
343
344 /* add the hard offsets so we dont draw on edge of screen */
345 /* center drawing based on width, height */
346
347 for(i = *npoints, p = points; i; i--, p++) {
348 p->x += HOFFSET - p->width/2;
349 p->y += VOFFSET - p->height/2;
350 }
351
352 return(points);
353 }
354
355
356 PRIVATE void DrawPoints(Display *display, Drawable drawable, GC gc,
357 POINT *points, int npoints)
358 {
359 register int full_circle;
360 register int i;
361 register POINT *p;
362
363 if (npoints <= 0) return;
364
365 /* this version has POINT typedef'd to XArc, so we need to */
366 /* fill in other fields before drawing */
367
368 full_circle = 64*360;
369
370 for(i = npoints, p = points; i ; i--, p++){
371 p->angle1 = 0;
372 p->angle2 = full_circle;
373 }
374
375 if (Common.hollow) {
376 if (Common.opaque)
377 XFillArcs(display, drawable, bggc, points, npoints);
378 XDrawArcs(display, drawable, gc, points, npoints);
379 }
380 else
381 XFillArcs(display, drawable, gc, points, npoints);
382
383 }
384
385 PRIVATE LINE *ClipAndScaleLines(BOND *bond, int cnt, int *nlines)
386 {
387 register int i;
388 BOUND range;
389 register LINE *l;
390 Dimension width, height;
391 static int max_lines = 0;
392 static LINE *lines = (LINE *) NULL;
393
394 range.low = Common.position - Common.thickness * 0.5;
395 range.high = Common.position + Common.thickness * 0.5;
396
397 /* use a static buffer so minimize number of allocations */
398 /* didnt use Realloc because dont want data copied */
399
400 *nlines = cnt;
401 if (*nlines > max_lines) {
402 XtFree((char *) lines);
403 lines = (LINE *) XtMalloc( *nlines * sizeof(LINE));
404 max_lines = *nlines;
405 }
406 l = lines;
407
408 if (cnt < 1) return(lines);
409
410 SceneSize(&width, &height);
411 width -= 2*HOFFSET;
412 height -= 2*VOFFSET;
413
414 /* translate x, y, z to x and y in window. */
415
416 switch(3*Common.direction + Common.axis){
417 case 0: /* negative direction, x axis */
418 for(i = cnt; i; i--, bond++) {
419 if (bond->atom1->x > range.high) continue;
420 if (bond->atom1->x < range.low) continue;
421 if (bond->atom2->x > range.high) continue;
422 if (bond->atom2->x < range.low) continue;
423 l->x1 = width -
424 (bond->atom1->z*Common.scale+Common.offset[2]);
425 l->y1 = height -
426 (bond->atom1->y*Common.scale+Common.offset[1]);
427 l->x2 = width -
428 (bond->atom2->z*Common.scale+Common.offset[2]);
429 l->y2 = height -
430 (bond->atom2->y*Common.scale+Common.offset[1]);
431 l++;
432 }
433 break;
434 case 1: /* negative direction, y axis */
435 for(i = cnt; i; i--, bond++) {
436 if (bond->atom1->y > range.high) continue;
437 if (bond->atom1->y < range.low) continue;
438 if (bond->atom2->y > range.high) continue;
439 if (bond->atom2->y < range.low) continue;
440 l->x1 = bond->atom1->x*Common.scale + Common.offset[0];
441 l->y1 = bond->atom1->z*Common.scale + Common.offset[2];
442 l->x2 = bond->atom2->x*Common.scale + Common.offset[0];
443 l->y2 = bond->atom2->z*Common.scale + Common.offset[2];
444 l++;
445 }
446 break;
447 case 2: /* negative direction, z axis */
448 for(i = cnt; i; i--, bond++) {
449 if (bond->atom1->z > range.high) continue;
450 if (bond->atom1->z < range.low) continue;
451 if (bond->atom2->z > range.high) continue;
452 if (bond->atom2->z < range.low) continue;
453 l->x1 = bond->atom1->x*Common.scale + Common.offset[0];
454 l->y1 = height -
455 (bond->atom1->y*Common.scale+Common.offset[1]);
456 l->x2 = bond->atom2->x*Common.scale + Common.offset[0];
457 l->y2 = height -
458 (bond->atom2->y*Common.scale+Common.offset[1]);
459 l++;
460 }
461 break;
462 case 3: /* positive direction, x axis */
463 for(i = cnt; i; i--, bond++) {
464 if (bond->atom1->x > range.high) continue;
465 if (bond->atom1->x < range.low) continue;
466 if (bond->atom2->x > range.high) continue;
467 if (bond->atom2->x < range.low) continue;
468 l->x1 = bond->atom1->z*Common.scale + Common.offset[2];
469 l->y1 = height -
470 (bond->atom1->y*Common.scale+Common.offset[1]);
471 l->x2 = bond->atom2->z*Common.scale + Common.offset[2];
472 l->y2 = height -
473 (bond->atom2->y*Common.scale+Common.offset[1]);
474 l++;
475 }
476 break;
477
478 case 4: /* positive direction, y axis */
479 for(i = cnt; i; i--, bond++) {
480 if (bond->atom1->y > range.high) continue;
481 if (bond->atom1->y < range.low) continue;
482 if (bond->atom2->y > range.high) continue;
483 if (bond->atom2->y < range.low) continue;
484 l->x1 = bond->atom1->x*Common.scale + Common.offset[0];
485 l->y1 = height -
486 (bond->atom1->z*Common.scale+Common.offset[2]);
487 l->x2 = bond->atom2->x*Common.scale + Common.offset[0];
488 l->y2 = height -
489 (bond->atom2->z*Common.scale+Common.offset[2]);
490 l++;
491 }
492 break;
493
494
495 case 5: /* postive direction, z axis */
496 for(i = cnt; i; i--, bond++) {
497 if (bond->atom1->z > range.high) continue;
498 if (bond->atom1->z < range.low) continue;
499 if (bond->atom2->z > range.high) continue;
500 if (bond->atom2->z < range.low) continue;
501 l->x1 = bond->atom1->x*Common.scale + Common.offset[0];
502 l->y1 = bond->atom1->y*Common.scale + Common.offset[1];
503 l->x2 = bond->atom2->x*Common.scale + Common.offset[0];
504 l->y2 = bond->atom2->y*Common.scale + Common.offset[1];
505 l++;
506 }
507 break;
508 }
509
510 *nlines = l - lines;
511
512 /* add the hard offsets so we dont draw on edge of screen */
513
514 for(i = *nlines, l = lines; i; i--, l++) {
515 l->x1 += HOFFSET;
516 l->y1 += VOFFSET;
517 l->x2 += HOFFSET;
518 l->y2 += VOFFSET;
519 }
520
521 return(lines);
522 }
523
524
525 PRIVATE void DrawLines(Display *display, Drawable drawable, GC gc,
526 LINE *lines, int nlines)
527 {
528 if (nlines <= 0) return;
529
530 XDrawSegments(display, drawable, gc, lines, nlines);
531 }
532
533 void Setup(void)
534 {
535 NewDataSetup();
536 SpeedUpdate();
537 UpdateRadios();
538 }
539
540 void NewDataSetup(void)
541 {
542 static int have_pixmap = 0;
543
544 BOUND *cb;
545 int i;
546 float longest, f;
547 Dimension width, height;
548
549 SceneSize(&Width, &Height);
550
551 if (have_pixmap) XFreePixmap(XtDisplay(Scene), Buffer);
552
553 Buffer = XCreatePixmap(XtDisplay(Scene),
554 RootWindowOfScreen(XtScreen(Scene)), Width, Height,
555 DefaultDepthOfScreen(XtScreen(Scene)));
556
557 have_pixmap = 1;
558
559 /* determine global scaling and offset factors */
560 /* offset + scale * coordinate = pixel */
561
562 longest = 0.0;
563 for(i = 3, cb = Common.bounds; i ; i--, cb++)
564 if ((f = (cb->high) - (cb->low)) > longest) longest = f;
565
566 SceneSize(&Width, &Height);
567 width = Width;
568 height = Height;
569
570 width -= HOFFSET*2;
571 height -= VOFFSET*2;
572
573 Common.scale = (width < height) ? width/longest : height/longest;
574
575 for(i = 0; i < 3; i++)
576 Common.offset[i] = - Common.bounds[i].low * Common.scale;
577
578 PositionUpdate();
579 ThicknessUpdate();
580 }
581
582 /* **************************************************************** */
583
584 void SetAtomColors(Pixel *fg)
585 {
586 int i;
587 XGCValues xgc;
588
589 XtVaGetValues(Scene, XtNbackground, &xgc.background, NULL);
590
591 xgc.function = GXcopy;
592
593 for(i = 0; i < Common.natomcolors; i++) {
594 if (gc[i]) XFreeGC(XtDisplay(Scene), gc[i]);
595 xgc.foreground = fg[i];
596 gc[i] = XCreateGC(XtDisplay(Scene), XtWindow(Scene),
597 GCFunction | GCBackground | GCForeground, &xgc);
598 }
599
600 if (bggc) XFreeGC(XtDisplay(Scene), bggc);
601 xgc.foreground = xgc.background;
602 bggc = XCreateGC(XtDisplay(Scene), XtWindow(Scene),
603 GCFunction | GCBackground | GCForeground, &xgc);
604
605 }
606
607 void SetBGColor(Pixel bg)
608 {
609 XGCValues xgc;
610
611 XtVaSetValues(Scene, XtNbackground, bg, NULL);
612
613 if (bggc) XFreeGC(XtDisplay(Scene), bggc);
614
615 xgc.function = GXcopy;
616 xgc.foreground = xgc.background = bg;
617
618 bggc = XCreateGC(XtDisplay(Scene), XtWindow(Scene),
619 GCFunction | GCBackground | GCForeground, &xgc);
620
621 }
622
623 /* **************************************************************** */
624
625 void SetBondColors(Pixel *fg, Dimension *thick)
626 {
627 int i;
628 XGCValues xgc;
629
630 XtVaGetValues(Scene, XtNbackground, &xgc.background, NULL);
631
632 xgc.function = GXcopy;
633
634 for(i = 0; i < Common.nbondcolors; i++) {
635 if (bondgc[i]) XFreeGC(XtDisplay(Scene), bondgc[i]);
636 xgc.foreground = fg[i];
637 xgc.line_width = thick[i];
638 bondgc[i] = XCreateGC(XtDisplay(Scene), XtWindow(Scene),
639 GCFunction | GCBackground | GCForeground | GCLineWidth,
640 &xgc);
641 }
642 }
643
644 /* **************************************************************** */
645
646 PRIVATE void SetAllColors(void)
647 {
648 int i;
649 XGCValues xgc;
650
651 xgc.function = GXcopy;
652 xgc.line_width = 1;
653
654 XtVaGetValues(Scene,
655 XtNbackground, &xgc.background,
656 XtNforeground, &xgc.foreground,
657 NULL);
658
659 for(i = 0; i < Common.natomcolors; i++)
660 gc[i] = XCreateGC(XtDisplay(Scene), XtWindow(Scene),
661 GCFunction | GCBackground | GCForeground, &xgc);
662
663 for(i = 0; i < Common.nbondcolors; i++)
664 bondgc[i] = XCreateGC(XtDisplay(Scene), XtWindow(Scene),
665 GCFunction | GCBackground | GCForeground | GCLineWidth,
666 &xgc);
667
668 xgc.foreground = xgc.background;
669 bggc = XCreateGC(XtDisplay(Scene), XtWindow(Scene),
670 GCFunction | GCBackground | GCForeground, &xgc);
671
672 }
673
LAMMPS Molecular Dynamics Simulator