예제 #1
0
/**
 * track replay, also being called by map_invalidate_view()
 */
static void replay_redraw_view()
{
	map_draw_back_layers(g_view.da->window);

	replay_calculate_pixel();

	replay_draw_lines();

	replay_draw_flag(last_point);

	/* draw current position */
	draw_current_position();
}
예제 #2
0
void ViewmdaWidget1D::paintEvent ( QPaintEvent * event ) {
	m_plot_data_real.clear();
	m_plot_data_imag.clear();	
	QPainter painter(this);
	if (!m_model) return;
	
	
	
	for (long j=0; j<m_model->N1(); j++) {
		m_plot_data_real << m_model->get(j).re();
		m_plot_data_imag << m_model->get(j).im();
	}
	m_minval=-m_model->windowMax();
	m_maxval=m_model->windowMax();

	QPainterPath	re_path;
	QPainterPath im_path;
	double dwidth=(double)width();
	double dheight=(double)height();
	for (long j=0; j<m_plot_data_real.count(); j++) {
		
		double re=m_plot_data_real[j];
		double im=m_plot_data_imag[j];
		if (j==0) {
			re_path.moveTo(indexToPoint(j,re));
			im_path.moveTo(indexToPoint(j,im));
		}
		else {
			re_path.lineTo(indexToPoint(j,re));
			im_path.lineTo(indexToPoint(j,im));
		}
	}
	painter.setPen(QPen(Qt::black,1));
	painter.drawLine(indexToPoint(0,0),indexToPoint(m_plot_data_real.count()-1,0));
	painter.setPen(QPen(Qt::darkBlue,3));
	painter.drawPath(re_path);
	painter.setPen(QPen(Qt::darkRed,3));
	painter.drawPath(im_path);
	
	draw_current_position(painter);
}
예제 #3
0
static void *replay_routine()
{
	if (total_records == 0)
		return NULL;

	sigset_t sig_set;
	sigemptyset(&sig_set);
	sigaddset(&sig_set, SIGINT);
	pthread_sigmask(SIG_BLOCK, &sig_set, NULL);

	pthread_context_t *ctx = register_thread("track replay thread",
		NULL, replay_thread_cleanup_func);

	running = TRUE;

	while(running) {

		stop = FALSE;
		suspend = FALSE;
		suspending = FALSE;
		last_draw_idx = -1;

		/* settings */
		LOCK_UI();

		replay_update_ui_helper(TRUE);

		map_draw_back_layers(g_view.da->window);

		RESET_LAST_POINT();

		/* the record index in the containing block */
		int last_time_offset = 0;
		int span, orient, start_idx, end_idx, inc;

		if (direction_forward) {
			start_idx = 0;
			end_idx = total_records - 1;
			inc = 1;
			orient = GTK_PROGRESS_LEFT_TO_RIGHT;
		} else {
			start_idx = total_records - 1;
			end_idx = 0;
			inc = -1;
			orient = GTK_PROGRESS_RIGHT_TO_LEFT;
		}

		gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(progress_bar), orient);
		gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress_bar), 0);

		gtk_button_set_label(GTK_BUTTON(start_button), "stop");
		gtk_widget_set_sensitive(start_button, TRUE);
		gtk_widget_set_sensitive(suspend_button, TRUE);
		gtk_widget_set_sensitive(toend_button, TRUE);
		gtk_widget_set_sensitive(direction_button, FALSE);

		speed = gtk_adjustment_get_value(adjustment);

		/* calculate pixels in tile map */
		replay_calculate_pixel();

		UNLOCK_UI();

		int i, from = start_idx, to;

		/* FIXME: better to use sigjmp here */
		for (i=start_idx; direction_forward? i<=end_idx : i>=end_idx; i+=inc) {

			if (! running) {
				goto EXIT;
			} else if (stop) {
				stop = FALSE;
				goto STOP;
			} else if (toend) {
				toend = FALSE;
				i = end_idx;
			} else if (suspend) {
				suspend = FALSE;
				suspending = TRUE;
				wait_ms(0, &replay_cond, &replay_lock, TRUE);
				suspending = FALSE;
				LOCK_UI();
				gtk_button_set_label(GTK_BUTTON(suspend_button), "suspend");
				UNLOCK_UI();
			}

			span = abs(replay_records[i].time_offset - last_time_offset) / speed;
			if (span < 1 && i != end_idx)
				continue;
			if (span > 1)
				span = 1; // don't wait too long

			to = i;
			LOCK_UI();
			replay_update_ui(from, to);
			UNLOCK_UI();
			from = to + inc;

			sleep(1);

			last_time_offset = replay_records[i].time_offset;
		}

		last_draw_idx = end_idx;

		/* draw current position */
		draw_current_position();

STOP:

		LOCK_UI();
		replay_reset_states();
		UNLOCK_UI();

		/* wait for restart */
		wait_ms(0, &replay_cond, &replay_lock, TRUE);
	}

EXIT:

	free(ctx);

	return NULL;
}