DAQ++ git-vmedaq

#include <iostream>
#include <DAQ++/DAQmanager.h>
#include <DAQ++/RunManager.h>
#include <config/Config.h>
#include "RunMenu.h"

RunMenu::RunMenuList RunMenu::vlist;

RunMenu::RunMenu( const DAQpp::DAQid &id,GtkWidget *b, DAQpp::RunState::StatusType state ) 
   : btn(GTK_BUTTON(b)) ,_id(id)
{
   runmenu = RUNMENU(gtk_runmenu_new());
   g_signal_connect(G_OBJECT(runmenu),"command",
		      G_CALLBACK (daq_command),
		      this
      );

   g_signal_connect (G_OBJECT (btn), "clicked",
		       G_CALLBACK (btn_clicked),
		       runmenu
      );
   g_object_set_data (G_OBJECT (btn), "runmenu", runmenu);
   
   update( state );
}

static gboolean do_send_command( Runmenu *rm ) {
   gpointer ptr = g_object_steal_data(G_OBJECT(rm), "__command__");
   if ( !ptr )
      return FALSE;

   int cmmd = (int)ptr;
   switch (cmmd) {
      case getready:
	 gtk_runmenu_emit(rm, (RunStates)cmmd);
	 break;
      case run:
	 gtk_runmenu_emit(rm, (RunStates)cmmd);
	 break;
      case stop:
	 gtk_runmenu_emit(rm, (RunStates)cmmd);
	 break;
      case pauserun:
	 break;
      case resume:
	 break;
   }

   return FALSE;
}
void RunMenu::send_command( unsigned int cmd )
{
   g_object_set_data(G_OBJECT(runmenu),"__command__", (gpointer)cmd);
   g_idle_add( (GSourceFunc)do_send_command, (gpointer)runmenu );
}

DAQpp::RunState::StatusType RunMenu::translate( unsigned long x) {
   DAQpp::RunState::StatusType st = DAQpp::RunState::NotReady;
//    switch (x) {
//       case DAQ::RUNmanager::NotDefined:
//       case DAQ::RUNmanager::NotReady:     
// 	 st = DAQpp::RunState::NotReady;
//          break;
//       case DAQ::RUNmanager::GettingReady:
//       case DAQ::RUNmanager::Ready:
// 	 st = DAQpp::RunState::Ready;
//          break;
//       case DAQ::RUNmanager::Paused:
// 	 st = DAQpp::RunState::Paused;
//          break;
//       case DAQ::RUNmanager::Starting:
// 	 st = DAQpp::RunState::Starting;
//          break;
//       case DAQ::RUNmanager::Running:
// 	 st = DAQpp::RunState::Running;
//          break;
//       case DAQ::RUNmanager::TimeOut:
// 	 st = DAQpp::RunState::TimeOut;
//          break;
//    }
   return st;
}

typedef std::pair<RunMenu *, DAQpp::RunState::StatusType> update_data;
static gboolean do_update_state(update_data *data) {
   data->first->update_state( data->second );
   delete data;
   return FALSE;
}
void RunMenu::update(DAQpp::RunState::StatusType st) {
   update_data *data = new update_data(this,st);
   g_idle_add((GSourceFunc)do_update_state,(gpointer)data);
}


void RunMenu::update_state(DAQpp::RunState::StatusType st) 
{
   switch (st) {
      case DAQpp::RunState::NotDefined:
      case DAQpp::RunState::NotReady:	  
	 gtk_runmenu_set_notready(runmenu);
	 gtk_button_set_label(btn, "Not Ready");
	 break;
      case DAQpp::RunState::GettingReady:
      case DAQpp::RunState::Ready:
	 gtk_button_set_label(btn, "Ready");
	 gtk_runmenu_set_ready(runmenu);
	 break;
      case DAQpp::RunState::Paused:
	 gtk_button_set_label(btn, "Paused");
	 gtk_runmenu_set_paused(runmenu);
	 break;
      case DAQpp::RunState::Running:
	 gtk_button_set_label(btn, "Running");
	 gtk_runmenu_set_running(runmenu);
	 break;
      case DAQpp::RunState::Stopping:
	 gtk_button_set_label(btn, "Stopping");
	 gtk_runmenu_set_running(runmenu);
	 break;
      case DAQpp::RunState::TimeOut:
	 gtk_button_set_label(btn, "Time Out");
	 break;
      default:
	 break;
   }
}

void RunMenu::btn_clicked(GtkWidget *w, gpointer p) {
    gtk_menu_popup(GTK_MENU(p),0,0,0,0,0,0);
}

void RunMenu::daq_command(GtkWidget *w, unsigned int cmd, RunMenu *rm) 
{
   if ( rm==0 ) 
      return;

   // Get a pointer to the configuration manager
   ConfigParser *cfg = ConfigParser::theConfig();

   DAQpp::DAQmanager *daqm = DAQpp::DAQmanager::theDAQmanager();
   DAQpp::RunManager *runm = daqm->find_runmanager(rm->get_id() );
   if ( !runm ) {
      std::cout << "RunMenu::daq_command - RunManager " << rm->get_id().str() << " not found" << std::endl;
      return;
   }

   bool do_int=false;
   try {
      do_int = runm->get_par_value<bool>("doInterrupts");
   }
   catch( DAQpp::Exception &ex ) {
      do_int=false;
   }
   
   switch ( cmd ) {
      case getready:
	 runm->GetReady();
	 cmd = DAQpp::RunState::Ready;
	 break;
      case run:
	 if (do_int)
	    cfg->start_interrupts();
	 
	 daqm->startRunManager( runm );
	 if ( !runm->isActive() )
	    runm->Activate();
	 
	 cmd = DAQpp::RunState::Running;
	 break;
      case stop:
	 if (do_int)
	    cfg->stop_interrupts();
	 
	 daqm->stopRunManager( runm );
	 runm->PrepareToStop(true);
	 {
	    DAQpp::GTimer tim;
	    double tmout = 1.;
	    tim.start();
	    while (runm->isActive() && tmout<20.) {
	       if ( tim()>tmout ) {
		  std::cout << '.' << std::flush;
		  tmout += 1.;
		  if (tmout>20.) {
		     std::cout << "RunManager does not seem to stop..."
			       << std::endl;
		  }
	       }
	    }
	 }
	 
	 cmd = DAQpp::RunState::Ready;
	 break;
      case pauserun:
	 if (do_int)
	    cfg->stop_interrupts();

	 runm->Pause();
	 cmd = DAQpp::RunState::Paused;
	 break;
      case resume:
	 if (do_int)
	    cfg->start_interrupts();

	 runm->Continue();
	 cmd = DAQpp::RunState::Running;
	 break;
      case send_reset:
	 if ( do_int )
	    cfg->reset_interrupts();
	 
	 if ( runm->isActive() )
	    runm->deActivate();

	 cmd = DAQpp::RunState::NotReady;
	 break;
      default:	 
	 break;
   }
//   rm->update((DAQpp::RunState::StatusType)cmd);
}

void RunMenu::delete_all() {
   RunMenuList::iterator ip;
   for (ip=vlist.begin();ip!=vlist.end();++ip)
      delete ip->second;
   
   vlist.clear();
}

RunMenu *RunMenu::find( const std::string &pid) {
   RunMenuList::iterator ip = vlist.find(pid);
   if ( ip == vlist.end() )
      return 0;
   else
      return ip->second;
}

RunMenu *RunMenu::new_menu( const DAQpp::DAQid &id, 
				     GtkWidget *bt,
				     DAQpp::RunState::StatusType s)
{
   RunMenu* ps = new RunMenu( id, bt, s);

   vlist[ id() ] = ps;
   return ps;
}

void RunMenu::delete_menu( const DAQpp::DAQid &id ) {
   RunMenuList::iterator ip = vlist.find( id );
   if ( ip == vlist.end() )
      return;
   else {
      delete ip->second;
      vlist.erase ( ip );
   }
}

RunMenu::~RunMenu() {

}