Diffusion lammps (lammm-master-deprecated) Browse

control.c
111777c6f68blammm-master-deprecated

control.c
View Options

			/* **************************************************************** */
			/* functions to handle control panel (sliders, labels, etc.) */

			#include <stdio.h>
			#include <stdlib.h>

			#include <X11/Intrinsic.h>
			#include <X11/StringDefs.h>
			#include <X11/Shell.h>
			#include <X11/Xos.h>

			#include <X11/Xaw/Cardinals.h>

			#include <X11/Xaw/Box.h>
			#include <X11/Xaw/Command.h>
			#include <X11/Xaw/Dialog.h>
			#include <X11/Xaw/Form.h>
			#include <X11/Xaw/Label.h>
			#include <X11/Xaw/MenuButton.h>
			#include <X11/Xaw/Scrollbar.h>
			#include <X11/Xaw/SimpleMenu.h>
			#include <X11/Xaw/Sme.h>
			#include <X11/Xaw/SmeBSB.h>
			#include <X11/Xaw/Toggle.h>

			#include "xmovie.h"

			#define POPUPSHELLCLASS overrideShellWidgetClass

			/* **************************************************************** */
			/* local typedefs */

			typedef void (*InitFunc)(Widget parent);

			typedef struct {
			char *name;
			XtCallbackProc exec_func;
			XtPointer data;
			InitFunc init_func;
			} ButtonStruct;

			#define NBTN(a) (sizeof(a)/sizeof(ButtonStruct))

			typedef struct {
			char *name;
			long value;
			Widget w;
			} ToggleStruct;

			#define TGLCNT(x) (sizeof(x)/sizeof(ToggleStruct))

			typedef struct {
			char *name;
			XtCallbackProc callback;
			ToggleStruct *buttons;
			int nbuttons;
			Widget lw;
			} RadioStruct;

			typedef struct {
			char *labelname;
			Widget *label;
			char *slidername;
			Widget *slider;
			XtCallbackProc callback;
			} SliderLabelStruct;

			typedef struct {
			Widget *w;
			XtGrabKind grab;
			Bool stop_motion;
			} PopupData;

			/* **************************************************************** */
			/* local prototypes */

			PRIVATE void SetSpeed(float percent);
			PRIVATE void NewSpeed(Widget w, XtPointer client_data, XtPointer percent);
			PRIVATE void SetPosition(float percent);
			PRIVATE void NewPosition(Widget w, XtPointer client_data, XtPointer percent);
			PRIVATE void SetThickness(float percent);
			PRIVATE void NewThickness(Widget w, XtPointer client_data, XtPointer percent);

			PRIVATE void AxisSelect(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void DirectionSelect(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void MotionSelect(Widget w, XtPointer client_data, XtPointer call_data);

			PRIVATE void FindAndDisplaySlider(Widget w, XtCallbackProc func);

			PRIVATE void DrawAxes(void);

			PRIVATE void MakeRadioGroup(Widget parent, RadioStruct *radio);
			PRIVATE void MakeSliderWithLabel(Widget parent, SliderLabelStruct *sl);

			PRIVATE void SetRadio(RadioStruct *radio);

			PRIVATE void do_start(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void do_stop(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void do_restart(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void do_step(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void do_back(Widget w, XtPointer client_data, XtPointer call_data);

			PRIVATE void do_save_off(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void do_save_on(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void do_save_one(Widget w, XtPointer client_data, XtPointer call_data);

			PRIVATE void do_popup(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void cancel_popup(Widget w, XtPointer client_data, XtPointer call_data);

			PRIVATE void init_quit(Widget w);
			PRIVATE void quit_ok(Widget w, XtPointer client_data, XtPointer call_data);

			PRIVATE void init_atoms(Widget w);
			PRIVATE void init_bonds(Widget w);
			PRIVATE void init_bg(Widget w);
			PRIVATE void init_file(Widget w);

			PRIVATE void color_apply(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void bond_apply(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void bg_apply(Widget w, XtPointer client_data, XtPointer call_data);
			PRIVATE void file_apply(Widget w, XtPointer client_data, XtPointer call_data);

			PRIVATE Pixel ConvertColorToPixel(Widget w, String color);
			PRIVATE XtActionProc NoOp(Widget w, XEvent event, String *params,
			Cardinal nparams);

			PRIVATE void visible_toggle(Widget w, XtPointer client_data, XtPointer
			call_data);

			PRIVATE void bvisible_toggle(Widget w, XtPointer client_data, XtPointer
			call_data);

			/* **************************************************************** */
			/* local data */

			static Widget QuitPopup = (Widget) 0,
			AtomPopup = (Widget) 0,
			BondPopup = (Widget) 0,
			BackgroundPopup = (Widget) 0,
			FileColorPopup = (Widget) 0,
			TimeLabel = (Widget) 0,
			SpeedBar = (Widget) 0,
			SpeedLabel = (Widget) 0,
			PositionBar = (Widget) 0,
			PositionLabel = (Widget) 0,
			ThicknessBar = (Widget) 0,
			ThicknessLabel = (Widget) 0,
			Axes = (Widget) 0,
			ReadInfo = (Widget) 0;

			static Widget BGDialog = (Widget) 0,
			FileDialog = (Widget) 0,
			FGDialog = (Widget ) NULL,
			Visible = (Widget ) NULL,
			Invisible = (Widget ) NULL,
			SizeDialog = (Widget ) NULL,
			BFGDialog = (Widget ) NULL,
			BVisible = (Widget ) NULL,
			BInvisible = (Widget ) NULL,
			ThicknessDialog= (Widget ) NULL;

			static PopupData
			QuitData = { &QuitPopup, XtGrabExclusive, True},
			AtomData = { &AtomPopup, XtGrabNone, False },
			BondData = { &BondPopup, XtGrabNone, False },
			BackgroundData = { &BackgroundPopup, XtGrabNone, False },
			FileColorData = { &FileColorPopup, XtGrabNone, False };

			static ButtonStruct Buttons[] = {
			{ "quit", do_popup, (XtPointer) &QuitData, init_quit },
			{ "start", do_start, NULL, NULL },
			{ "stop", do_stop, NULL, NULL },
			{ "restart", do_restart, NULL, NULL },
			{ "step", do_step, NULL, NULL },
			{ "back", do_back, NULL, NULL },
			};

			static ButtonStruct SaveButtons[] = {
			{ "Off while animating", do_save_off, NULL, NULL },
			{ "On while animating", do_save_on , NULL, NULL },
			{ "This snapshot", do_save_one, NULL, NULL },
			};

			static ButtonStruct ColorButtons[] = {
			{ "atoms", do_popup, (XtPointer) &AtomData, init_atoms },
			{ "bonds", do_popup, (XtPointer) &BondData, init_bonds },
			{ "background", do_popup, (XtPointer) &BackgroundData, init_bg },
			{ "filecolor", do_popup, (XtPointer) &FileColorData, init_file }
			};

			static int in_motion;

			static SliderLabelStruct
			SpeedSL = {
			"speed", &SpeedLabel,
			"speedbar", &SpeedBar,
			NewSpeed },
			PositionSL = {
			"position", &PositionLabel,
			"positionbar", &PositionBar,
			NewPosition },
			ThicknessSL = {
			"thickness", &ThicknessLabel,
			"thicknessbar", &ThicknessBar,
			NewThickness }
			;

			static ToggleStruct
			AxisButtons[] = {
			{ "x", 0 },
			{ "y", 1 },
			{ "z", 2 } },
			DirectionButtons[] = {
			{ "vplus", 1 },
			{ "vminus", 0 } },
			MotionButtons[] = {
			{ "mplus", 1 },
			{ "mminus", -1 } }
			;

			static RadioStruct
			AxisRadio = {
			"axis",
			AxisSelect,
			AxisButtons,
			TGLCNT(AxisButtons) },
			DirectionRadio = {
			"viewdir",
			DirectionSelect,
			DirectionButtons,
			TGLCNT(DirectionButtons) },
			MotionRadio = {
			"motiondir",
			MotionSelect,
			MotionButtons,
			TGLCNT(MotionButtons) }
			;

			static int normal = 1;
			static char *null_string = "";

			static XtActionsRec actions[] = {
			{ "NoOp", (XtActionProc) NoOp},
			};

			/* **************************************************************** */

			Widget CreateControl(Widget parent, char *name)
			{
			Widget form, command, button, menu;
			ButtonStruct *bptr;
			int bcnt;

			/* register the new actions */

			XtAppAddActions(XtWidgetToApplicationContext(parent),
			actions, XtNumber(actions));

			/* create a form widget to handle layout */

			form = XtCreateManagedWidget(name, formWidgetClass, parent,
			NULL, ZERO);

			/* create all the command buttons */

			for(bcnt = NBTN(Buttons), bptr = Buttons;bcnt > 0; bcnt--, bptr++){

			/* create a button */

			command = XtCreateManagedWidget(bptr->name,
			commandWidgetClass, form, NULL, ZERO);

			/* Add the function as a callback */

			XtAddCallback(command, XtNcallback, bptr->exec_func,
			bptr->data);

			/* call initialization routine */

			if (bptr->init_func) (bptr->init_func)(command);

			}

			/* create the save menu */

			command = XtCreateManagedWidget("save", menuButtonWidgetClass,
			form, NULL, ZERO);

			menu = XtCreatePopupShell("menu", simpleMenuWidgetClass,
			command, NULL, ZERO);

			for(bcnt=NBTN(SaveButtons), bptr=SaveButtons; bcnt>0; bcnt--,bptr++){
			button = XtCreateManagedWidget(bptr->name, smeBSBObjectClass,
			menu, NULL, ZERO);
			XtAddCallback(button, XtNcallback, bptr->exec_func,bptr->data);
			if (bptr->init_func) (bptr->init_func)(button);
			}

			/* create the color menu */

			command = XtCreateManagedWidget("color", menuButtonWidgetClass,
			form, NULL, ZERO);

			menu = XtCreatePopupShell("menu", simpleMenuWidgetClass,
			command, NULL, ZERO);

			for(bcnt=NBTN(ColorButtons), bptr=ColorButtons; bcnt>0; bcnt--,bptr++){
			button = XtCreateManagedWidget(bptr->name, smeBSBObjectClass,
			menu, NULL, ZERO);
			XtAddCallback(button, XtNcallback, bptr->exec_func,bptr->data);
			if (bptr->init_func) (bptr->init_func)(button);
			}

			/* create a label widget to display time */

			TimeLabel = XtCreateManagedWidget("time", labelWidgetClass,
			form, NULL, ZERO);

			SetTime("Time: 0");

			/* ************************************************ */
			/* create all the sliders */
			/* ************************************************ */


			MakeSliderWithLabel(form, &SpeedSL);
			MakeSliderWithLabel(form, &PositionSL);
			MakeSliderWithLabel(form, &ThicknessSL);

			/* ******************************************************** */
			/* create a radio group for axis, view, motion directions */
			/* ******************************************************** */

			MakeRadioGroup(form, &AxisRadio);
			MakeRadioGroup(form, &DirectionRadio);
			MakeRadioGroup(form, &MotionRadio);

			/* create a label widget to put axes in */

			/* SJP - 10/02, had to add last NULL argument to each call */

			Axes = XtVaCreateManagedWidget("axes", labelWidgetClass, form,
			XtNlabel, null_string,NULL);

			ReadInfo = XtVaCreateManagedWidget("read", labelWidgetClass,
			form, XtNlabel, null_string,NULL);

			}

			PRIVATE XtActionProc NoOp(Widget w, XEvent event, String *params,
			Cardinal nparams)
			{
			return;
			}

			void SetTime(char *s)
			{
			XtVaSetValues(TimeLabel, XtNlabel, s, NULL);
			}

			PRIVATE void SetSpeed(float percent)
			{
			char string[40];
			int speed;

			speed = percent * 100;
			(void) sprintf(string,"Speed: %i", speed);

			XtVaSetValues(SpeedLabel, XtNlabel, string, NULL);
			}

			PRIVATE void NewSpeed(Widget w, XtPointer client_data, XtPointer percent_ptr)
			{
			float percent;

			percent = * (float *) percent_ptr;

			/* delay between frames in milliseconds */

			Common.delay = 30 + 10.0/(0.01 + percent);

			SetSpeed(percent);
			}

			PRIVATE void SetPosition(float position)
			{
			char string[40];

			static char *axis[] = { "X", "Y", "Z" };

			(void) sprintf(string,"%s Position: %6.3f", axis[Common.axis],
			position);

			XtVaSetValues(PositionLabel, XtNlabel, string, NULL);
			}

			PRIVATE void NewPosition(Widget w, XtPointer client_data, XtPointer percent_ptr)
			{
			float percent;
			int i;
			float old_pos;

			percent = * (float *) percent_ptr;

			i = Common.axis;

			old_pos = Common.position;

			Common.position =
			(Common.bounds[i].high - Common.bounds[i].low) * percent +
			Common.bounds[i].low;

			SetPosition(Common.position);

			if (Common.position == old_pos) return;

			if (normal) SceneUpdate();
			}

			PRIVATE void SetThickness(float thickness)
			{
			char string[40];

			(void) sprintf(string,"Thickness: %6.3f", thickness);

			XtVaSetValues(ThicknessLabel, XtNlabel, string, NULL);
			}

			PRIVATE void NewThickness(Widget w, XtPointer client_data, XtPointer percent_ptr)
			{
			float percent;
			int i;
			float old_thick;

			percent = * (float *) percent_ptr;
			i = Common.axis;

			old_thick = Common.thickness;
			Common.thickness =
			(Common.bounds[i].high - Common.bounds[i].low) * percent;

			if (old_thick == Common.thickness) return;

			SetThickness(Common.thickness);

			if (normal) SceneUpdate();
			}

			/* **************************************************************** */

			PRIVATE void AxisSelect(Widget w, XtPointer client_data, XtPointer call_data)
			{
			PTR new_axis;

			new_axis = (PTR) client_data;

			if (new_axis == Common.axis) return;

			Common.axis = new_axis;

			DrawAxes();

			normal = 0;

			FindAndDisplaySlider(PositionBar, NewPosition);
			FindAndDisplaySlider(ThicknessBar, NewThickness);

			normal = 1;

			SceneUpdate();
			}

			PRIVATE void DirectionSelect(Widget w, XtPointer client_data, XtPointer call_data)
			{
			PTR new_dir;

			new_dir = (PTR) client_data;

			if (new_dir == Common.direction) return;

			Common.direction = new_dir;

			DrawAxes();
			SceneUpdate();
			}

			PRIVATE void MotionSelect(Widget w, XtPointer client_data, XtPointer call_data)
			{
			PTR new_dir;

			new_dir = (PTR) client_data;

			Common.dstep = new_dir;
			}


			PRIVATE void FindAndDisplaySlider(Widget w, XtCallbackProc func)
			{
			float percent;

			XtVaGetValues(w, XtNtopOfThumb, &percent, NULL);

			(func)(NULL, NULL, &percent);
			}

			void PositionUpdate(void)
			{
			FindAndDisplaySlider(PositionBar, NewPosition);
			}

			void ThicknessUpdate(void)
			{
			FindAndDisplaySlider(ThicknessBar, NewThickness);
			}

			void SpeedUpdate(void)
			{
			FindAndDisplaySlider(SpeedBar, NewSpeed);
			}

			/* **************************************************************** */

			typedef struct {
			int x;
			int y;
			char *name;
			} LABEL;

			typedef struct {
			XSegment lines[6];
			LABEL labels[2];
			} AXIS;

			static AXIS axis_data[] = {
			{ { { 120, 120, 120, 30 }, { 115, 35, 120, 30 },
			{ 120, 30, 125, 35 }, { 120, 120, 30, 120 },
			{ 35, 125, 30, 120 }, { 30, 120, 35, 115 } },
			{ { 15, 127, "Z" }, { 115, 25, "Y" } },
			},
			{ { { 20, 20, 20, 110 }, { 15, 105, 20, 110 },
			{ 20, 110, 25, 105 }, { 20, 20, 110, 20 },
			{ 105, 15, 110, 20 }, { 110, 20, 105, 25 } },
			{ { 115, 27, "X" }, { 15, 127, "Z" } },
			},
			{ { { 20, 120, 20, 30 }, { 15, 35, 20, 30 },
			{ 20, 30, 25, 35 }, { 20, 120, 110, 120 },
			{ 105, 125, 110, 120 }, { 110, 120, 105, 115 } },
			{ { 115, 127, "X" }, { 15, 27, "Y" } },
			},
			{ { { 20, 120, 20, 30 }, { 15, 35, 20, 30 },
			{ 20, 30, 25, 35 }, { 20, 120, 110, 120 },
			{ 105, 125, 110, 120 }, { 110, 120, 105, 115 } },
			{ { 115, 127, "Z" }, { 15, 27, "Y" } },
			},
			{ { { 20, 120, 20, 30 }, { 15, 35, 20, 30 },
			{ 20, 30, 25, 35 }, { 20, 120, 110, 120 },
			{ 105, 125, 110, 120 }, { 110, 120, 105, 115 } },
			{ { 115, 127, "X" }, { 15, 27, "Z" } },
			},
			{ { { 20, 20, 20, 110 }, { 15, 105, 20, 110 },
			{ 20, 110, 25, 105 }, { 20, 20, 110, 20 },
			{ 105, 15, 110, 20 }, { 110, 20, 105, 25 } },
			{ { 115, 27, "X" }, { 15, 127, "Y" } },
			},
			};

			PRIVATE void DrawAxes(void)
			{
			static int first = 1;
			static GC gc;
			static Dimension height, width;
			XGCValues xgc;
			AXIS *a;
			int i;
			XFontStruct *font;

			if ( Common.axis < 0 \|\|
			Common.direction < 0 \|\|
			!Axes \|\|
			!XtIsRealized(Axes) ) return;

			if (first) {
			xgc.function = GXcopy;

			XtVaGetValues(Axes,
			XtNbackground, &xgc.background,
			XtNforeground, &xgc.foreground,
			XtNfont, &font,
			XtNheight, &height,
			XtNwidth, &width,
			NULL );

			xgc.font = font->fid;

			gc = XCreateGC(XtDisplay(Axes), XtWindow(Axes),
			GCFunction \| GCBackground \| GCForeground \| GCFont,
			&xgc);

			first = 0;
			}

			XClearWindow(XtDisplay(Axes), XtWindow(Axes));

			a = axis_data + Common.axis + 3*Common.direction;

			XDrawSegments(XtDisplay(Axes), XtWindow(Axes), gc, a->lines, 6);

			for(i = 0; i < 2; i++)
			XDrawString(XtDisplay(Axes), XtWindow(Axes), gc,
			a->labels[i].x, a->labels[i].y,
			a->labels[i].name,
			strlen(a->labels[i].name));

			}
			void ExposeAxes(Widget w, XEvent event, String strings, Cardinal *nstrings)
			{
			DrawAxes();
			}


			/* **************************************************************** */

			PRIVATE void MakeRadioGroup(Widget parent, RadioStruct *radio)
			{
			ToggleStruct *t;
			int i;

			if (radio->name)
			radio->lw = XtCreateManagedWidget(radio->name,
			labelWidgetClass, parent , NULL, ZERO );

			for(t = radio->buttons, i = radio->nbuttons; i; i--, t++) {
			t->w = XtCreateManagedWidget(t->name, toggleWidgetClass,
			parent, NULL, ZERO);
			XtAddCallback(t->w, XtNcallback, radio->callback,
			(XtPointer) t->value);
			}

			}

			/* **************************************************************** */

			PRIVATE void MakeSliderWithLabel(Widget parent, SliderLabelStruct *sl)
			{
			/* create the slider */

			*(sl->slider) = XtCreateManagedWidget(sl->slidername,
			scrollbarWidgetClass, parent, NULL, ZERO);

			/* add the callback */

			XtAddCallback(*(sl->slider), XtNjumpProc, sl->callback, NULL);

			/* create the label */

			*(sl->label) = XtCreateManagedWidget(sl->labelname,
			labelWidgetClass, parent, NULL, ZERO);

			/* Initialize the display */

			FindAndDisplaySlider(*(sl->slider), sl->callback);
			}


			void UpdateRadios(void)
			{
			SetRadio(&AxisRadio);
			SetRadio(&DirectionRadio);
			SetRadio(&MotionRadio);
			}

			PRIVATE void SetRadio(RadioStruct *radio)
			{
			ToggleStruct *t;
			int i;
			char set_name[80], *rg;

			t = radio->buttons;

			/* find out which toggle is currently set */
			strcpy(set_name, (char *) XawToggleGetCurrent(t->w));

			for(i = radio->nbuttons; i; i--, t++)
			if (!strcmp(set_name, t->name)) goto found_set;

			t = radio->buttons;

			XtVaGetValues(t->w, XtNradioGroup, &rg, NULL);
			fprintf(stderr,"Error: radioData for radioGroup %s inconsistent.\n",
			rg);
			XtDestroyApplicationContext(XtWidgetToApplicationContext(TopLevel));
			exit(0);

			found_set:

			/* call the callback with the proper data */

			(radio->callback)((Widget) t->w, (XtPointer) t->value, (XtPointer) 0);
			}

			void SetReadString(char *s)
			{
			if (ReadInfo == (Widget) 0) return;

			XtVaSetValues(ReadInfo, XtNlabel, s, NULL);
			}

			/* **************************************************************** */

			PRIVATE void init_quit(Widget parent)
			{
			Widget dialog;

			/* create a popup shell */

			QuitPopup = XtCreatePopupShell("popup", POPUPSHELLCLASS,
			parent, NULL, ZERO);

			/* put a dialog box in it */

			dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
			QuitPopup, NULL, ZERO);

			XawDialogAddButton(dialog, "ok", quit_ok, (XtPointer) dialog);
			XawDialogAddButton(dialog, "cancel", cancel_popup,
			(XtPointer) &QuitData);

			}

			/* **************************************************************** */

			PRIVATE void do_popup(Widget w, XtPointer client_data, XtPointer call_data)
			{
			Position x, y;
			PopupData *pdata;

			pdata = (PopupData *) client_data;

			/* stop motion for now */

			if (pdata->stop_motion) {
			in_motion = Common.motion;
			RemoveMotion();
			}

			/* translate to corner of calling widgets window */

			XtTranslateCoords(w, 0, 0, &x, &y);

			/* Set us to pop up there */

			XtVaSetValues(*(pdata->w), XtNx, x, XtNy, y, NULL);

			/* do the popping */

			XtPopup(*(pdata->w), pdata->grab);
			}


			PRIVATE void quit_ok(Widget w, XtPointer client_data, XtPointer call_data)
			{
			XtDestroyApplicationContext(XtWidgetToApplicationContext(w));
			exit(0);
			}

			PRIVATE void cancel_popup(Widget w, XtPointer client_data, XtPointer call_data)
			{
			PopupData *pdata;

			pdata = (PopupData *) client_data;

			if (pdata->stop_motion && in_motion) InstallMotion();

			XtPopdown(*(pdata->w));
			}

			/* **************************************************************** */

			PRIVATE void do_start(Widget w, XtPointer client_data, XtPointer call_data)
			{
			InstallMotion();
			}

			PRIVATE void do_stop(Widget w, XtPointer client_data, XtPointer call_data)
			{
			RemoveMotion();
			}

			PRIVATE void do_restart(Widget w, XtPointer client_data, XtPointer call_data)
			{
			RemoveMotion();

			if (Common.dstep > 0)
			Common.step = 0;
			else
			Common.step = Common.ndata-1;

			InstallMotion();
			}

			PRIVATE void do_step(Widget w, XtPointer client_data, XtPointer call_data)
			{
			RemoveMotion();

			Common.step = CoerceStep(Common.step + 1);

			SceneUpdate();
			}

			PRIVATE void do_back(Widget w, XtPointer client_data, XtPointer call_data)
			{
			RemoveMotion();

			Common.step = CoerceStep(Common.step - 1);

			SceneUpdate();
			}

			PRIVATE void do_save_off(Widget w, XtPointer client_data, XtPointer call_data)
			{
			Common.saveflag = 0;
			}

			PRIVATE void do_save_on(Widget w, XtPointer client_data, XtPointer call_data)
			{
			Common.saveflag = 1;
			}

			PRIVATE void do_save_one(Widget w, XtPointer client_data, XtPointer call_data)
			{
			SceneSave();
			}

			/* **************************************************************** */

			PRIVATE void init_atoms(Widget parent)
			{
			Widget outerform, form;
			Widget apply, cancel, last;
			char formname[80], fglabel[80], sizelabel[80];
			char fgname[80], sizename[80], vname[80], iname[80];
			long i, j;
			size_t size;

			/* create a popup shell for atom colors */

			AtomPopup = XtCreatePopupShell("atomcolors",
			transientShellWidgetClass, TopLevel, NULL, ZERO);

			/* put a form widget in it for layout */

			outerform = XtCreateManagedWidget("form", formWidgetClass, AtomPopup,
			NULL, ZERO);

			/* add the buttons */

			apply = XtCreateManagedWidget("apply", commandWidgetClass,
			outerform, NULL, ZERO);
			XtAddCallback(apply, XtNcallback, color_apply,
			(XtPointer) NULL);

			cancel = XtVaCreateManagedWidget("cancel", commandWidgetClass,
			outerform, XtNfromHoriz, apply, NULL);
			XtAddCallback(cancel, XtNcallback, cancel_popup,
			(XtPointer) &AtomData);

			/* put the dialog boxes in it for the colors */

			/* ************************************************ */
			/* allocate all the widgets */
			/* ************************************************ */

			size = Common.natomcolors * sizeof(Widget);

			FGDialog = (Widget *) XtMalloc(size);
			SizeDialog = (Widget *) XtMalloc(size);
			Visible = (Widget *) XtMalloc(size);
			Invisible = (Widget *) XtMalloc(size);

			/* ************************************************ */
			/* build the rest of the panel */
			/* ************************************************ */

			last = apply;

			for(i = 0; i < Common.natomcolors; i++) {
			j = i+1;

			sprintf(formname, "colorform%i", j);
			sprintf(fgname, "color%i", j);
			sprintf(fglabel, "Type %i Color", j);
			sprintf(sizename, "size%i", j);
			sprintf(sizelabel, "Type %i Diameter", j);
			sprintf(vname, "visible%i", j);
			sprintf(iname, "invisible%i", j);

			form = XtVaCreateManagedWidget(formname, formWidgetClass,
			outerform, XtNfromVert, last, NULL);

			FGDialog[i] = XtVaCreateManagedWidget(fgname,
			dialogWidgetClass, form, XtNlabel, fglabel,
			XtNvalue, "white", NULL);

			SizeDialog[i] = XtVaCreateManagedWidget(sizename,
			dialogWidgetClass, form, XtNlabel, sizelabel,
			XtNvalue, "10", XtNfromHoriz, FGDialog[i], NULL);

			Visible[i] = XtVaCreateManagedWidget(vname,
			toggleWidgetClass, form, XtNlabel, "Visible",
			XtNstate, True, XtNfromVert, FGDialog[i], NULL);

			Invisible[i] = XtVaCreateManagedWidget(iname,
			toggleWidgetClass, form, XtNlabel, "Invisible",
			XtNstate, False, XtNradioGroup, Visible[i],
			XtNfromHoriz, Visible[i], XtNfromVert, FGDialog[i],
			NULL);

			XtAddCallback(Visible[i], XtNcallback, visible_toggle,
			(XtPointer) i);

			XtAddCallback(Invisible[i], XtNcallback, visible_toggle,
			(XtPointer) i);

			Common.atoms_visible[i] = True;
			Common.diameter[i] = 10;
			last = form;
			}
			}

			/* **************************************************************** */

			PRIVATE void init_bg(Widget parent)
			{
			Widget outerform;
			Widget apply, cancel;

			/* create a popup shell for background color */

			BackgroundPopup = XtCreatePopupShell("backcolors",
			transientShellWidgetClass, TopLevel, NULL, ZERO);

			/* put a form widget in it for layout */

			outerform = XtCreateManagedWidget("form", formWidgetClass,
			BackgroundPopup, NULL, ZERO);

			/* add the buttons */

			apply = XtCreateManagedWidget("apply", commandWidgetClass,
			outerform, NULL, ZERO);
			XtAddCallback(apply, XtNcallback, bg_apply, (XtPointer) NULL);

			cancel = XtVaCreateManagedWidget("cancel", commandWidgetClass,
			outerform, XtNfromHoriz, apply, NULL);
			XtAddCallback(cancel, XtNcallback, cancel_popup,
			(XtPointer) &BackgroundData);

			/* put the dialog box in it for the color */

			BGDialog = XtVaCreateManagedWidget("bg", dialogWidgetClass,
			outerform, XtNfromVert, apply, NULL);
			}

			/* **************************************************************** */

			PRIVATE void init_file(Widget parent)
			{
			Widget outerform;
			Widget apply, cancel;

			/* create a popup shell for color file */

			FileColorPopup = XtCreatePopupShell("filecolors",
			transientShellWidgetClass, TopLevel, NULL, ZERO);

			/* put a form widget in it for layout */

			outerform = XtCreateManagedWidget("form", formWidgetClass,
			FileColorPopup, NULL, ZERO);

			/* add the buttons */

			apply = XtCreateManagedWidget("apply", commandWidgetClass,
			outerform, NULL, ZERO);
			XtAddCallback(apply, XtNcallback, file_apply, (XtPointer) NULL);

			cancel = XtVaCreateManagedWidget("cancel", commandWidgetClass,
			outerform, XtNfromHoriz, apply, NULL);
			XtAddCallback(cancel, XtNcallback, cancel_popup,
			(XtPointer) &FileColorData);

			/* put the dialog box in it for the filename */

			FileDialog = XtVaCreateManagedWidget("file", dialogWidgetClass,
			outerform, XtNfromVert, apply, NULL);
			}

			PRIVATE void init_bonds(Widget parent)
			{
			Widget outerform, form;
			Widget apply, cancel, last;
			char formname[80], fglabel[80], sizelabel[80];
			char fgname[80], sizename[80], vname[80], iname[80];
			long i, j;
			size_t size;

			/* create a popup shell for bond colors */

			BondPopup = XtCreatePopupShell("bondcolors",
			transientShellWidgetClass,
			TopLevel, NULL, ZERO);

			/* put a form widget in it for layout */

			outerform = XtCreateManagedWidget("form", formWidgetClass, BondPopup,
			NULL, ZERO);

			/* add the buttons */

			apply = XtCreateManagedWidget("apply", commandWidgetClass,
			outerform, NULL, ZERO);
			XtAddCallback(apply, XtNcallback, bond_apply,
			(XtPointer) NULL);

			cancel = XtVaCreateManagedWidget("cancel", commandWidgetClass,
			outerform, XtNfromHoriz, apply, NULL);
			XtAddCallback(cancel, XtNcallback, cancel_popup,
			(XtPointer) &BondData);

			/* ************************************************ */
			/* allocate all the widgets */
			/* ************************************************ */

			size = Common.nbondcolors * sizeof(Widget);

			BFGDialog = (Widget *) XtMalloc(size);
			ThicknessDialog = (Widget *) XtMalloc(size);
			BVisible = (Widget *) XtMalloc(size);
			BInvisible = (Widget *) XtMalloc(size);

			/* ************************************************ */
			/* build the rest of the panel */
			/* ************************************************ */

			last = apply;

			for(i = 0; i < Common.nbondcolors; i++) {
			j = i+1;

			sprintf(formname, "bondform%i", j);
			sprintf(fgname, "color%i", j);
			sprintf(fglabel, "Bond Type %i Color", j);
			sprintf(sizename, "thickness%i", j);
			sprintf(sizelabel, "Bond Type %i Thickness",j);
			sprintf(vname, "visible%i", j);
			sprintf(iname, "invisible%i", j);

			form = XtVaCreateManagedWidget(formname,
			formWidgetClass, outerform, XtNfromVert,
			last, NULL);

			BFGDialog[i] = XtVaCreateManagedWidget(fgname,
			dialogWidgetClass, form, XtNlabel, fglabel,
			XtNvalue, "white", NULL);

			ThicknessDialog[i] = XtVaCreateManagedWidget(sizename,
			dialogWidgetClass, form, XtNlabel, sizelabel,
			XtNvalue, "1", XtNfromHoriz, BFGDialog[i], NULL);

			BVisible[i] = XtVaCreateManagedWidget(vname,
			toggleWidgetClass, form, XtNlabel, "Visible",
			XtNstate, True, XtNfromVert, BFGDialog[i], NULL);

			BInvisible[i] = XtVaCreateManagedWidget(iname,
			toggleWidgetClass, form, XtNlabel, "Invisible",
			XtNstate, False, XtNradioGroup, BVisible[i],
			XtNfromHoriz, BVisible[i], XtNfromVert, BFGDialog[i],
			NULL);

			XtAddCallback(BVisible[i], XtNcallback, bvisible_toggle,
			(XtPointer) i);

			XtAddCallback(BInvisible[i], XtNcallback, bvisible_toggle,
			(XtPointer) i);

			Common.bonds_visible[i] = True;
			last = form;
			}
			}

			/* **************************************************************** */

			PRIVATE void color_apply(Widget w, XtPointer client_data, XtPointer call_data)
			{
			static String fg, size;
			static Pixel *fgpixel;
			static int *diam;
			static Bool first = True;

			Boolean ok;
			int i, n;


			if (first) {
			n = Common.natomcolors;

			fg = (String ) XtMalloc( n sizeof(String) );
			size = (String ) XtMalloc( n sizeof(String) );
			fgpixel = (Pixel ) XtMalloc( n sizeof(Pixel) );
			diam = (int ) XtMalloc( n sizeof(int) );

			first = False;
			}

			ok = True;

			for(i = 0; i < Common.natomcolors; i++) {
			fg[i] = XawDialogGetValueString(FGDialog[i]);
			fgpixel[i] = ConvertColorToPixel(FGDialog[i], fg[i]);

			if (fgpixel[i] == (Pixel) -1) {
			ok = False;
			XtVaSetValues(FGDialog[i], XtNvalue,
			"-Invalid Color-", NULL);
			}

			size[i] = XawDialogGetValueString(SizeDialog[i]);
			diam[i] = atoi(size[i]);

			if (diam[i] < 1 \|\| diam[i] > MAXDIAM) {
			ok = False;
			XtVaSetValues(SizeDialog[i], XtNvalue,
			"-Invalid Size-", NULL);
			}
			}

			if (!ok){
			XBell(XtDisplay(BGDialog), 0);
			return;
			}

			SetAtomColors(fgpixel);

			for(i = 0; i < Common.natomcolors; i++)
			Common.diameter[i] = diam[i];

			SceneUpdate();
			}

			/* **************************************************************** */

			PRIVATE void bond_apply(Widget w, XtPointer client_data, XtPointer call_data)
			{
			static String fg, size;
			static Pixel *fgpixel;
			static Dimension *thick;
			static Bool first = True;

			Boolean ok;
			int i, n, ithick;

			if (first) {
			n = Common.nbondcolors;

			fg = (String ) XtMalloc( n sizeof(String) );
			size = (String ) XtMalloc( n sizeof(String) );
			fgpixel = (Pixel ) XtMalloc( n sizeof(Pixel) );
			thick = (Dimension ) XtMalloc( n sizeof(Dimension) );

			first = False;
			}

			ok = True;

			for(i = 0; i < Common.nbondcolors; i++) {
			fg[i] = XawDialogGetValueString(BFGDialog[i]);
			fgpixel[i] = ConvertColorToPixel(BFGDialog[i], fg[i]);

			if (fgpixel[i] == (Pixel) -1) {
			ok = False;
			XtVaSetValues(BFGDialog[i], XtNvalue,
			"-Invalid Color-", NULL);
			}

			size[i] = XawDialogGetValueString(ThicknessDialog[i]);
			ithick = atoi(size[i]);

			if (ithick < 1 \|\| ithick > MAXTHICK) {
			ok = False;
			XtVaSetValues(ThicknessDialog[i], XtNvalue,
			"-Invalid Size-", NULL);
			}
			thick[i] = ithick;
			}

			if (!ok){
			XBell(XtDisplay(BGDialog), 0);
			return;
			}

			SetBondColors(fgpixel, thick);

			SceneUpdate();
			}

			/* **************************************************************** */

			PRIVATE void bg_apply(Widget w, XtPointer client_data, XtPointer call_data)
			{
			String bg;
			Pixel bgpixel;

			bg = XawDialogGetValueString(BGDialog);
			bgpixel = ConvertColorToPixel(BGDialog, bg);

			if (bgpixel == (Pixel) -1) {
			XtVaSetValues(BGDialog, XtNvalue, "-Invalid Color-", NULL);
			XBell(XtDisplay(BGDialog), 0);
			return;
			}

			SetBGColor(bgpixel);

			SceneUpdate();
			}

			PRIVATE Pixel ConvertColorToPixel(Widget w, String color)
			{
			XrmValue from, to;
			Pixel pixel;

			from.size = strlen(color) + 1;
			from.addr = color;
			/* SJP - 10/02, new Linux couldn't fine caddr_t */
			/* to.addr = (caddr_t) &pixel; */
			to.addr = (char *) &pixel;
			to.size = sizeof(pixel);

			if (XtConvertAndStore(w, XtRString, (XrmValuePtr) &from,
			XtRPixel, (XrmValuePtr) &to))
			return(pixel);
			else
			return( (Pixel) -1);
			}


			PRIVATE void file_apply(Widget w, XtPointer client_data, XtPointer call_data)
			{
			String bg;
			Pixel bgpixel;
			static String fg, size;
			static Pixel *fgpixel;
			static int *diam;
			static Bool first = True;

			int i, n;

			if (first) {
			n = Common.natomcolors;

			fg = (String ) XtMalloc( n sizeof(String) );
			size = (String ) XtMalloc( n sizeof(String) );
			fgpixel = (Pixel ) XtMalloc( n sizeof(Pixel) );
			diam = (int ) XtMalloc( n sizeof(int) );

			first = False;
			}

			for(i = 0; i < Common.natomcolors; i++) {
			fg[i] = "red";
			fgpixel[i] = ConvertColorToPixel(FGDialog[i], fg[i]);

			if (fgpixel[i] == (Pixel) -1) return;

			XtVaSetValues(FGDialog[i], XtNvalue, fg[i], NULL);

			size[i] = "20";
			diam[i] = atoi(size[i]);

			if (diam[i] < 1 \|\| diam[i] > MAXDIAM) return;
			XtVaSetValues(SizeDialog[i], XtNvalue, size[i], NULL);
			}

			SetAtomColors(fgpixel);

			for(i = 0; i < Common.natomcolors; i++)
			Common.diameter[i] = diam[i];

			/*
			Common.atoms_visible[0] = 0;
			Common.atoms_visible[1] = 0;
			Common.atoms_visible[2] = 0;
			Common.atoms_visible[3] = 0;
			*/

			bg = "green";
			bgpixel = ConvertColorToPixel(BGDialog, bg);

			if (bgpixel == (Pixel) -1) {
			XtVaSetValues(BGDialog, XtNvalue, "-Invalid Color-", NULL);
			XBell(XtDisplay(BGDialog), 0);
			return;
			}

			SetBGColor(bgpixel);

			SceneUpdate();
			}

			PRIVATE void visible_toggle(Widget w, XtPointer client_data,
			XtPointer call_data)
			{
			long i;
			XtPointer data;
			char c;

			i = (long) client_data;

			XtVaGetValues(w, XtNradioData, &data, NULL);

			c = ((char ) data);

			Common.atoms_visible[i] = c == 'v';
			}

			PRIVATE void bvisible_toggle(Widget w, XtPointer client_data,
			XtPointer call_data)
			{
			int i;
			XtPointer data;
			char c;

			i = (int) client_data;

			XtVaGetValues(w, XtNradioData, &data, NULL);

			c = ((char ) data);

			Common.bonds_visible[i] = c == 'v';
			}

lammps/tools/xmovie/control.c111777c6f68blammm-master-deprecated

control.cView Options

lammps/tools/xmovie/control.c
111777c6f68blammm-master-deprecated

control.c
View Options