protected void RaiseEventManagerDispatchException(EventManagerDispatchExceptionHandler handler, IQEventManager eventManager, Exception ex, IQHsm hsm, IQEvent ev)
 {
     if (handler != null)
     {
         handler (eventManager, ex, hsm, ev);
     }
 }

 protected virtual void DoDispatchException(IQHsm hsm, Exception ex, MethodInfo stateMethod, IQEvent ev)
 {
     if (OnDispatchException (hsm, ex, stateMethod, ev))
     {
         RaiseDispatchException (DispatchException, hsm, ex, stateMethod, ev);
     }
 }

 protected void DoEventManagerDispatchException(IQEventManager eventManager, Exception ex, IQHsm hsm, IQEvent ev)
 {
     if (OnEventManagerDispatchException (eventManager, ex, hsm, ev))
     {
         RaiseEventManagerDispatchException (EMDispatchException, eventManager, ex, hsm, ev);
     }
 }

 protected void DoPolledEvent(IQEventManager eventManager, IQHsm hsm, IQEvent ev, PollContext pollContext)
 {
     if (OnPolledEvent (eventManager, hsm, ev, pollContext))
     {
         RaisePolledEvent (eventManager, PolledEvent, hsm, ev, pollContext);
     }
 }

 public DispatchExceptionFailureEventArgs(Exception ex, IQHsm hsm, System.Reflection.MethodInfo stateMethod, IQEvent ev)
 {
     _Exception = ex;
     _Hsm = hsm;
     _StateMethod = stateMethod;
     _OriginalEvent = ev;
 }

 protected void DoUnhandledTransition(IQHsm hsm, MethodInfo stateMethod, IQEvent qEvent)
 {
     if (OnUnhandledTransition (hsm, stateMethod, qEvent))
     {
         RaiseUnhandledTransition (UnhandledTransition, hsm, stateMethod, qEvent);
     }
 }

 public HsmEventHolder(QEventManagerBase eventManager, IQHsm hsm, IQEvent ev)
 {
     _EventManager = eventManager;
     _Hsm = hsm;
     _Event = ev;
     _Principal = System.Threading.Thread.CurrentPrincipal;
 }

 protected override QState s02(IQEvent qEvent)
 {
     switch (qEvent.QSignal)
     {
         case (int)QSignals.Init:    CWrite("s02-INIT;");  InitializeState(m_s021); return null;
     }
     return base.s02(qEvent);
 }

 protected override QState s1(IQEvent qEvent)
 {
     switch (qEvent.QSignal)
     {
         case (int)MyQSignals.B_Sig: Console.Write("s1-B-overriden;"); return null;
     }
     // Everything else we pass on to the state handler of the base class
     return base.s1(qEvent);
 }

 protected QState s021(IQEvent qEvent)
 {
     switch (qEvent.QSignal)
     {
         case (int)QSignals.Entry:   CWrite("s021-ENTRY;"); return null;
         case (int)QSignals.Exit:    CWrite("s021-EXIT;");  return null;
     }
     return m_s02;
 }

 protected virtual QState s02(IQEvent qEvent)
 {
     switch (qEvent.QSignal)
     {
         case (int)QSignals.Entry:   Console.Write("s02-ENTRY;"); return null;
         case (int)QSignals.Exit:    Console.Write("s02-EXIT;");  return null;
         case (int)MyQSignals.Sig2:  Console.Write("s02-Sig2;");  TransitionTo(m_s01, ref s_Tran_s02_s01);   return null;
     }
     return m_s0;
 }

 protected QState s01(IQEvent qEvent)
 {
     switch (qEvent.QSignal)
     {
         case (int)QSignals.Entry:   Console.Write("s01-ENTRY;"); return null;
         case (int)QSignals.Exit:    Console.Write("s01-EXIT;");  return null;
         case (int)MyQSignals.Sig1:  Console.Write("s01-Sig1;");  TransitionTo(m_s02, ref s_Tran_s01_s02);   return null;
     }
     return m_s0;
 }

 protected QState s0(IQEvent qEvent)
 {
     switch (qEvent.QSignal)
     {
         case (int)QSignals.Entry:   Console.Write("s0-ENTRY;"); return null;
         case (int)QSignals.Exit:    Console.Write("s0-EXIT;");  return null;
         case (int)QSignals.Init:    Console.Write("s0-INIT;");  InitializeState(m_s01); return null;
     }
     return this.TopState;
 }

 public void AsyncDispatchFront(IQHsm hsm, IQEvent ev)
 {
     lock (_QLock)
     {
     #warning Using a stack will alway push the most recent event to the front - thus reversing instead of maintaining "insert" order
         HsmEventHolder holder = new HsmEventHolder (this, hsm, ev);
         _FrontStack.Push (holder);
     }
     _WaitHandle.Set ();
 }

 public void Send(IQEvent ev)
 {
     if (OnQEvents (ev))
     {
         if (QEvents != null)
         {
             QEvents (this, ev);
         }
     }
 }

 protected QState s0(IQEvent qEvent)
 {
     switch (qEvent.QSignal)
     {
         case (int)QSignals.Entry:   Console.Write("s0-ENTRY;"); return null;
         case (int)QSignals.Exit:    Console.Write("s0-EXIT;");  return null;
         case (int)QSignals.Init:    Console.Write("s0-INIT;");  InitializeState(m_s1); return null;
         case (int)MyQSignals.E_Sig: Console.Write("s0-E;");     TransitionTo(m_s211, ref s_Tran_s0_s211); return null;
     }
     return this.TopState;
 }

		private QState CatchAll(IQEvent qEvent)
		{
			LogEvent(MethodBase.GetCurrentMethod().Name, qEvent);
			switch (qEvent.QSignal)
			{
				case (int)QSignals.Init:
					InitializeState(this.InitializeBoard);
					return null;
				case (int)ControllerSignal.Reset:
					TransitionTo(this.InitializeBoard);
					return null;
			}
			return this.TopState;
		}

 protected virtual QState s1(IQEvent qEvent)
 {
     switch (qEvent.QSignal)
     {
         case (int)QSignals.Entry:   Console.Write("s1-ENTRY;"); return null;
         case (int)QSignals.Exit:    Console.Write("s1-EXIT;");  return null;
         case (int)QSignals.Init:    Console.Write("s1-INIT;");  InitializeState(m_s11); return null;
         case (int)MyQSignals.A_Sig: Console.Write("s1-A;");     TransitionTo(m_s1,   ref s_Tran_s1_s1);   return null;
         case (int)MyQSignals.B_Sig: Console.Write("s1-B;");     TransitionTo(m_s11,  ref s_Tran_s1_s11);  return null;
         case (int)MyQSignals.C_Sig: Console.Write("s1-C;");     TransitionTo(m_s2,   ref s_Tran_s1_s2);   return null;
         case (int)MyQSignals.D_Sig: Console.Write("s1-D;");     TransitionTo(m_s0,   ref s_Tran_s1_s0);   return null;
         case (int)MyQSignals.F_Sig: Console.Write("s1-F;");     TransitionTo(m_s211, ref s_Tran_s1_s211); return null;
     }
     return m_s0;
 }

		private QState InitializeBoard(IQEvent qEvent)
		{
			LogEvent(MethodBase.GetCurrentMethod().Name, qEvent);
			switch (qEvent.QSignal)
			{
				case (int)ControllerSignal.ProcessFrame:
					m_MainModel.ImageProcessor.DetectedBlobsImage = null;
					DetectBoardRectangles();
					return null;
				case (int)ControllerSignal.BoardInitialized:
					TransitionTo(this.Initialized);
					return null;
			}
			return this.CatchAll;
		}

        private QState Eating(IQEvent qEvent)
        {
            switch (qEvent.QSignal)
            {
                case (int)QSignals.Entry:
                    LogMessage(String.Format("Philosopher {0} is eating.", m_PhilosopherId));
                    m_Timer.FireIn(c_EatTime, new PhilosopherEvent(DPPSignal.Timeout));
                    return null;

                case (int)DPPSignal.Timeout:
                    TransitionTo(m_StateThinking, ref s_Tran_Eating_Thinking);
                    return null;

                case (int)QSignals.Exit:
                    LogMessage(String.Format("Philosopher {0} is exiting eating state.", m_PhilosopherId));
                    TableEvent tableEvent = new TableEvent(DPPSignal.Done, m_PhilosopherId);
                    LogMessage(String.Format("Philosopher {0} publishes Done event.", m_PhilosopherId));
                    QF.Instance.Publish(tableEvent);
                    return null;
            }
            return this.TopState;
        }