/* fill the browser */
void FillBrowser(Int4 entries )
{
Int4 index;
Int4 real_index;
char bl[100];
fl_freeze_form(xew_mainf);
fl_clear_browser(wad_brow);
/* make a legend */
sprintf(bl,"@_@fName Type Index");
fl_add_browser_line(wad_brow, bl);
for ( index = 0; index < entries; index++ ) {
real_index = LinearMap[index+2];
sprintf(bl,"%-8.8s %-7.7s %5d", pDirEnt[real_index].name,
TagString( pEntryTag[real_index] ),
real_index );
fl_add_browser_line(wad_brow, bl);
}
fl_select_browser_line(wad_brow,1);
fl_unfreeze_form(xew_mainf);
}
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;
}
/*
* buildShDetDisp - Clears the existing contents of the ship detail
* window and redraws it based on current known
* ships.
*/
void buildShDetDisp(void)
{
ULONG itNum;
USHORT num_comp=0, num_eng=0, num_life=0, num_wpn=0, num_elect=0;
FeShip_t tmpShip;
FeItem_t tmpItem;
int compChar, engChar, lifeChar, photChar, blasChar, sensChar,
shldChar, telepChar, tractChar;
char workBuf[90], nameBuf[10], itType, location[15], tBuff[28], inst;
/* Speed up output */
fl_freeze_form(fd_ShipDetailForm->ShipDetailForm);
/* Clear the existing contents, if any */
fl_clear_browser(fd_ShipDetailForm->ShDetItem);
compChar = (int) BIG_PART_CHAR[bp_computer];
engChar = (int) BIG_PART_CHAR[bp_engines];
lifeChar = (int) BIG_PART_CHAR[bp_lifeSupp];
photChar = (int) BIG_PART_CHAR[bp_photon];
blasChar = (int) BIG_PART_CHAR[bp_blaser];
sensChar = (int) BIG_PART_CHAR[bp_sensors];
shldChar = (int) BIG_PART_CHAR[bp_shield];
telepChar = (int) BIG_PART_CHAR[bp_teleport];
tractChar = (int) BIG_PART_CHAR[bp_tractor];
/* Loop for each known big item */
for (itNum=0; itNum < next_item; itNum++)
{
/* Make sure the item has been seen and is on the ship */
if (!readItem(&tmpItem, itNum))
{
continue;
}
if ((tmpItem.last_seen != 0) && (tmpItem.where == LastShip) &&
!(tmpItem.flags & BF_ONPLAN))
{
if (tmpItem.owner != 0)
{
strncpy(nameBuf, Player[tmpItem.owner].name, 9);
nameBuf[9] = '\0';
}
else
{
strcpy(nameBuf, "???");
}
if (tmpItem.type != 0)
{
itType=tmpItem.type;
}
else
{
itType='?';
}
/* Check if it is installed, or just cargo */
if (tmpItem.flags & BF_INSTALL)
{
/* Installed */
inst='Y';
/* Increment our running counts */
if (itType == tractChar)
{
num_comp++;
}
else if (itType == engChar)
{
num_eng++;
}
else if (itType == lifeChar)
{
num_life++;
}
else if ((itType == photChar) || (itType == blasChar))
{
num_wpn++;
}
else if ((itType == sensChar) || (itType == shldChar) ||
(itType == telepChar) || (itType == tractChar))
{
num_elect++;
}
}
else
{
/* Not installed, just being carried */
inst=' ';
}
sprintf(workBuf, "%8u %c %3u %3u %5u %c", itNum,
itType, tmpItem.it_tf, tmpItem.efficiency,
tmpItem.weight, inst);
fl_add_browser_line(fd_ShipDetailForm->ShDetItem, workBuf);
}
}
/* read the ship in */
(void) readShip(&tmpShip, LastShip);
/* Update using the counts we saw before */
tmpShip.num_comp = num_comp;
tmpShip.num_eng = num_eng;
tmpShip.num_life = num_life;
tmpShip.num_wpn = num_wpn;
tmpShip.num_elect = num_elect;
/* Write ship back */
(void) writeShip(&tmpShip, LastShip);
sprintf(workBuf, "%u", tmpShip.fuelLeft);
fl_set_object_label(fd_ShipDetailForm->Fuel, workBuf);
sprintf(workBuf, "%u", tmpShip.energy);
fl_set_object_label(fd_ShipDetailForm->Energy, workBuf);
sprintf(workBuf, "%u", tmpShip.armourLeft);
fl_set_object_label(fd_ShipDetailForm->Armor, workBuf);
sprintf(workBuf, "%u", tmpShip.shields);
fl_set_object_label(fd_ShipDetailForm->Shields, workBuf);
sprintf(workBuf, "%u", tmpShip.shieldsKeep);
fl_set_object_label(fd_ShipDetailForm->ShKeep, workBuf);
sprintf(workBuf, "%u", tmpShip.airLeft);
fl_set_object_label(fd_ShipDetailForm->Air, workBuf);
sprintf(workBuf, "%u", tmpShip.efficiency);
fl_set_object_label(fd_ShipDetailForm->Effic, workBuf);
sprintf(workBuf, "%u", tmpShip.sh_tf);
fl_set_object_label(fd_ShipDetailForm->TF, workBuf);
sprintf(workBuf, "%u", tmpShip.hullTF);
fl_set_object_label(fd_ShipDetailForm->HullTF, workBuf);
sprintf(workBuf, "%u", tmpShip.engTF);
fl_set_object_label(fd_ShipDetailForm->EngTF, workBuf);
sprintf(workBuf, "%u", tmpShip.engEff);
fl_set_object_label(fd_ShipDetailForm->EngEff, workBuf);
if (tmpShip.plagueStage != 0)
{
fl_set_object_label(fd_ShipDetailForm->Plague, "YES");
}
else
{
fl_set_object_label(fd_ShipDetailForm->Plague, "NO");
}
sprintf(workBuf, "%u", tmpShip.num_civ);
fl_set_object_label(fd_ShipDetailForm->Civ, workBuf);
sprintf(workBuf, "%u", tmpShip.num_sci);
fl_set_object_label(fd_ShipDetailForm->Sci, workBuf);
sprintf(workBuf, "%u", tmpShip.num_mil);
fl_set_object_label(fd_ShipDetailForm->Mil, workBuf);
sprintf(workBuf, "%u", tmpShip.num_ofc);
fl_set_object_label(fd_ShipDetailForm->Ofc, workBuf);
sprintf(workBuf, "%u", tmpShip.num_torp);
fl_set_object_label(fd_ShipDetailForm->Torp, workBuf);
sprintf(workBuf, "%u", tmpShip.num_ore);
fl_set_object_label(fd_ShipDetailForm->Ore, workBuf);
sprintf(workBuf, "%u", tmpShip.num_gold);
fl_set_object_label(fd_ShipDetailForm->Bars, workBuf);
sprintf(workBuf, "%u", tmpShip.num_airt);
fl_set_object_label(fd_ShipDetailForm->AirTnk, workBuf);
sprintf(workBuf, "%u", tmpShip.num_ftnk);
fl_set_object_label(fd_ShipDetailForm->FuelTnk, workBuf);
sprintf(workBuf, "%u", tmpShip.cargo);
fl_set_object_label(fd_ShipDetailForm->Cargo, workBuf);
strcpy(workBuf, ctime(&tmpShip.last_seen));
workBuf[24]='\0'; /* strip off NL */
fl_set_object_label(fd_ShipDetailForm->Seen, workBuf);
sprintf(workBuf, "%u", LastShip);
fl_set_object_label(fd_ShipDetailForm->ShNum, workBuf);
sprintf(workBuf, "%u,%u", tmpShip.sh_row, tmpShip.sh_col);
fl_set_object_label(fd_ShipDetailForm->RowCol, workBuf);
if (tmpShip.owner != 0)
{
strcpy(workBuf, Player[tmpShip.owner].name);
}
else
{
strcpy(workBuf, "???");
}
fl_set_object_label(fd_ShipDetailForm->Owner, workBuf);
if (tmpShip.flags & BF_ONPLAN)
{
sprintf(workBuf, "Ship is on planet %u", tmpShip.planet);
fl_set_object_label(fd_ShipDetailForm->Where, workBuf);
}
else
{
fl_set_object_label(fd_ShipDetailForm->Where, "Ship is in space");
}
fl_unfreeze_form(fd_ShipDetailForm->ShipDetailForm);
}
/*
* buildShCensus - Clears the existing contents of the ship census
* window and redraws it based on current known
* ships.
*/
void buildShCensus(void)
{
ULONG shNum, crew;
USHORT eff;
FeShip_t tmpShip;
char workBuf[90], nameBuf[10], shType, location[15], crewBuf[5],
tBuff[28], shName[10];
/* Speed up output */
fl_freeze_form(fd_ShipCensusForm->ShipCensusForm);
/* Clear the existing contents, if any */
fl_clear_browser(fd_ShipCensusForm->ShBrowse);
/* Loop for each known ship */
fprintf(stderr, "*** start of loop\n");
for (shNum=0; shNum < next_ship; shNum++)
{
fprintf(stderr, "*** shNum is %u!\n", shNum);
fprintf(stderr, "*** next_ship is %u!\n", next_ship);
/* Make sure the ship has been seen */
if (readShip(&tmpShip, shNum))
{
fprintf(stderr, "*** readShip ok %u!\n", shNum);
if(tmpShip.last_seen != 0)
{
fprintf(stderr, "*** tempship ok %u!\n", shNum);
if (tmpShip.owner != 0)
{
fprintf(stderr, "*** owner %u!\n", tmpShip.owner);
strncpy(nameBuf, Player[tmpShip.owner].name, 9);
nameBuf[9] = '\0';
}
else
{
fprintf(stderr, "*** unknown owner\n");
strcpy(nameBuf, "???");
}
strncpy(shName, tmpShip.name, 9);
shName[9]='\0';
if (tmpShip.ShipType != 0)
{
fprintf(stderr, "*** ship type %u!\n", tmpShip.ShipType);
shType = tmpShip.ShipType;
}
else
{
fprintf(stderr, "*** ship type unknown!\n");
shType = '?';
}
crew = tmpShip.num_civ + tmpShip.num_mil + tmpShip.num_sci +
tmpShip.num_ofc;
fprintf(stderr, "*** ship crew %u!\n", crew);
if (crew < 1000)
{
sprintf(crewBuf, "%3u", crew);
}
else if (crew < 10000)
{
sprintf(crewBuf, "%2uX", crew / 100);
}
else
{
sprintf(crewBuf, "%2uK", crew / 1000);
}
fprintf(stderr, "*** about to set ship location\n");
sprintf(location, "%4u, %4u", tmpShip.sh_row, tmpShip.sh_col);
strcpy(tBuff, ctime(&tmpShip.last_seen));
tBuff[19]='\0';
sprintf(workBuf, "%8u %8s %8s %c %s %s %3u %s", shNum,
shName, nameBuf, shType, location, crewBuf, tmpShip.efficiency,
&tBuff[4]);
fprintf(stderr, "*** about to add browser line\n");
fl_add_browser_line(fd_ShipCensusForm->ShBrowse, workBuf);
}
}
}
fprintf(stderr, "*** about to unfreeze form\n");
fl_unfreeze_form(fd_ShipCensusForm->ShipCensusForm);
}
void
receiver_leave (FL_OBJECT *ob, long data)
{
FILE *fp;
int pid;
rcvr_runrun = 0;
if (data > -1 && (fp = fopen ("receiver.pid", "r")) != NULL)
{
fl_hide_form (fd_receiver_main->receiver_main);
hide_info(NULL, 0);
hide_interferometer (NULL, 0);
hide_waterfall (NULL, 0);
tp_hide (NULL, 0);
spectrum_hide (NULL, 0);
dismiss_psr (NULL, 0);
fl_show_form (fd_receiver_shutdown->receiver_shutdown, FL_PLACE_CENTER, FL_NOBORDER, "IRA Shutdown");
fl_check_forms ();
fscanf (fp, "%d", &pid);
kill (pid, SIGINT);
sleep (1);
kill (pid, SIGHUP);
sleep (1);
kill (pid, SIGKILL);
fclose (fp);
}
if (data < -1)
{
char string[129];
if (before)
{
fprintf (stderr, "Leaving from: %s\n", __FUNCTION__);
receiver_leave (ob, 0);
}
before++;
fp = fopen ("receiver_py.err", "r");
fl_set_browser_fontsize(fd_receiver_error->error_browser, 14);
fl_set_browser_fontstyle(fd_receiver_error->error_browser, FL_BOLD_STYLE);
if (fp != NULL)
{
while (fgets (string, 128, fp) != NULL)
{
string[strlen(string)-1] = '\0';
fl_add_browser_line (fd_receiver_error->error_browser, string);
}
fclose (fp);
if ((fp = fopen ("receiver_py.log", "r"))!= NULL)
{
while (fgets (string, 128, fp) != NULL)
{
string[strlen(string)-1] = '\0';
fl_add_browser_line (fd_receiver_error->error_browser, string);
}
}
}
else
{
fl_add_browser_line (fd_receiver_error->error_browser, "No Error Information Is Available");
}
if (data == -10)
{
fl_add_browser_line (fd_receiver_error->error_browser,
"I/O Timeout from Gnu Radio--no data for >30 seconds");
fprintf (stderr, "I/O timeout--exiting");
}
fl_show_form (fd_receiver_error->receiver_error, FL_PLACE_CENTER, FL_FULLBORDER, "IRA Errors");
fl_check_forms ();
no_more_input = 1;
return;
}
exit (0);
}