/*
If the control panel is on, reset the sliders. This is done
by asking the xyplot for it's current bounds.
Hence, if the use sets the bounds from Glish to values other
than what is set by default, the sliders will see the change.
*/
void ResetSliders()
{
if (CtrlPanelOn)
{
float max,min;
int i;
fl_get_xyplot_xbounds(CHART[0],&min,&max);
fl_set_slider_bounds(XMax_Slider,(double)min,(double)max);
fl_set_slider_bounds(XMin_Slider,(double)min,(double)max);
fl_set_slider_value(XMax_Slider,(double)max);
fl_set_slider_value(XMin_Slider,(double)min);
for (i=0;i<=GlobalNoOfOverlays;i++)
{
fl_get_xyplot_ybounds(CHART[i],&min,&max);
fl_set_slider_bounds(YMax_Slider[i],(double)max,(double)min);
fl_set_slider_bounds(YMin_Slider[i],(double)max,(double)min);
fl_set_slider_value(YMax_Slider[i],(double)max);
fl_set_slider_value(YMin_Slider[i],(double)min);
}
}
}
void anim_reactive_collision_interface(AnimProb * AnimProbPt) {
int NofCoef;
NofCoef = XYZ_ANIM.animation[0]->nof_coef;
ZANIM = AnimProbPt;
if (ARCI != NULL) {
fl_hide_form(ARCI);
fl_free_form(ARCI);
ARCI = NULL;
}
ARCI = fl_bgn_form(FL_UP_BOX, 200, 370);
ARCI_REAC_TIME = fl_add_valslider (FL_HOR_SLIDER, 10, 10, 180, 20, "Reaction Time");
fl_set_slider_bounds (ARCI_REAC_TIME, 0, 3);
fl_set_slider_value (ARCI_REAC_TIME, 1);
fl_set_slider_step (ARCI_REAC_TIME, 0.1);
ARCI_CONST_BLOCKS = fl_add_button(FL_NORMAL_BUTTON, 10, 50, 180, 20, "Constitute Blocks");
fl_set_object_callback(ARCI_CONST_BLOCKS, anim_arci_cb, 10);
ARCI_NOF_BLOCK = fl_add_text(FL_NORMAL_TEXT, 10, 80, 180, 20, "");
anim_udpate_nof_blocks();
ARCI_NOF_ATTEMPTS = fl_add_valslider (FL_HOR_SLIDER, 10, 110, 180, 20, "Number of Attempt for Solving Collisions");
fl_set_slider_bounds (ARCI_NOF_ATTEMPTS, 0, 1000);
fl_set_slider_value (ARCI_NOF_ATTEMPTS, 100);
fl_set_slider_step (ARCI_NOF_ATTEMPTS, 10);
ARCI_SOLVE_COL = fl_add_button(FL_NORMAL_BUTTON, 10, 150, 180, 20, "Solve Blocks");
fl_set_object_callback(ARCI_SOLVE_COL, anim_arci_cb, 11);
ARCI_SOLVED = fl_add_text(FL_NORMAL_TEXT, 10, 180, 180, 20, "");
anim_udpate_solved();
ARCI_SHOW_SOL = fl_add_button(FL_NORMAL_BUTTON, 10, 210, 180, 20, "Show Solution(s)");
fl_set_object_callback(ARCI_SHOW_SOL, anim_arci_cb, 12);
ARCI_OPTIM = fl_add_button(FL_NORMAL_BUTTON, 10, 240, 180, 20, "Optimize Solution(s)");
fl_set_object_callback(ARCI_OPTIM, anim_arci_cb, 13);
ARCI_OPTIMIZED = fl_add_text(FL_NORMAL_TEXT, 10, 270, 180, 20, "");
anim_udpate_optimized();
ARCI_SHOW_OPTIM = fl_add_button(FL_NORMAL_BUTTON, 10, 300, 180, 20, "Show Optimized Solution(s)");
fl_set_object_callback(ARCI_SHOW_OPTIM, anim_arci_cb, 14);
ARCI_CLOSE = fl_add_button(FL_NORMAL_BUTTON, 10, 330, 180, 20, "Close");
fl_set_object_callback(ARCI_CLOSE, anim_arci_cb, 15);
fl_end_form();
fl_show_form (ARCI, FL_PLACE_SIZE, FL_FULLBORDER, "Reactive collisions");
}
int main(int argc, char *argv[])
{
void lmst_update (FL_OBJECT *, long);
int i;
void dismiss_psr();
void spectrum_hide();
void tp_hide ();
void hide_waterfall();
void hide_interferometer();
void hide_info();
void receiver_leave();
int close_sub ();
int close_main ();
char *p;
char fntstr[128];
char d[128];
int binwidth;
/*
* Init xforms library
*/
fl_initialize(&argc, argv, "Ira", 0, 0);
fl_get_app_resources (NULL, 0);
time (&started_at);
/*
* Create various windows, including the main one
*/
fd_receiver_main = create_form_receiver_main();
fl_set_form_atclose(fd_receiver_main->receiver_main, close_main, 0);
fd_receiver_pulsar = create_form_receiver_pulsar();
fl_set_form_atclose (fd_receiver_pulsar->receiver_pulsar, close_sub, dismiss_psr);
fd_receiver_spectrum = create_form_receiver_spectrum();
fl_set_form_atclose (fd_receiver_spectrum->receiver_spectrum, close_sub, spectrum_hide);
fd_receiver_continuum = create_form_receiver_continuum();
fl_set_form_atclose (fd_receiver_continuum->receiver_continuum, close_sub, tp_hide);
fd_receiver_waterfall = create_form_receiver_waterfall();
fl_set_form_atclose (fd_receiver_waterfall->receiver_waterfall, close_sub, hide_waterfall);
fd_receiver_info = create_form_receiver_info();
fl_set_form_atclose (fd_receiver_info->receiver_info, close_sub, hide_info);
fd_receiver_lproblem = create_form_receiver_lproblem ();
fd_receiver_error = create_form_receiver_error ();
fd_receiver_shutdown = create_form_receiver_shutdown ();
flps_init();
fl_free_pixmap_pixmap(fd_receiver_main->ira_xpm_button);
fl_set_pixmap_data(fd_receiver_main->ira_xpm_button, Ira_xpm);
sprintf (version_info, "Ver: %s (BETA)", VERSION);
/*
* Stuff lines in info window
*/
for (i = 0; ; i++)
{
if (ira_info[i] == NULL)
{
break;
}
fl_add_browser_line (fd_receiver_info->info_browser, ira_info[i]);
}
fl_set_browser_fontsize(fd_receiver_info->info_browser, 14);
/* fill-in form initialization code */
fl_set_object_label (fd_receiver_main->startup_text, "PLEASE WAIT.........");
/* show the first form */
fl_show_form(fd_receiver_main->receiver_main,FL_PLACE_CENTER,FL_FULLBORDER,"IRA Control Panel");
fl_check_forms();
/*
* Now we check a raft of environment variables, and use those to initialize
* various settable values
*/
refmult = 1.0;
if ((p = getenv ("RCVR_REF_MULT")) != NULL)
{
refmult = atof(p);
}
fl_set_slider_value (fd_receiver_main->refmult_slider, refmult);
seti_integ = 15;
if ((p = getenv ("RCVR_SETI_INTEG")) != NULL)
{
seti_integ = (int)atof(p);
}
fl_set_slider_value (fd_receiver_main->seti_integ_slider, (float)seti_integ);
strcpy (datadir, ".");
if ((p = getenv ("RCVR_DATA_DIR")) != NULL)
{
strcpy (datadir, p);
}
/*
* Set the input field for freq, as well as the actual frequency
*/
if ((p = getenv ("RCVR_INITIAL_FREQ")) != NULL)
{
fl_set_input (fd_receiver_main->frequency_input, p);
frequency = atof(p);
sky_freq = frequency;
sky_locked = 1;
}
/*
* Start out with sky_freq unavailable for input
*/
fl_deactivate_object (fd_receiver_main->sky_freq_input);
fl_set_input (fd_receiver_main->sky_freq_input, "--------");
/* If there's a sky_freq parameter, use it, and re-activate the
* sky_freq_input control
*/
if ((p = getenv ("RCVR_SKY_FREQ")) != NULL)
{
if (abs(atof(p) - frequency) > 100.0)
{
sky_locked = 0;
fl_set_input (fd_receiver_main->sky_freq_input, p);
sky_freq = atof(p);
fl_activate_object (fd_receiver_main->sky_freq_input);
fl_set_button (fd_receiver_main->sky_lock_button, 0);
}
else
{
sky_freq = atof(p);
fl_set_button (fd_receiver_main->sky_lock_button, 1);
sky_locked = 1;
}
}
PUSHVAR("ifreq", frequency);
PUSHVAR("skyfreq", sky_freq);
/*
*
* And again for RF gain
*/
if ((p = getenv ("RCVR_RF_GAIN")) != NULL)
{
rf_gain = atoi(p);
}
fl_set_slider_value (fd_receiver_main->rf_gain_slider, rf_gain);
PUSHVAR("igain", rf_gain);
/*
* Gain correction values for A and B sides
*/
if ((p = getenv ("RCVR_COR_A")) != NULL)
{
gc_a = atof(p);
}
sprintf (d, "%f", gc_a);
fl_set_input (fd_receiver_main->gc_a, d);
if ((p = getenv ("RCVR_COR_B")) != NULL)
{
gc_b = atof(p);
}
sprintf (d, "%f", gc_b);
fl_set_input (fd_receiver_main->gc_b, d);
/*
* Set bounds/values for DC gain
*/
if ((p = getenv ("RCVR_DC_GAIN")) != NULL)
{
dc_gain = atof(p);
}
fl_set_slider_value (fd_receiver_main->dc_gain_control, dc_gain);
/*
* And again for DC offset
*/
if ((p = getenv ("RCVR_DC_OFFSET")) != NULL)
{
dc_offset = atof(p);
}
fl_set_slider_value (fd_receiver_main->dc_offset_control, dc_offset);
/*
* Receiver DC Gain multiplier
*/
if ((p = getenv ("RCVR_DC_MULT")) != NULL)
{
int which;
dc_mult = (double)atoi(p);
which = 1;
/*
* It's a choice widget, so we need to set 'which' appropriately
*/
switch ((int)dc_mult)
{
case 1:
which = 1;
break;
case 5:
which = 2;
break;
case 10:
which = 3;
break;
case 15:
which = 4;
break;
case 20:
which = 5;
break;
case 25:
which = 6;
break;
case 30:
which=7;
break;
case 35:
which = 8;
break;
case 40:
which = 9;
break;
}
fl_set_choice (fd_receiver_main->mult_choice, which);
}
/*
* Total power integration value
*/
tp_integration = 5;
if ((p = getenv ("RCVR_TP_INTEG")) != NULL)
{
tp_integration = atoi(p);
}
fl_set_slider_value (fd_receiver_main->continuum_int, (double)atof(getenv("RCVR_TP_INTEG")) );
/*
* Spectral integration
*/
spec_integration = 15;
if ((p = getenv ("RCVR_SPEC_INTEG")) != NULL)
{
spec_integration = atoi(p);
}
fl_set_slider_value (fd_receiver_main->spec_int_slider, (double)atof(getenv("RCVR_SPEC_INTEG")) );
/*
* Sigma_K for SETI analysis
*/
sigma_k = 2.5;
if ((p = getenv ("RCVR_SIGMA_K")) != NULL)
{
sigma_k = atof(p);
}
fl_set_slider_value (fd_receiver_main->sigma_k_slider, sigma_k);
/*
* Check desired receiver mode
*/
if (getenv("RCVR_MODE") != NULL)
{
strcpy (rcvr_mode, getenv("RCVR_MODE"));
}
else
{
strcpy (rcvr_mode, "unknown");
}
/*
* Interferometer? Create the interferometer window
*/
if (strcmp (rcvr_mode, "interferometer") == 0)
{
fd_receiver_interferometer = create_form_receiver_interferometer();
fl_set_form_atclose (fd_receiver_interferometer->receiver_interferometer, close_sub,
hide_interferometer);
}
/*
* Otherwise, delete the "show interferograms" control
*/
else
{
fl_delete_object (fd_receiver_main->interferometer_button);
}
/*
* Various values
*/
declination = -28.3;
if ((p = getenv ("RCVR_DECLINATION")) != NULL)
{
declination = atof(p);
}
fl_set_input (fd_receiver_main->declination_input, getenv("RCVR_DECLINATION"));
longitude = 0.0;
if ((p = getenv ("RCVR_LONGITUDE")) != NULL)
{
longitude = atof(p);
}
seti_size = 500000;
if ((p = getenv ("RCVR_SETI_SIZE")) != NULL)
{
seti_size = atoi (p);
}
bandwidth = 5000000;
if ((p = getenv ("RCVR_BANDWIDTH")) != NULL)
{
bandwidth = atoi (p);
}
psr_rate = 10000;
if ((p = getenv ("RCVR_PSR_RATE")) != NULL)
{
psr_rate = atoi (getenv ("RCVR_PSR_RATE"));
}
for (i = 0; i < NNOTCHES; i++)
{
notches[i] = -1.0;
}
if ((p = getenv ("RCVR_NOTCHES")) != NULL)
{
char *tp;
char pcopy[128];
FILE *fp;
strcpy (pcopy, p);
tp = strtok (pcopy, ",");
notches[0] = atof(tp);
for (i = 1; i < NNOTCHES; i++)
{
tp = strtok (NULL, ",");
if (tp == NULL)
{
break;
}
notches[i] = atof(tp);
}
}
if ((p = getenv ("RCVR_NOTCH_SIZE")) != NULL)
{
notch_length = atoi(p);
fl_set_slider_value (fd_receiver_spectrum->notch_slider, (double)notch_length);
}
if ((p = getenv ("RCVR_DM")) != NULL)
{
pulsar_dm = atof(p);
fl_set_slider_value (fd_receiver_main->dm_input, (double)pulsar_dm);
}
PUSHVAR("idm", pulsar_dm);
if ((p = getenv ("PULSAR_RATE")) != NULL)
{
pulsar_rate = atof(p);
fl_set_input (fd_receiver_main->pulsar_rate_input, p);
}
if ((p = getenv ("PULSAR_FOLDING")) != NULL)
{
pulsar_folding = atoi(p);
fl_set_choice (fd_receiver_main->pulsar_choice, pulsar_folding/5);
}
/*
* Set spec_fft_size based on width of spectral plot display
*/
{
FL_Coord x, y, w, h;
fl_get_object_bbox (fd_receiver_spectrum->spectral_plot, &x, &y, &w, &h);
spec_fft_size = w-130;
}
tp_maxval = 100000;
tp_span = 20000;
/*
* Establish parameters for TP plot
*/
if ((p = getenv("RCVR_TP_MAXVAL")) != NULL)
{
tp_maxval = (double)atoi(p);
}
if ((p = getenv ("RCVR_TP_SPAN")) != NULL)
{
tp_span = (double)atoi(p);
}
tp_minval = tp_maxval - tp_span;
fl_set_slider_value (fd_receiver_continuum->tp_max_slider, (double)tp_maxval);
fl_set_slider_value (fd_receiver_continuum->tp_span_slider, (double)tp_span);
fl_set_xyplot_ybounds(fd_receiver_continuum->tp_chart, (double)tp_minval, (double)tp_maxval);
fl_set_xyplot_ytics(fd_receiver_continuum->tp_chart, 10, 1);
fl_set_xyplot_xgrid (fd_receiver_continuum->tp_chart, FL_GRID_MINOR);
fl_set_xyplot_ygrid (fd_receiver_continuum->tp_chart, FL_GRID_MINOR);
fl_set_object_posthandler(fd_receiver_continuum->tp_chart, continuum_plot_post);
/*
* Set a post handler for inteferometer display
*/
if (strcmp (rcvr_mode, "interferometer") == 0)
{
fl_set_object_posthandler(fd_receiver_interferometer->interferometer_chart, continuum_plot_post);
if ((p = getenv ("RCVR_INT_GAIN")) != NULL)
{
interferometer_gain = atof(p);
}
if ((p = getenv ("RCVR_INT_SPAN")) != NULL)
{
interferometer_span = atof(p);
}
if ((p = getenv ("RCVR_PHCORR")) != NULL)
{
interferometer_phase = atof(p);
}
if ((p = getenv ("RCVR_DELAY")) != NULL)
{
interferometer_delay = atof(p);
}
fl_set_xyplot_ytics (fd_receiver_interferometer->interferometer_chart, 10, 1);
fl_set_xyplot_xgrid (fd_receiver_interferometer->interferometer_chart, FL_GRID_MINOR);
fl_set_xyplot_ygrid (fd_receiver_interferometer->interferometer_chart, FL_GRID_MINOR);
fl_set_slider_value (fd_receiver_interferometer->int_gain_slider, interferometer_gain);
fl_set_slider_value (fd_receiver_interferometer->int_span_slider, interferometer_span);
fl_set_slider_value (fd_receiver_interferometer->phase_adjust, interferometer_phase);
fl_set_slider_value (fd_receiver_interferometer->delay_adjust, interferometer_delay);
fl_set_xyplot_ybounds (fd_receiver_interferometer->interferometer_chart, -1*interferometer_span,
interferometer_span);
}
fl_add_timeout (1000.0, (FL_TIMEOUT_CALLBACK)lmst_update, 0);
/*
* Setup parameters for spectral plot
*/
if ((p = getenv ("RCVR_SPEC_MAX")) != NULL)
{
current_smax = atoi(p);
}
if ((p = getenv ("RCVR_SPEC_SPAN")) != NULL)
{
current_span = atoi(p);
}
if ((p = getenv ("RCVR_SPEC_FLAT")) != NULL)
{
spec_flat_on = atoi(p);
fl_set_button (fd_receiver_spectrum->flaten_button, spec_flat_on);
}
if ((p = getenv ("RCVR_SPEC_METHOD")) != NULL)
{
spec_method = atoi (p);
}
fl_set_xyplot_xgrid(fd_receiver_spectrum->spectral_plot, FL_GRID_MINOR);
fl_set_xyplot_ygrid(fd_receiver_spectrum->spectral_plot, FL_GRID_MINOR);
fl_set_xyplot_ybounds(fd_receiver_spectrum->spectral_plot, (double)(current_smax-current_span), (double)
current_smax);
fl_set_xyplot_ytics(fd_receiver_spectrum->spectral_plot, 10, 1);
fl_set_xyplot_xtics(fd_receiver_spectrum->spectral_plot, 10, 1);
fl_set_object_posthandler(fd_receiver_spectrum->spectral_plot, spectral_plot_post);
fl_set_choice (fd_receiver_spectrum->spec_method_choice, spec_method);
fl_set_choice_fontsize (fd_receiver_spectrum->spec_method_choice, 14);
fl_set_slider_value (fd_receiver_spectrum->spec_max_slider, (double)current_smax);
fl_set_slider_value (fd_receiver_spectrum->spec_span_slider, (double)current_span);
/*
* Set post handler for pulsar display
*/
fl_set_object_posthandler(fd_receiver_pulsar->pulsar_plot, pulsar_plot_post);
/*
* Set parameters for waterfall (SETI) display
*/
{
FL_Coord x, y;
FL_Coord w, h;
fl_get_object_bbox(fd_receiver_waterfall->waterfall_display, &x, &y, &w, &h);
fl_set_slider_bounds (fd_receiver_waterfall->wfall_seg_slider, 1.0, (float)seti_size/w);
fl_set_object_dblbuffer(fd_receiver_waterfall->waterfall_display, 1);
if ((p = getenv ("RCVR_WFALL_SEGMENT")) != NULL)
{
waterfall_segment = atoi(p);
fl_set_slider_value (fd_receiver_waterfall->wfall_seg_slider, (double)waterfall_segment);
}
if ((p = getenv ("RCVR_WFALL_FINE")) != NULL)
{
waterfall_fine = atoi(p);
fl_set_slider_value (fd_receiver_waterfall->fine_segment, waterfall_fine);
}
if ((p = getenv ("RCVR_WFALL_BRIGHTNESS")) != NULL)
{
double w;
w = atof(p);
if (fabsf(w-1.0) < 0.1)
{
fl_set_choice (fd_receiver_waterfall->wfall_brightness, 1);
w = 1.0;
}
if (fabsf(w-0.75) < 0.1)
{
fl_set_choice (fd_receiver_waterfall->wfall_brightness, 2);
w = 0.75;
}
if (fabsf(w-0.66) < 0.1)
{
fl_set_choice (fd_receiver_waterfall->wfall_brightness, 3);
w = 0.66;
}
if (fabsf(w-0.50) < 0.1)
{
fl_set_choice (fd_receiver_waterfall->wfall_brightness, 4);
w = 0.50;
}
waterfall_brightness = (float)w;
}
}
if ((p = getenv ("RCVR_TRANS_THRESH")) != NULL)
{
transient_threshold = atof(p);
fl_set_slider_value (fd_receiver_main->trans_thr_slider, transient_threshold);
}
if ((p = getenv ("RCVR_TRANS_DUR")) != NULL)
{
transient_duration = atof(p);
fl_set_slider_value (fd_receiver_main->trans_dur_slider, transient_duration);
}
/*
* Open various FIFOs--that's where we get our data from
*/
if ((seti_fd = open ("ra_seti_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (seti_fd, F_SETFL, 0);
fl_add_io_callback (seti_fd, FL_READ, (FL_IO_CALLBACK)handle_seti_io, fd_receiver_main);
}
if ((pulsar_fd = open ("ra_psr_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (pulsar_fd, F_SETFL, 0);
fl_add_io_callback (pulsar_fd, FL_READ, (FL_IO_CALLBACK)handle_pulsar_io, fd_receiver_main);
}
if ((dicke_fd = open ("ra_switching_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (dicke_fd, F_SETFL, 0);
fl_set_object_label (fd_receiver_main->dicke_mode, "DICKE: ON");
fl_add_io_callback (dicke_fd, FL_READ, (FL_IO_CALLBACK)handle_dicke_io, fd_receiver_main);
}
if (strcmp (rcvr_mode, "interferometer") == 0)
{
if ((inter_fd = open ("ra_inter_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (inter_fd, F_SETFL, 0);
fl_add_io_callback (inter_fd, FL_READ, (FL_IO_CALLBACK)handle_inter_io, fd_receiver_main);
}
}
if (strcmp (rcvr_mode, "split") == 0)
{
if ((validation_fd = open ("ra_validation_fifo", O_RDONLY|O_NONBLOCK)) > 0)
{
fcntl (validation_fd, F_SETFL, 0);
split_mode = 1;
fl_add_io_callback (validation_fd, FL_READ, (FL_IO_CALLBACK)handle_validation_io, fd_receiver_main);
}
}
fl_set_oneliner_font (FL_FIXEDBOLDITALIC_STYLE, FL_MEDIUM_FONT);
fl_set_oneliner_color (FL_GREEN, FL_BLACK);
while(fl_do_forms())
;
return 0;
}
void handle_event(XEvent *event) {
/* see /usr/include/X11/X.h for definitions of X Windows event types */
// you won't want to leave these printf's in here for your finished program,
// but they should help you get started and debug.
static int xprev, yprev, xstart, ystart;
switch (event->type) {
case ButtonPress: /* button press */
printf(" ButtonPress. button %d at (%d, %d)\n",
event->xbutton.button, event->xbutton.x, event->xbutton.y);
switch (event->xbutton.button) {
case 1:
world.curp = world.pick_particle(event->xbutton.x,
event->xbutton.y, view);
if (!world.curp) break;
if (is_key_pressed(pane.display, XK_Shift_L) ||
is_key_pressed(pane.display, XK_Shift_R)) {
world.delete_particle(world.curp);
world.curp = NULL;
}
else
fl_set_slider_value(ui->mass_slider, world.curp->mass);
// set slider to show the mass of this particle
break;
case 2:
{
Vec2 p = view.screen_to_world(event->xbutton.x,
event->xbutton.y);
world.curp = world.insert_particle(p[0], p[1], 0, 0,
fl_get_slider_value(ui->mass_slider));
}
break;
case 3:
// save these for later use when MotionNotify event comes
xstart = xprev = event->xbutton.x;
ystart = yprev = event->xbutton.y;
break;
}
world.draw();
break;
case ButtonRelease: /* button release */
printf(" ButtonRelease. button %d\n", event->xbutton.button);
break;
case MotionNotify: /* mouse pointer moved */
printf(" MotionNotify at (%d, %d) state=%d=(%s %s %s)\n",
event->xmotion.x, event->xmotion.y,
event->xmotion.state,
event->xmotion.state&Button1Mask ? "button1" : ".",
event->xmotion.state&Button2Mask ? "button2" : ".",
event->xmotion.state&Button3Mask ? "button3" : ".");
if (world.curp && (
event->xmotion.state & (Button1Mask|Button2Mask))) {
/* printf("moving particle %d\n", world.curp-world.pt); */
world.curp->pos = view.screen_to_world(event->xmotion.x,
event->xmotion.y);
}
else if (event->xmotion.state & Button3Mask) {
if (is_key_pressed(pane.display, XK_Shift_L) ||
is_key_pressed(pane.display, XK_Shift_R)) {
float s = 1. + (event->xmotion.x - xprev)/100.;
/* printf("s=%g\n", s); */
Vec2 pos = view.screen_to_world(xstart, ystart);
// scale view around the point where user moused down
glTranslatef(pos[0], pos[1], 0.);
glScalef(s, s, 1.);
glTranslatef(-pos[0], -pos[1], 0.);
}
else {
float t = view.viewport.width*view.relscale();
glTranslatef((event->xmotion.x - xprev)/t,
-(event->xmotion.y - yprev)/t, 0.);
}
view.update();
xprev = event->xmotion.x;
yprev = event->xmotion.y;
}
world.draw();
break;
case EnterNotify: /* mouse pointer entered window */
printf(" EnterNotify.\n");
break;
case LeaveNotify: /* mouse pointer left window */
printf(" LeaveNotify.\n");
break;
case KeyPress: /* key pressed */
case KeyRelease: /* key released */
{
char buf[10];
int n;
KeySym keysym;
printf(event->type==KeyPress ? " KeyPress." : " KeyRelease.");
n = XLookupString(&event->xkey, buf, sizeof buf - 1,
&keysym, 0);
buf[n] = 0;
/* print key as ascii and in hexadecimal */
/* see /usr/include/X11/keysymdef.h for key codes */
printf(" key=(%c)=0x%x\n", keysym, keysym);
}
break;
case Expose: /* window just uncovered */
printf(" Expose.\n");
world.draw();
break;
case VisibilityNotify: /* window occluded or exposed */
printf(" VisibilityNotify.\n");
break;
default:
printf(" unknown event type.\n");
break;
}
}
FD_options *create_form_options(void)
{
FL_OBJECT *obj;
FD_options *fdui = (FD_options *) fl_calloc(1, sizeof(*fdui));
fdui->options = fl_bgn_form(FL_NO_BOX, 470, 530);
obj = fl_add_box(FL_UP_BOX,0,0,470,530,"Options");
fl_set_object_lsize(obj,FL_NORMAL_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP|FL_ALIGN_INSIDE);
fl_set_object_lstyle(obj,FL_BOLD_STYLE);
obj = fl_add_frame(FL_EMBOSSED_FRAME,20,370,210,130,"");
obj = fl_add_frame(FL_EMBOSSED_FRAME,240,370,220,110,"");
obj = fl_add_frame(FL_EMBOSSED_FRAME,20,190,440,170,"");
fdui->prob_mutation = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,35,250,200,20,"Probabiliy of Mutation:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 3);
fl_set_slider_value(obj, 0.008);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 0.001);
fl_set_slider_increment(obj, 0.001, 0.001);
fdui->prob_crossover = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,250,250,200,20,"Probabiliy of Crossover:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 3);
fl_set_slider_value(obj, 0.002);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 0.001);
fl_set_slider_increment(obj, 0.001, 0.001);
fdui->max_pop = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,250,210,200,20,"Maximum Population:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 10000);
fl_set_slider_value(obj, 2000);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 1);
fl_set_slider_increment(obj, 10, 10);
fdui->maintain_min_pop = obj = fl_add_checkbutton(FL_PUSH_BUTTON,260,380,20,20,"Maintain a Minimum Population?");
fdui->age_factor = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,35,290,200,20,"Age Factor:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 15);
fl_set_slider_value(obj, 9);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 1);
fl_set_slider_increment(obj, 1, 1);
fdui->carcass_decay_rate = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,250,290,200,20,"Carcass Decay Rate:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 100000);
fl_set_slider_value(obj, 10000);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 100);
fl_set_slider_increment(obj, 100, 100);
fdui->save_sim = obj = fl_add_checkbutton(FL_PUSH_BUTTON,45,380,20,20,"Save Simulation Every N Steps?");
fdui->save_every = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,40,420,170,20,"Save Every N Steps:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 100000);
fl_set_slider_value(obj, 50000);
fl_set_slider_size(obj, 0.12);
fl_set_slider_step(obj, 100);
fl_set_slider_increment(obj, 100, 100);
fdui->file_name = obj = fl_add_input(FL_NORMAL_INPUT,40,465,170,20,"Default File Name:");
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fdui->ok = obj = fl_add_button(FL_RETURN_BUTTON,360,490,80,30,"OK");
fdui->initial_params_frame = obj = fl_add_frame(FL_ENGRAVED_FRAME,20,20,440,160,"Initial Parameters");
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_object_lstyle(obj,FL_BOLD_STYLE);
fdui->scale = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,35,210,200,20,"Display Scale Factor:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 1, 32);
fl_set_slider_value(obj, 5);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 1);
fl_set_slider_increment(obj, 1, 1);
fdui->min_pop = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,265,420,170,20,"Minimum Population:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 100);
fl_set_slider_value(obj, 5);
fl_set_slider_size(obj, 0.12);
fl_set_slider_step(obj, 1);
fl_set_slider_increment(obj, 1, 1);
fdui->use_survivor = obj = fl_add_checkbutton(FL_PUSH_BUTTON,280,450,20,20,"Use Survivor for Minimum?");
fdui->initial_parameters_group = fl_bgn_group();
fdui->terrain_size = obj = fl_add_choice(FL_NORMAL_CHOICE2,340,135,100,30,"Terrain Size (cells):");
fl_set_choice_entries(obj, fdchoice_terrain_size_0);
fl_set_choice(obj,4);
fdui->initial_pop = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,35,60,200,20,"Initial Population:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 2000);
fl_set_slider_value(obj, 200);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 1);
fl_set_slider_increment(obj, 10, 10);
fdui->initial_plant = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,35,100,200,20,"Number of Initial Plant Locations:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 10000);
fl_set_slider_value(obj, 1000);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 100);
fl_set_slider_increment(obj, 100, 100);
fdui->initial_flesh = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,250,100,200,20,"Number of Initial Flesh Locations:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 10000);
fl_set_slider_value(obj, 1000);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 100);
fl_set_slider_increment(obj, 100, 100);
fdui->give_head_start = obj = fl_add_checkbutton(FL_PUSH_BUTTON,290,55,20,20,"Give A Head Start?");
fl_set_button(obj, 1);
fdui->allow_asex = obj = fl_add_checkbutton(FL_PUSH_BUTTON,70,150,20,20,"Allow Asexual Reproduction?");
fl_set_button(obj, 1);
fdui->allow_sex = obj = fl_add_checkbutton(FL_PUSH_BUTTON,70,130,20,20,"Allow Sexual Reproduction?");
fl_set_button(obj, 1);
fl_end_group();
fdui->waste_decay_rate = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,35,330,200,20,"Waste Decay Rate:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 10000);
fl_set_slider_value(obj, 20);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 5);
fl_set_slider_increment(obj, 10, 10);
fdui->poison_decay_rate = obj = fl_add_valslider(FL_HOR_BROWSER_SLIDER,250,330,200,20,"Poison Decay Rate:");
fl_set_object_lsize(obj,FL_DEFAULT_SIZE);
fl_set_object_lalign(obj,FL_ALIGN_TOP);
fl_set_slider_precision(obj, 0);
fl_set_slider_bounds(obj, 0, 10000);
fl_set_slider_value(obj, 20);
fl_set_slider_size(obj, 0.10);
fl_set_slider_step(obj, 5);
fl_set_slider_increment(obj, 10, 10);
fl_end_form();
fdui->options->fdui = fdui;
return fdui;
}
void NeoWindow::HandleMainWinObject( FL_OBJECT *obj ) { // Handle command from form on main window
int scale = neo->scale, i;
if ( obj == mainWin->pause ) { // Pause/un-pause
if ( ! neo->setup ) return;
neo->started = true;
neo->paused = ! neo->paused;
Refresh( true );
} else if ( obj == mainWin->step ) { // If paused, update by one timestep
neo->started = true;
if ( neo->paused ) neo->nextStep = true;
} else if ( obj == mainWin->add_food ) { // Add food to world
neo->borrowed_energy -= neo->food_button_increment;
} else if ( obj == mainWin->remove_food ) { // Remove food
neo->borrowed_energy += neo->food_button_increment;
} else if ( obj == mainWin->file_menu ) {
const char *choice = fl_get_menu_text( obj );
if ( ! strcmp( "New", choice ) ) {
neo->started = false;
neo->paused = true;
neo->SetUpRun(); // Set up the run
Refresh( true );
//portal = new NeoPortal( 1115 );
//( portal = new NeoPortal() )->CallServer( "localhost", 1115 );
} else if ( ! strcmp( "Close", choice ) ) {
neo->started = false;
neo->paused = true;
Refresh( true );
} else if ( ! strcmp( "Load", choice ) ) {
const char *output = NULL;
if ( ( output = fl_show_fselector( "Load simulation from file:" , ".", "*",
neo->fileName ) ) != NULL ) {
strcpy( neo->fileName, output );
neo->LoadSimulation();
Refresh( true );
}
} else if ( ! strcmp( "Save", choice ) ) {
const char *output = NULL;
if ( ( output = fl_show_fselector( "Save simulation to file:" , ".", "*",
neo->fileName ) ) != NULL ) {
strcpy( neo->fileName, output );
neo->SaveSimulation();
}
Refresh();
} else if ( ! strcmp( "Print...", choice ) ) {
char tmp[50];
sprintf( tmp, "%s.%08d.ps", neo->fileName, neo->time_step );
const char *output = NULL;
if ( ( output = fl_show_fselector( "Print simulation to PostScript file:" , ".", "*",
tmp ) ) != NULL ) {
fl_object_ps_dump( mainWin->mainCanvas, tmp );
}
} else if ( ! strcmp( "Quit", choice ) ) {
neo->done = true;
neo->started = false;
neo->keepDrawing = false;
}
} else if ( obj == mainWin->other_menu ) {
const char *choice = fl_get_menu_text( obj );
if ( ! strcmp( "Update Display", choice ) ) {
neo->keepDrawing = ! neo->keepDrawing;
Refresh( true ); // Need to update the whole screen
} else if ( ! strcmp( "NNet Window", choice ) ) {
nnet_plot = create_form_neural_net_plot();
fl_add_canvas_handler( nnet_plot->mainCanvas, Expose, expose_callback, (void *) this );
fl_show_form( nnet_plot->neural_net_plot, FL_PLACE_MOUSE, FL_TRANSIENT, "Neural Net Plot" );
RedrawNNetPlot();
} else if ( ! strcmp( "Chart Window", choice ) ) {
chart_wind = create_form_chart_window();
fl_show_form( chart_wind->chart_window, FL_PLACE_MOUSE, FL_TRANSIENT, "Population Statistics" );
} else if ( ! strcmp( "Leave Trails", choice ) ) {
neo->leaveTrails = ! neo->leaveTrails;
if ( ! neo->leaveTrails ) Refresh( true );
} else if ( ! strcmp( "Add Bug", choice ) ) {
const char *output = NULL;
fl_add_fselector_appbutton( "Number", fselector_callback, this );
if ( ( output = fl_show_fselector( "Add creature from file:", ".", "*",
neo->creatureFile ) ) != NULL ) {
for ( int jj = 0; jj < neo->initialBugSeed; jj ++ ) {
strcpy( neo->creatureFile, output );
new Creature( Introduced, neo );
}
}
fl_remove_fselector_appbutton( "Number" );
Draw( true );
} else if ( ! strcmp( "Save Bug", choice ) ) {
if ( neo->output_creature < 0 ) return;
const char *output = NULL;
if ( ( output = fl_show_fselector( "Save creature to file:" , ".", "*",
neo->creatureFile ) ) != NULL ) {
Creature *creature = neo->ppCreatureList[ neo->output_creature ];
if ( creature != NULL ) creature->WriteGenotype( (char *) output );
}
} else if ( ! strcmp( "Options...", choice ) ) {
options_box = create_form_options();
FD_options *box = options_box;
if ( neo->started ) {
fl_deactivate_object( box->initial_parameters_group );
fl_set_object_label( box->initial_params_frame, "Initial Parameters (currently inactive)" );
}
fl_set_slider_value( box->initial_pop, neo->initial_creatures );
fl_set_slider_value( box->initial_plant, neo->num_initial_food_locs );
fl_set_slider_value( box->initial_flesh, neo->num_initial_meat_locs );
fl_set_button( box->give_head_start, neo->bGiveHeadStart );
fl_set_button( box->allow_sex, neo->bAllowSexual );
fl_set_button( box->allow_asex, neo->bAllowAsexual );
char tmp[5];
sprintf( tmp, "%d", neo->terrain_size );
fl_set_choice_text( box->terrain_size, tmp );
fl_set_slider_value( box->scale, neo->scale );
fl_set_slider_value( box->prob_crossover, neo->prob_crossover );
fl_set_slider_value( box->prob_mutation, neo->prob_mutation );
fl_set_slider_value( box->max_pop, neo->maximum_creatures );
fl_set_slider_value( box->min_pop, neo->nMinimumPopulation );
fl_set_slider_value( box->age_factor, neo->age_factor );
fl_set_slider_value( box->carcass_decay_rate, neo->nCarcassDecayRate );
fl_set_slider_value( box->waste_decay_rate, neo->nWasteDecayRate );
fl_set_slider_value( box->poison_decay_rate, neo->nPoisonDecayRate );
fl_set_button( box->give_head_start, neo->bGiveHeadStart );
fl_set_button( box->maintain_min_pop, neo->bKeepMinimumPopulation );
fl_set_button( box->use_survivor, neo->bUseSurvivorForMinimum );
fl_set_slider_value( box->save_every, neo->saveEveryNsteps );
if ( neo->saveEveryNsteps == -1 ) fl_set_button( box->save_sim, 0 );
else fl_set_button( box->save_sim, 1 );
fl_set_input( box->file_name, neo->fileName );
fl_show_form( box->options, FL_PLACE_MOUSE, FL_TRANSIENT, "Key Commands" );
}
}
}
void PlotButtonCB(FL_OBJECT *p0, long p1) {
FL_OBJECT *np = the_gui->NEntry;
FL_OBJECT *sp = the_gui->ProgressSlider;
FL_OBJECT *cp = the_gui->DistributionChoice;
FL_OBJECT *xyp = the_gui->xyplot;
RNG *rng = CreateRNG();
int n = atoi(fl_get_input(np));
double r;
int i, j;
int distrib[NB];
float xv[NB];
float yv[NB];
int di;
float dx;
unsigned long xl;
double sum, sumsq;
static char *mstring = new char[80];
static char *sdstring = new char[80];
int ymax;
double xmin, xmax;
if (rng == NULL)
return;
for (i=0; i<NB; i++)
distrib[i] = 0;
sum = sumsq = 0.0;
ymax = 0;
if (n >= PROGRESS_THRESHOLD) {
di = n/100; // update slider every 'di' points
fl_set_slider_value(sp,0.0);
fl_show_object(sp);
}
else
di = 0; // n too small; don't draw slider
xmin = atof(fl_get_input(the_gui->MinEntry));
xmax = atof(fl_get_input(the_gui->MaxEntry));
for (i=0; i<n; i++) {
r = ++(*rng); // get a sample from current distribution
sum += r;
sumsq += r*r;
j = fl_get_choice(cp);
if ((j == Binomial) || (j == Poisson))
r *= 10.0; // spread out integer values so we can see them
if (j == CDF) // 'dx' is a value added to each sample
dx = 0.0005; // the CDF demo RNG returns values that are exactly
else // on the divide between two bins, and roundoff
dx = 0.0; // errors lead to funny looking plots....
j = floor((r+dx-xmin)*NB/(xmax-xmin));
if ((j >= 0) && (j < NB)) {
distrib[j] += 1;
if (distrib[j] > ymax)
ymax = distrib[j];
}
if (di && ((i%di)==0))
fl_set_slider_value(sp,(double)i/(double)n);
}
fl_hide_object(sp); // all done; put away the slider
// Bins filled; transfer to x and y vectors and plot. The xyplot
// widget will scale x and y automatically.
fl_delete_xyplot_text(xyp,mstring);
fl_delete_xyplot_text(xyp,sdstring);
for (i=0; i<NB; i++) {
xv[i] = (float)i*(xmax-xmin)/NB + xmin;
yv[i] = (float)distrib[i];
}
if (xmin == xmax)
fl_set_xyplot_xbounds(xyp,xmin+1.0,xmax); // auto-scale if min>max
else
fl_set_xyplot_xbounds(xyp,xmin,xmax);
fl_set_xyplot_data(xyp, xv, yv, NB, "", "", "");
// compute, display sample mean and sample standard deviation
double dn = double(n);
double mean = sum/dn;
double sd = sqrt(dn*((sumsq/dn)-mean*mean)/(dn-1));
sprintf(mstring,"Sample Mean = %f",mean);
sprintf(sdstring,"Standard Dev = %f",sd);
// The (x,y) coords of the string are defined in terms of scaled plot
// units. If the right edge of the x scale is at 100, put the text
// at 80. Put the top string near the top of the plot, and the bottom
// string 10% lower.
double y1 = double(ymax) - .05*(double(ymax));
double y2 = double(ymax) - .10*(double(ymax));
fl_add_xyplot_text(xyp,(xmax-xmin)*0.8+xmin,y1,mstring,FL_ALIGN_CENTER,FL_BLACK);
fl_add_xyplot_text(xyp,(xmax-xmin)*0.8+xmin,y2,sdstring,FL_ALIGN_CENTER,FL_BLACK);
delete rng; // some RNGs allocate internal tables....
}
