#include <gtk/gtk.h>
#include <stdio.h>
#include <stdint.h>
#include <errno.h>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string.h>
#include "drawing.h"
#include "absgeo.h"
#include "event.h"
#include "geo.h"
#include "tracks.h"
#include "vertices.h"
#include "hits.h"
#include "status.h"
#include "zoompan.h"
#include "active.h"

Functions
static void	change_highlighted_reco ()

static void	change_highlighted_cell (const int oldactive_plane, const int oldactive_cell)

void	update_active_objects (const noe_view_t V, const int x, const int y)

static gboolean	pollmouseover (__attribute__((unused)) gpointer data)

static gboolean	mouseover (GtkWidget widg, GdkEventMotion gevent, __attribute__((unused)) gpointer data)

static gboolean	to_next_free_run (__attribute__((unused)) gpointer data)

static void	draw_whole_user_event ()

static gboolean	animation_step (__attribute__((unused)) gpointer data)

static gboolean	handle_event ()

static gboolean	draw_event_from_timer (__attribute__((unused)) gpointer data)

static bool	get_event (const int change)

static gboolean	prefetch_an_event (__attribute__((unused)) gpointer data)

static void	prepare_to_swich_events ()

static void	to_next (__attribute__((unused)) GtkWidget *widget, gpointer data)

static bool	have_event_by_number (const unsigned int n)

static gboolean	clear_error_message (__attribute__((unused)) gpointer dt)

static void	getuserevent ()

static void	stop_freerun_timer ()

static void	start_freerun_timer ()

static void	toggle_freerun (__attribute__((unused)) GtkWidget *w, __attribute__((unused)) gpointer dt)

static void	toggle_cum_ani (GtkWidget *w, __attribute__((unused)) gpointer dt)

static void	set_intervals (const int speednum)

static void	toggle_animate (GtkWidget *w, __attribute__((unused)) gpointer dt)

static void	restart_animation (__attribute__((unused)) GtkWidget *w, __attribute__((unused)) gpointer d)

static void	adjusttick (GtkWidget *wg, const gpointer dt)

static void	adjustspeed (GtkWidget *wg, __attribute__((unused)) const gpointer dt)

static gboolean	redraw_window (GtkWidget mainwin, GdkEventConfigure event, __attribute__((unused)) gpointer d)

static void	close_window ()

static void	openvertexwin ()

static void	opentrackwin ()

static GtkWidget *	make_tickslider (const bool ismax)

static GtkWidget *	make_speedslider ()

static void	set_bg_color_to_main (GtkWidget *widg)

static void	makestatbox (const int i)

static GtkWidget *	make_ticklabel (const bool ismax)

static GtkWidget *	make_speedlabel ()

static GtkWidget *	make_ueventbox ()

static GtkWidget *	make_aux_win (const char *const name, const statcontents si)

static void	setup ()

void	realmain (const bool have_read_all)

Variables
static int	TDCSTEP = 4

std::vector< noeevent >	theevents

int	gevi = 0

int	active_plane = -1

int	active_cell = -1

int	active_track = -1

int	active_vertex = -1

int	first_mucatcher

int	ncells_perplane

int	nplanes

GtkWidget *	statbox [NSTATBOXES]

GtkTextBuffer *	stattext [NSTATBOXES]

GtkWidget *	edarea [kXorY]

cairo_pattern_t *	eventpattern [kXorY]

static GtkWidget *	mainwin = NULL

static GtkWidget *	trackwin = NULL

static GtkWidget *	vertexwin = NULL

static GtkWidget *	animate_checkbox = NULL

static GtkWidget *	cum_ani_checkbox = NULL

static GtkWidget *	freerun_checkbox = NULL

static GtkWidget *	ueventbut = NULL

static GtkWidget *	ueventbox = NULL

static GtkWidget *	mintickslider = NULL

static GtkWidget *	maxtickslider = NULL

static GtkObject *	speedadj = NULL

bool	ghave_read_all = false

static bool	prefetching = false

static bool	adjusttick_callback_inhibit = false

static bool	animate = false

static bool	cumulative_animation = true

static bool	free_running = false

static gulong	freeruninterval = 0

static gulong	animationinterval = 0

static gulong	freeruntimeoutid = 0

static gulong	animatetimeoutid = 0

static gulong	statmsgtimeoutid = 0

Function Documentation

static void adjustspeed	(	GtkWidget *	wg,
		__attribute__((unused)) const gpointer	dt
	)

static

Definition at line 646 of file main.cxx.

References animate, animatetimeoutid, animation_step(), animationinterval, free_running, std::max(), set_intervals(), start_freerun_timer(), and stop_freerun_timer().

Referenced by make_speedslider().

 {
   set_intervals(gtk_adjustment_get_value(GTK_ADJUSTMENT(wg)));
 
   stop_freerun_timer();
   if(free_running && !animate) start_freerun_timer();
 
   if(animatetimeoutid) g_source_remove(animatetimeoutid);
   if(animate)
     animatetimeoutid =
       g_timeout_add(std::max(1, (int)animationinterval),
                     animation_step, NULL);
   else
     animatetimeoutid = 0;
 }

static void adjusttick	(	GtkWidget *	wg,
		const gpointer	dt
	)

static

Definition at line 601 of file main.cxx.

References adjusttick_callback_inhibit, animate, animatetimeoutid, DRAWPARS::clear, noeevent::current_maxtick, noeevent::current_mintick, draw_event(), E, DRAWPARS::firsttick, gevi, DRAWPARS::lasttick, std::max(), std::min(), restart_animation(), theevents, noeevent::user_maxtick, and noeevent::user_mintick.

Referenced by make_tickslider().

 {
   if(adjusttick_callback_inhibit) return;
 
   noeevent & E = theevents[gevi];
 
   const bool adjmax = *(bool *)dt;
 
   // TODO: respond intelligently if the user gives a maximum less
   // than the minimum.  Currently does something dumb.
 
   (adjmax? E.user_maxtick: E.user_mintick)
     = gtk_adjustment_get_value(GTK_ADJUSTMENT(wg));
 
   const int32_t oldcurrent_maxtick = E.current_maxtick;
   const int32_t oldcurrent_mintick = E.current_mintick;
   if(animate){
     E.current_maxtick = std::min(E.current_maxtick, E.user_maxtick);
     E.current_mintick = std::max(E.current_mintick, E.user_mintick);
   }
   else{
     E.current_maxtick = E.user_maxtick;
     E.current_mintick = E.user_mintick;
   }
 
   DRAWPARS drawpars;
   drawpars.clear = E.current_maxtick < oldcurrent_maxtick ||
                    E.current_mintick > oldcurrent_mintick;
 
   // TODO can optimize this to only draw the new range
   drawpars.firsttick = E.current_mintick;
   drawpars.lasttick  = E.current_maxtick;
 
   // Restart the animation if the minimum has changed, OR if the maximum
   // has changed but we've finished animating, OR if the maximum has
   // changed and is now less than where we were. TODO: This could be
   // better.
   if(animate && (!adjmax || animatetimeoutid == 0 ||
                  oldcurrent_maxtick < E.current_maxtick))
     restart_animation(NULL, NULL);
   else
     draw_event(&drawpars);
 }

static gboolean animation_step ( __attribute__((unused)) gpointer data )

static

Definition at line 260 of file main.cxx.

References animate, animatetimeoutid, DRAWPARS::clear, cumulative_animation, noeevent::current_maxtick, noeevent::current_mintick, draw_event(), E, DRAWPARS::firsttick, free_running, gevi, DRAWPARS::lasttick, TDCSTEP, theevents, and to_next_free_run().

Referenced by adjustspeed(), and handle_event().

 {
   noeevent & E = theevents[gevi];
 
   DRAWPARS drawpars;
   // Must redraw if we are just starting the animation, or if it is
   // non-cumulative, i.e. the old hits have to be re-hidden
   drawpars.clear = E.current_maxtick == theevents[gevi].user_mintick ||
                    !cumulative_animation;
 
   E.current_maxtick += TDCSTEP;
 
   // Necessary to make visible_hit() work.  Otherwise, hits incorrectly
   // become visible when moused over.
   if(!cumulative_animation) E.current_mintick = E.current_maxtick;
 
   drawpars.firsttick = E.current_maxtick-(TDCSTEP-1);
   drawpars.lasttick  = E.current_maxtick;
   draw_event(&drawpars);
 
   const bool stillanimating =
     animate && E.current_maxtick < theevents[gevi].user_maxtick;
 
   // If we are animating and free running, go directly to the next event
   // at the end of this one, not worrying about the free run delay. This
   // avoids the need to switch back and forth between timers. Keep the
   // animation timer running unless this was the last event, as signaled
   // by the return value of to_next_free_run().
   if(!stillanimating && free_running)
     return to_next_free_run(NULL);
 
   // Immediately zero this so that other functions can know that the
   // animation isn't active.
   if(!stillanimating) animatetimeoutid = 0;
 
   return stillanimating;
 }

static void change_highlighted_cell	(	const int	oldactive_plane,
		const int	oldactive_cell
	)

static

Definition at line 157 of file main.cxx.

References active_cell, active_plane, hit::cell, draw_hit(), edarea, gevi, MECModelEnuComparisons::i, kX, kXorY, kY, hit::plane, theevents, and allInOneTrainingPlots::window.

Referenced by update_active_objects().

 {
   cairo_t * cr[kXorY];
   for(int i = 0; i < kXorY; i++){
     cr[i] = gdk_cairo_create(edarea[i]->window);
     cairo_set_line_width(cr[i], 1.0);
   }
 
   std::vector<hit> & THEhits = theevents[gevi].hits;
 
   // We may need to find any number of hits since more than one hit
   // can be in the same cell.  It is not guaranteed that the same hit
   // ends up visible, but I'm just going to live with that.
   for(unsigned int i = 0; i < THEhits.size(); i++){
     hit & thishit = THEhits[i];
     if((thishit.plane == oldactive_plane && thishit.cell == oldactive_cell) ||
        (thishit.plane ==    active_plane && thishit.cell ==    active_cell))
       draw_hit(cr[thishit.plane%2 == 1?kX:kY], thishit, edarea);
   }
 
   // NOTE: In principle we should redraw tracks here since we may have just
   // stomped on some.  However, in practice the visual effect isn't very
   // noticeable and since it's kinda a pain to do it from here, we'll skip it.
 
   for(int i = 0; i < kXorY; i++) cairo_destroy(cr[i]);
 }

static void change_highlighted_reco ( )

static

Definition at line 124 of file main.cxx.

References DRAWPARS::clear, draw_tracks(), draw_vertices(), edarea, eventpattern, DRAWPARS::firsttick, gevi, MECModelEnuComparisons::i, kXorY, DRAWPARS::lasttick, theevents, and allInOneTrainingPlots::window.

Referenced by update_active_objects().

 {
   // You can't just overdraw a track because it doesn't light up precise
   // rows of pixels. The way Cairo works, you end up with a thicker
   // track with bits of both colors in it. XXX This doesn't quite work
   // right with animations.  If a track is highlighted and then there's
   // an animation step, the bits-of-both-colors problem still appears.
   // But this is a pretty minor problem.
   cairo_t * cr[kXorY];
   for(int i = 0; i < kXorY; i++){
     cairo_push_group(cr[i] = gdk_cairo_create(edarea[i]->window));
     cairo_set_source(cr[i], eventpattern[i]);
     cairo_paint(cr[i]);
   }
 
   DRAWPARS drawpars;
   drawpars.firsttick = theevents[gevi].current_mintick;
   drawpars.lasttick  = theevents[gevi].current_maxtick;
   drawpars.clear = true;
   draw_tracks(cr, &drawpars);
   draw_vertices(cr, &drawpars);
 
   for(int i = 0; i < kXorY; i++){
     cairo_pop_group_to_source(cr[i]);
     cairo_paint(cr[i]);
     cairo_destroy(cr[i]);
   }
 }

static gboolean clear_error_message ( __attribute__((unused)) gpointer dt )

static

Definition at line 433 of file main.cxx.

References FALSE, set_status(), and staterror.

Referenced by getuserevent().

 {
   set_status(staterror, "");
   return FALSE;
 }

static void close_window ( )

static

Definition at line 683 of file main.cxx.

Referenced by setup().

 {
   // We could quit gently:
   // gtk_main_quit(); exit(0);
   // But there is nothing to save, so just drop everything quickly.
   _exit(0);
 }

static gboolean draw_event_from_timer ( __attribute__((unused)) gpointer data )

static

Definition at line 335 of file main.cxx.

References draw_whole_user_event(), and FALSE.

Referenced by realmain().

 {
   draw_whole_user_event();
   return FALSE; // don't call me again
 }

static void draw_whole_user_event ( )

static

Definition at line 243 of file main.cxx.

References DRAWPARS::clear, draw_event(), DRAWPARS::firsttick, free_running, freeruninterval, gevi, DRAWPARS::lasttick, pollmouseover(), and theevents.

Referenced by draw_event_from_timer(), and handle_event().

 {
   theevents[gevi].current_mintick = theevents[gevi].user_mintick;
   theevents[gevi].current_maxtick = theevents[gevi].user_maxtick;
 
   DRAWPARS drawpars;
   drawpars.firsttick = theevents[gevi].current_mintick;
   drawpars.lasttick  = theevents[gevi].current_maxtick;
   drawpars.clear = true;
   draw_event(&drawpars);
 
   // get cells, etc. highlighted a little faster.  For tracks, must call
   // this *after* draw_event so that screentrack is filled. Don't do
   // this if the speed is 11.
   if(!free_running || freeruninterval > 1) pollmouseover(NULL);
 }

static bool get_event ( const int change )

static

Definition at line 349 of file main.cxx.

References gevi, ghave_read_all, and theevents.

Referenced by realmain(), setup(), and to_next().

 {
   if(gevi+change >= (int)theevents.size()){
     if(ghave_read_all){
       gevi = theevents.size() - 1;
     }
     else{
       // NOTE: this does not work with abs(change) > 1, but it doesn't
       // matter since we never call get_event with a bigger number.
       //
       // NOTE: Leaving the GTK loop *seems* to be OK, but I'm not clear
       // on what happens when user events arrive when we're outside.
       gtk_main_quit();
       return false;
     }
   }
   else if(gevi+change < 0){
     gevi = 0;
   }
   else{
     gevi += change;
   }
 
   return true;
 }

static void getuserevent ( )

static

Definition at line 440 of file main.cxx.

References clear_error_message(), errno, gevi, ghave_read_all, handle_event(), have_event_by_number(), makeTrainCVSamples::int, nevent, prepare_to_swich_events(), set_status(), staterror, statmsgtimeoutid, theevents, and ueventbox.

Referenced by make_ueventbox(), and setup().

 {
   errno = 0;
   char * endptr;
   const int userevent =
     strtol(gtk_entry_get_text(GTK_ENTRY(ueventbox)), &endptr, 10);
 
   clear_error_message(NULL);
 
   if((errno == ERANGE && (userevent == INT_MAX || userevent == INT_MIN))
      || (errno != 0 && userevent == 0)
      || endptr == optarg || *endptr != '\0'
      || !have_event_by_number(userevent)){
     if(!theevents.empty())
       set_status(staterror, "Entered event invalid or not available. I have "
                  "events %d through %d%s%s",
                  theevents[0].nevent,
                  theevents[theevents.size()-1].nevent,
                  theevents[theevents.size()-1].nevent-theevents[0].nevent
                  == theevents.size()-1?"":" (not consecutive)",
                  ghave_read_all?"":". I'm still loading events.");
     if(statmsgtimeoutid) g_source_remove(statmsgtimeoutid);
     statmsgtimeoutid = g_timeout_add(8e3, clear_error_message, NULL);
     return;
   }
 
   if(userevent == (int)theevents[gevi].nevent) return;
 
   const bool forward = userevent > (int)theevents[gevi].nevent;
   while(userevent != (int)theevents[gevi].nevent)
     // Don't go through get_event because we do *not* want to try
     // getting more events from the file
     gevi += (forward?1:-1);
 
   prepare_to_swich_events();
   handle_event();
 }

static gboolean handle_event ( )

static

Definition at line 298 of file main.cxx.

References adjusttick_callback_inhibit, animate, animatetimeoutid, animation_step(), animationinterval, noeevent::current_maxtick, noeevent::current_mintick, draw_whole_user_event(), E, FALSE, gevi, std::max(), noeevent::maxtick, maxtickslider, noeevent::mintick, mintickslider, theevents, noeevent::user_maxtick, and noeevent::user_mintick.

Referenced by getuserevent(), restart_animation(), setup(), to_next(), toggle_animate(), and toggle_freerun().

 {
   noeevent & E = theevents[gevi];
   adjusttick_callback_inhibit = true;
   gtk_spin_button_set_range(GTK_SPIN_BUTTON(maxtickslider), E.mintick, E.maxtick);
   gtk_spin_button_set_range(GTK_SPIN_BUTTON(mintickslider), E.mintick, E.maxtick);
   gtk_spin_button_set_value(GTK_SPIN_BUTTON(maxtickslider), E.user_maxtick);
   gtk_spin_button_set_value(GTK_SPIN_BUTTON(mintickslider), E.user_mintick);
   gtk_widget_draw(maxtickslider, NULL);
   gtk_widget_draw(mintickslider, NULL);
   adjusttick_callback_inhibit = false;
 
   if(animate){
     E.current_maxtick = E.current_mintick = E.user_mintick;
     if(animatetimeoutid) g_source_remove(animatetimeoutid);
 
     // Do one step immediately to be responsive to the user even if the
     // speed is set very slow
     animation_step(NULL);
 
     // Use a priority lower than G_PRIORITY_HIGH_IDLE + 10, which is
     // what GTK uses for resizing.  This means that even while animating
     // furiously, we'll still be responsive to window resizes.
     animatetimeoutid = g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE,
       std::max(1, (int)animationinterval), animation_step, NULL, NULL);
   }
   else{
     if(animatetimeoutid) g_source_remove(animatetimeoutid);
     animatetimeoutid = 0;
     draw_whole_user_event();
   }
 
   return FALSE;
 }

static bool have_event_by_number ( const unsigned int n )

static

Definition at line 424 of file main.cxx.

References MECModelEnuComparisons::i, nevent, and theevents.

Referenced by getuserevent().

 {
   for(unsigned int i = 0; i < theevents.size(); i++)
     if(theevents[i].nevent == n)
       return true;
   return false;
 }

static GtkWidget* make_aux_win	(	const char *const	name,
		const statcontents	si
	)

static

Definition at line 788 of file main.cxx.

References FALSE, statbox, and w.

Referenced by setup().

 {
   GtkWidget * w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   char winname[1024];
   snprintf(winname, 1024, "NOE: %s", name);
   gtk_window_set_title(GTK_WINDOW(w), winname);
   gtk_window_set_default_size(GTK_WINDOW(w), 400, 68 /* four lines for me */);
   g_signal_connect(w, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL);
 
   GtkWidget * tab = gtk_table_new(1, 1, FALSE); // necessary?
   gtk_container_add(GTK_CONTAINER(w), tab);
 
   gtk_table_attach(GTK_TABLE(tab), statbox[si], 0, 1, 0, 1,
     GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_SHRINK, 0, 0);
 
   return w;
 }

static GtkWidget* make_speedlabel ( )

static

Definition at line 766 of file main.cxx.

References set_bg_color_to_main().

Referenced by setup().

 {
   GtkWidget * speedlabel = gtk_text_view_new();
   GtkTextBuffer * speedlabeltext = gtk_text_buffer_new(0);
   gtk_text_view_set_justification(GTK_TEXT_VIEW(speedlabel), GTK_JUSTIFY_CENTER);
   const char * const speedlabelbuf = "Speed";
   gtk_text_buffer_set_text(speedlabeltext, speedlabelbuf, strlen(speedlabelbuf));
   gtk_text_view_set_buffer(GTK_TEXT_VIEW(speedlabel), speedlabeltext);
   gtk_text_view_set_editable(GTK_TEXT_VIEW(speedlabel), false);
   set_bg_color_to_main(speedlabel);
   return speedlabel;
 }

static GtkWidget* make_speedslider ( )

static

Definition at line 718 of file main.cxx.

References adjustspeed(), set_intervals(), and speedadj.

Referenced by setup().

 {
   const int initialspeednum = 6;
   speedadj = gtk_adjustment_new (initialspeednum, 1, 11, 1, 1, 0);
   set_intervals(initialspeednum);
   g_signal_connect(speedadj, "value_changed", G_CALLBACK(adjustspeed), NULL);
 
   GtkWidget * const speedslider
     = gtk_spin_button_new(GTK_ADJUSTMENT(speedadj), 10, 0);
   gtk_entry_set_max_length (GTK_ENTRY(speedslider), 2);
   gtk_entry_set_width_chars(GTK_ENTRY(speedslider), 2);
   return speedslider;
 }

static GtkWidget* make_ticklabel ( const bool ismax )

static

Definition at line 753 of file main.cxx.

References set_bg_color_to_main().

Referenced by setup().

 {
   GtkWidget * ticklabel = gtk_text_view_new();
   GtkTextBuffer * ticklabeltext = gtk_text_buffer_new(0);
   gtk_text_view_set_justification(GTK_TEXT_VIEW(ticklabel), GTK_JUSTIFY_CENTER);
   const char * const ticklabelbuf = ismax?"Max Tick":"Min Tick";
   gtk_text_buffer_set_text(ticklabeltext, ticklabelbuf, strlen(ticklabelbuf));
   gtk_text_view_set_buffer(GTK_TEXT_VIEW(ticklabel), ticklabeltext);
   gtk_text_view_set_editable(GTK_TEXT_VIEW(ticklabel), false);
   set_bg_color_to_main(ticklabel);
   return ticklabel;
 }

static GtkWidget* make_tickslider ( const bool ismax )

static

Definition at line 705 of file main.cxx.

References adjusttick().

Referenced by setup().

 {
   const int initialticknum = 0;
   GtkObject * const tickadj = gtk_adjustment_new
     (initialticknum, 0, 1000, 1, 100, 0);
   GtkWidget * tickslider = gtk_spin_button_new(GTK_ADJUSTMENT(tickadj), 10, 0);
   g_signal_connect(tickadj, "value_changed", G_CALLBACK(adjusttick),
                    new bool(ismax));
   gtk_entry_set_max_length (GTK_ENTRY(tickslider), 6);
   gtk_entry_set_width_chars(GTK_ENTRY(tickslider), 6);
   return tickslider;
 }

static GtkWidget* make_ueventbox ( )

static

Definition at line 779 of file main.cxx.

References getuserevent(), and ueventbox.

Referenced by setup().

 {
   GtkWidget * ueventbox = gtk_entry_new();
   gtk_entry_set_max_length(GTK_ENTRY(ueventbox), 20);//length of a int64
   gtk_entry_set_width_chars(GTK_ENTRY(ueventbox), 5);
   g_signal_connect(ueventbox, "activate", G_CALLBACK(getuserevent), NULL);
   return ueventbox;
 }

static void makestatbox ( const int i )

static

Definition at line 743 of file main.cxx.

References MECModelEnuComparisons::i, set_bg_color_to_main(), statbox, and stattext.

Referenced by setup().

 {
   statbox[i]  = gtk_text_view_new();
   stattext[i] = gtk_text_buffer_new(0);
   gtk_text_view_set_buffer(GTK_TEXT_VIEW(statbox[i]), stattext[i]);
   gtk_text_view_set_editable(GTK_TEXT_VIEW(statbox[i]), false);
   gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(statbox[i]), false);
   set_bg_color_to_main(statbox[i]);
 }

static gboolean mouseover	(	GtkWidget *	widg,
		GdkEventMotion *	gevent,
		__attribute__((unused)) gpointer	data
	)

static

Definition at line 222 of file main.cxx.

References __attribute__(), dopanning(), edarea, kX, kY, theevents, to_next_free_run(), TRUE, and update_active_objects().

Referenced by setup().

 {
   if(gevent == NULL) return TRUE; // shouldn't happen
   if(theevents.empty()) return TRUE; // No coordinates in this case
 
   const noe_view_t V = widg == edarea[kX]? kX: kY;
 
   if(gevent->state & GDK_BUTTON1_MASK){
     dopanning(V, gevent);
     return TRUE;
   }
 
   update_active_objects(V, (int)gevent->x, (int)gevent->y);
 
   return TRUE;
 }

static void opentrackwin ( )

static

Definition at line 696 of file main.cxx.

References trackwin.

Referenced by setup().

 {
   gtk_widget_show_all(trackwin);
 }

static void openvertexwin ( )

static

Definition at line 691 of file main.cxx.

References vertexwin.

Referenced by setup().

 {
   gtk_widget_show_all(vertexwin);
 }

static gboolean pollmouseover ( __attribute__((unused)) gpointer data )

static

Definition at line 207 of file main.cxx.

References edarea, MECModelEnuComparisons::i, kXorY, TRUE, update_active_objects(), submit_syst::x, and submit_syst::y.

Referenced by draw_whole_user_event(), and setup().

 {
   gint x, y;
   for(int i = 0; i < kXorY; i++){
     gtk_widget_get_pointer(edarea[i], &x, &y);
     if(x >= 0 && y >= 0 && x < edarea[i]->allocation.width
                         && y < edarea[i]->allocation.height)
       update_active_objects((noe_view_t)i, x, y);
   }
   return TRUE;
 }

static gboolean prefetch_an_event ( __attribute__((unused)) gpointer data )

static

Definition at line 376 of file main.cxx.

References FALSE, ghave_read_all, prefetching, and TRUE.

Referenced by setup().

 {
   if(ghave_read_all) return FALSE; // don't call this again
 
   if(gtk_events_pending()) return TRUE;
 
   // exit GTK event loop to get another event from art
   prefetching = true;
   gtk_main_quit();
   return TRUE;
 }

static void prepare_to_swich_events ( )

static

Definition at line 389 of file main.cxx.

References active_cell, active_plane, and active_track.

Referenced by getuserevent(), and to_next().

 {
   active_track = active_cell = active_plane = -1;
 }

void realmain ( const bool have_read_all )

Definition at line 962 of file main.cxx.

References draw_event_from_timer(), get_event(), ghave_read_all, prefetching, set_eventn_status_runevent(), and setup().

Referenced by noe::noe::endJob(), and noe::noe::produce().

 {
   if(have_read_all) ghave_read_all = true;
   static bool first = true;
   if(first){
     first = false;
     setup();
   }
   else if(prefetching){
     set_eventn_status_runevent();
     prefetching = false;
   }
   else{
     get_event(1);
     g_timeout_add(0, draw_event_from_timer, NULL);
   }
   gtk_main();
 }

static gboolean redraw_window	(	GtkWidget *	mainwin,
		GdkEventConfigure *	event,
		__attribute__((unused)) gpointer	d
	)

static

Definition at line 668 of file main.cxx.

Referenced by setup().

 {
   static int oldwidth = event->width, oldheight = event->height;
   static bool first = true;
   const bool need_redraw =
     first || event->width > oldwidth || event->height > oldheight;
   first = false;
   oldwidth = event->width, oldheight = event->height;
 
   if(need_redraw) gtk_widget_queue_draw(mainwin);
 
   return !need_redraw; // FALSE means *do* propagate this to children
 }

static void restart_animation	(	__attribute__((unused)) GtkWidget *	w,
		__attribute__((unused)) gpointer	d
	)

static

Definition at line 589 of file main.cxx.

References animate, animate_checkbox, handle_event(), and TRUE.

Referenced by adjusttick(), and setup().

 {
   // Assume that if the user wants the animation restarted, then the
   // user wants animation.
   animate = true;
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(animate_checkbox), TRUE);
   handle_event();
 }

static void set_bg_color_to_main ( GtkWidget * widg )

static

Definition at line 732 of file main.cxx.

References plot_validation_datamc_2018::color.

Referenced by make_speedlabel(), make_ticklabel(), and makestatbox().

 {
   static GdkColor * color = NULL;
   if(color == NULL){
     color = new GdkColor;
     gtk_widget_realize(mainwin); // because we may not have drawn the window yet
     gtk_style_lookup_color(gtk_widget_get_style(mainwin), "bg_color", color);
   }
   gtk_widget_modify_base(widg, GTK_STATE_NORMAL, color);
 }

static void set_intervals ( const int speednum )

static

Definition at line 544 of file main.cxx.

References animationinterval, freeruninterval, makeTrainCVSamples::int, cet::pow(), and TDCSTEP.

Referenced by adjustspeed(), make_speedslider(), and toggle_animate().

 {
   freeruninterval = (int)pow(10, 6.5 - speednum/2.0);
   if(speednum == 11) freeruninterval = 1;
 
   // No point in trying to go faster than ~50Hz since the monitor won't
   // keep up (to say nothing of the human eye). I've found it not very
   // useful to have things flicking past so fast you only barely see
   // them. Limit to ~3Hz. Control higher speeds exclusively with the
   // TDCSTEP. This has the added benefit of putting several ticks on the
   // screen at once, which makes it easier to see interesting things.
   switch(speednum < 1?1:speednum > 11?11:speednum){
     case  1: animationinterval = 3000; TDCSTEP =     1; break;
     case  2: animationinterval = 3000; TDCSTEP =     2; break;
     case  3: animationinterval = 3000; TDCSTEP =     4; break;
     case  4: animationinterval = 1000; TDCSTEP =     4; break;
     case  5: animationinterval = 1000; TDCSTEP =     8; break;
     case  6: animationinterval =  333; TDCSTEP =     8; break;
     case  7: animationinterval =  333; TDCSTEP =    32; break;
     case  8: animationinterval =  333; TDCSTEP =   128; break;
     case  9: animationinterval =  333; TDCSTEP =  1024; break;
     case 10: animationinterval =  333; TDCSTEP =  4096; break;
     case 11: animationinterval =  333; TDCSTEP = 16384; break;
   }
 }

static void setup ( )

static

Definition at line 808 of file main.cxx.

References animate, animate_checkbox, plot_validation_datamc::c, close_window(), cum_ani_checkbox, cumulative_animation, dozooming(), edarea, FALSE, free_running, freerun_checkbox, get_event(), getuserevent(), ghave_read_all, handle_event(), MECModelEnuComparisons::i, kXorY, make_aux_win(), make_speedlabel(), make_speedslider(), make_ticklabel(), make_tickslider(), make_ueventbox(), makestatbox(), maxtickslider, mintickslider, mousebuttonpress(), mouseover(), next(), NSTATBOXES, opentrackwin(), openvertexwin(), pollmouseover(), prefetch_an_event(), prev(), redraw_event(), redraw_window(), request_edarea_size(), restart_animation(), setboxes(), statbox, staterror, stathit, statrunevent, stattiming, stattrack, statvertex, to_next(), toggle_animate(), toggle_cum_ani(), toggle_freerun(), trackwin, ueventbox, ueventbut, and vertexwin.

Referenced by daqdataformats::NanoSliceVersionConvention::NanoSliceVersionConvention(), and realmain().

 {
   gtk_init(NULL, NULL);
   mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(mainwin), "NOE: New nOva Event viewer");
   g_signal_connect(mainwin, "delete-event", G_CALLBACK(close_window), 0);
 
   g_signal_connect(mainwin,"configure-event",G_CALLBACK(redraw_window),NULL);
   for(int i = 0; i < kXorY; i++){
     edarea[i] = gtk_drawing_area_new();
     g_signal_connect(edarea[i],"expose-event",G_CALLBACK(redraw_event),NULL);
     g_signal_connect(edarea[i], "motion-notify-event", G_CALLBACK(mouseover), NULL);
     g_signal_connect(edarea[i], "scroll-event", G_CALLBACK(dozooming), new bool(i));
     g_signal_connect(edarea[i], "button-press-event",
                      G_CALLBACK(mousebuttonpress), NULL);
     gtk_widget_set_events(edarea[i], gtk_widget_get_events(edarea[i])
                                      | GDK_POINTER_MOTION_HINT_MASK
                                      | GDK_POINTER_MOTION_MASK
                                      | GDK_BUTTON_PRESS_MASK
                                      | GDK_SCROLL_MASK);
   }
   setboxes();
   request_edarea_size();
 
   GtkWidget * next = gtk_button_new_with_mnemonic("_Next Event");
   g_signal_connect(next, "clicked", G_CALLBACK(to_next), new bool(true));
 
   GtkWidget * prev = gtk_button_new_with_mnemonic("_Previous Event");
   g_signal_connect(prev, "clicked", G_CALLBACK(to_next), new bool(false));
 
   animate_checkbox = gtk_check_button_new_with_mnemonic("_Animate");
   cum_ani_checkbox = gtk_check_button_new_with_mnemonic("_Cumulative animation");
   freerun_checkbox = gtk_check_button_new_with_mnemonic("_Free running");
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(animate_checkbox),
                                animate);
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cum_ani_checkbox),
                                cumulative_animation);
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(freerun_checkbox),
                                free_running);
 
   g_signal_connect(animate_checkbox, "toggled", G_CALLBACK(toggle_animate),NULL);
   g_signal_connect(cum_ani_checkbox, "toggled", G_CALLBACK(toggle_cum_ani),NULL);
   g_signal_connect(freerun_checkbox, "toggled", G_CALLBACK(toggle_freerun),NULL);
 
   GtkWidget * re_an_button = gtk_button_new_with_mnemonic("_Restart animation");
   g_signal_connect(re_an_button, "clicked", G_CALLBACK(restart_animation), NULL);
 
   maxtickslider                  = make_tickslider(true);
   mintickslider                  = make_tickslider(false);
   GtkWidget * const maxticklabel = make_ticklabel(true);
   GtkWidget * const minticklabel = make_ticklabel(false);
   GtkWidget * const speedslider  = make_speedslider();
   GtkWidget * const speedlabel   = make_speedlabel();
   ueventbox                      = make_ueventbox();
 
   ueventbut = gtk_button_new_with_mnemonic("_Go to event");
   g_signal_connect(ueventbut, "clicked",  G_CALLBACK(getuserevent), NULL);
 
   const int nrow = 8, ncol = 11;
   GtkWidget * tab = gtk_table_new(nrow, ncol, FALSE);
   gtk_container_add(GTK_CONTAINER(mainwin), tab);
 
   GtkWidget * top_row_widgets[ncol] = {
     prev, next, mintickslider, maxtickslider, animate_checkbox, cum_ani_checkbox,
     re_an_button, freerun_checkbox, speedslider, ueventbox, ueventbut};
 
   GtkWidget * second_row_widgets[ncol] = {
     NULL, NULL, minticklabel, maxticklabel, NULL,
     NULL, NULL, NULL, speedlabel, NULL, NULL};
 
   for(int c = 0; c < ncol; c++){
     gtk_table_attach(GTK_TABLE(tab), top_row_widgets[c], c, c+1, 0, 1,
       GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_SHRINK, 0, 0);
 
     if(second_row_widgets[c] != NULL)
       gtk_table_attach(GTK_TABLE(tab),second_row_widgets[c],c,c+1,1,2,
         GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_SHRINK, 0, 0);
   }
 
   for(int i = 0; i < NSTATBOXES; i++) makestatbox(i);
 
   gtk_table_attach(GTK_TABLE(tab), statbox[statrunevent], 0, ncol-1, 2, 3,
     GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_SHRINK, 0, 0);
   gtk_table_attach(GTK_TABLE(tab), statbox[stattiming],   0, ncol-1, 3, 4,
     GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_SHRINK, 0, 0);
   gtk_table_attach(GTK_TABLE(tab), statbox[stathit],      0, ncol-1, 4, 5,
     GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_SHRINK, 0, 0);
   gtk_table_attach(GTK_TABLE(tab), statbox[staterror],    0, ncol-1, 5, 6,
     GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_SHRINK, 0, 0);
 
   trackwin  = make_aux_win("Tracks"  , stattrack );
   vertexwin = make_aux_win("Vertices", statvertex);
 
   GtkWidget * const tracksbut = gtk_button_new_with_mnemonic("Show _track info");
   g_signal_connect(tracksbut, "clicked",  G_CALLBACK(opentrackwin), NULL);
 
   GtkWidget * const vertexbut = gtk_button_new_with_mnemonic("Show _vertex info");
   g_signal_connect(vertexbut, "clicked",  G_CALLBACK(openvertexwin), NULL);
 
   gtk_table_attach(GTK_TABLE(tab), tracksbut, ncol-1, ncol, 2, 4,
       GtkAttachOptions(GTK_EXPAND | GTK_FILL),
       GtkAttachOptions(GTK_EXPAND | GTK_FILL), 0, 0);
 
   gtk_table_attach(GTK_TABLE(tab), vertexbut, ncol-1, ncol, 4, 6,
       GtkAttachOptions(GTK_EXPAND | GTK_FILL),
       GtkAttachOptions(GTK_EXPAND | GTK_FILL), 0, 0);
 
   for(int i = 0; i < kXorY; i++)
     gtk_table_attach(GTK_TABLE(tab), edarea[i], 0, ncol,
                      6+2*i, 7+2*i,
                      GtkAttachOptions(GTK_EXPAND | GTK_FILL),
                      GtkAttachOptions(GTK_EXPAND | GTK_FILL), 0, 0);
 
   gtk_table_attach(GTK_TABLE(tab), gtk_hseparator_new(), 0, ncol,
                    7, 8,
                    GtkAttachOptions(GTK_EXPAND | GTK_FILL),
                    GtkAttachOptions(GTK_SHRINK), 0, 0);
 
   // This isn't the size I want, but along with requesting the size of the
   // edarea widgets, it has the desired effect, at least more or less.
   gtk_window_set_default_size(GTK_WINDOW(mainwin), 400, 300);
 
   gtk_widget_show_all(mainwin);
 
   get_event(0);
   handle_event();
 
   // This is a hack that gets all objects drawn fully. It seems that the window
   // initially getting set to the size of the ND and then resized to the size
   // of the FD fails to have the expected effect and the objects outside the
   // original area don't get redrawn. Maybe this is is an xmonad-only problem?
   // This is a case of a window resizing itself, and maybe window managers are
   // supposed to send an expose event in this case, but xmonad doesn't. Or maybe
   // they aren't supposed to according to the spec, but all the other ones do...
   gtk_widget_queue_draw(mainwin);
 
   if(!ghave_read_all) g_timeout_add(20, prefetch_an_event, NULL);
 
   g_timeout_add(500, pollmouseover, NULL);
 }

static void start_freerun_timer ( )

static

Definition at line 484 of file main.cxx.

References freeruninterval, freeruntimeoutid, std::max(), and stop_freerun_timer().

Referenced by adjustspeed(), toggle_animate(), and toggle_freerun().

 {
   stop_freerun_timer(); // just in case
 
   // Do not call g_timeout_add with an interval of zero, since that
   // seems to be a special case that causes the function to be run
   // repeatedly *without* returning to the main loop, or without
   // doing all the things in the main loop that are usually done, or
   // something. In any case, empirically, it causes multiple (infinite?)
   // calls to to_next_free_run after gtk_main_quit() has been called,
   // which locks us up. It is quite possible that by setting the
   // interval to 1, it only makes it *unlikely* that further events are
   // processed between gtk_main_quit() and exiting the main loop, in
   // which case I have a bug that has only been suppressed instead of
   // fixed.
   //
   // See comments on the animation timer for why we use this priority.
   freeruntimeoutid = g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE,
     std::max((gulong)1, freeruninterval), to_next_free_run, NULL, NULL);
 }

static void stop_freerun_timer ( )

static

Definition at line 478 of file main.cxx.

References freeruntimeoutid.

Referenced by adjustspeed(), start_freerun_timer(), toggle_animate(), and toggle_freerun().

 {
   if(freeruntimeoutid) g_source_remove(freeruntimeoutid);
   freeruntimeoutid = 0;
 }

static void to_next	(	__attribute__((unused)) GtkWidget *	widget,
		gpointer	data
	)

static

Definition at line 395 of file main.cxx.

References get_event(), handle_event(), and prepare_to_swich_events().

Referenced by setup(), and to_next_free_run().

 {
   prepare_to_swich_events();
   const bool * const forward = (const bool * const)data;
   if(get_event((*forward)?1:-1))
     handle_event();
 }

static gboolean to_next_free_run ( __attribute__((unused)) gpointer data )

static

Definition at line 405 of file main.cxx.

References FALSE, free_running, freerun_checkbox, gevi, ghave_read_all, makeTrainCVSamples::int, theevents, and to_next().

Referenced by animation_step(), and mouseover().

 {
   bool forward = true;
   to_next(NULL, &forward);
 
   const bool atend = gevi == (int)theevents.size()-1 && ghave_read_all;
 
   if(atend){
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(freerun_checkbox),
                                  FALSE);
     free_running = false;
   }
   return free_running && !atend;
 }

static void toggle_animate	(	GtkWidget *	w,
		__attribute__((unused)) gpointer	dt
	)

static

Definition at line 571 of file main.cxx.

References animate, free_running, handle_event(), set_intervals(), speedadj, start_freerun_timer(), stop_freerun_timer(), and TDCSTEP.

Referenced by setup().

 {
   animate = GTK_TOGGLE_BUTTON(w)->active;
   if(animate){
     // If free running *and* animating, the animation timer will handle
     // switching to the next event.
     stop_freerun_timer();
     set_intervals(gtk_adjustment_get_value(GTK_ADJUSTMENT(speedadj)));
   }
   else{
     // If we stop animating, the free run timer has to take over free running
     if(free_running) start_freerun_timer();
     TDCSTEP = 1;
   }
 
   handle_event();
 }

static void toggle_cum_ani	(	GtkWidget *	w,
		__attribute__((unused)) gpointer	dt
	)

static

Definition at line 520 of file main.cxx.

References DRAWPARS::clear, cumulative_animation, draw_event(), DRAWPARS::firsttick, gevi, DRAWPARS::lasttick, and theevents.

Referenced by setup().

 {
   cumulative_animation = GTK_TOGGLE_BUTTON(w)->active;
 
   // If switching to cumulative, need to draw all the previous hits.  If
   // switching away, need to blank them all out.  In either case, don't wait
   // until the next animation step, because that appears laggy for the user.
   // TODO: make that actually work.
   DRAWPARS drawpars;
   if(cumulative_animation){
     drawpars.firsttick = theevents[gevi].user_mintick;
     drawpars.lasttick  = theevents[gevi].current_maxtick;
   }
   else{
     theevents[gevi].current_mintick = theevents[gevi].current_maxtick;
     drawpars.firsttick = theevents[gevi].current_mintick;
     drawpars.lasttick  = theevents[gevi].current_maxtick;
   }
   drawpars.clear = !cumulative_animation;
   draw_event(&drawpars);
 }

static void toggle_freerun	(	__attribute__((unused)) GtkWidget *	w,
		__attribute__((unused)) gpointer	dt
	)

static

Definition at line 506 of file main.cxx.

References animate, free_running, handle_event(), start_freerun_timer(), and stop_freerun_timer().

Referenced by setup().

 {
   free_running = GTK_TOGGLE_BUTTON(w)->active;
 
   // If free running *and* animating, the animation timer will handle
   // switching to the next event.
   if(free_running && !animate) start_freerun_timer();
   else                         stop_freerun_timer();
 
   handle_event();
 }

void update_active_objects	(	const noe_view_t	V,
		const int	x,
		const int	y
	)

Definition at line 185 of file main.cxx.

References active_cell, active_plane, active_track, active_vertex, change_highlighted_cell(), change_highlighted_reco(), set_eventn_status_hit(), set_eventn_status_track(), set_eventn_status_vertex(), TDCSTEP, and update_active_indices().

Referenced by mouseover(), and pollmouseover().

 {
   const int oldactive_plane = active_plane;
   const int oldactive_cell  = active_cell;
   const int oldactive_track = active_track;
   const int oldactive_vertex= active_vertex;
 
   update_active_indices(V, x, y, TDCSTEP);
 
   // Change track first because it starts by redrawing all hits from a saved
   // cairo_pattern_t.
   if(oldactive_track != active_track || oldactive_vertex != active_vertex)
     change_highlighted_reco();
   change_highlighted_cell(oldactive_plane, oldactive_cell);
   set_eventn_status_hit();
   set_eventn_status_track();
   set_eventn_status_vertex();
 }