Esempio n. 1
0
/* 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;
}
Esempio n. 3
0
File: ship.c Progetto: fstltna/ImpFE
/*
 * 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);
}
Esempio n. 4
0
File: ship.c Progetto: fstltna/ImpFE
/*
 * 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);
}