tkobserver.cc

MICO2.3.13 corba 环境平台

    if {$status(has_left_fork)} {\n\
	.philo.$i.left configure -image $forkpic\n\
    } else {\n\
	.philo.$i.left configure -image $noforkpic\n\
    }\n\
    if {$status(has_right_fork)} {\n\
	.philo.$i.right configure -image $forkpic\n\
    } else {\n\
	.philo.$i.right configure -image $noforkpic\n\
    }\n\
\n\
    set hungryness [expr $status(ticks_since_last_meal) * 8]\n\
\n\
    switch $status(state) {\n\
	EATING -\n\
	THINKING {\n\
	    set color \"#008000\"\n\
	}\n\
	HUNGRY {\n\
	    set color \"#000000\"\n\
	}\n\
	STARVING {\n\
	    set color \"#FFFF00\"\n\
	}\n\
	default {\n\
	    set color \"#FF0000\"\n\
	}\n\
    }\n\
\n\
    .philo.$i.hungry coords hungryness 0 8 $hungryness 18\n\
    .philo.$i.hungry itemconfigure hungryness -fill $color\n\
}\n\
\n\
set philosophers(count) 0\n\
.status.left configure -text \"Passive\"\n\
\n\
";

/*
 * ----------------------------------------------------------------------\n\
 * StatusInfo event type
 * ----------------------------------------------------------------------
 */

class StatusInfo_impl :
  virtual public OBV_DiningPhilosophers::StatusInfo,
  virtual public CORBA::DefaultValueRefCountBase
{
public:
  StatusInfo_impl ();
};

StatusInfo_impl::StatusInfo_impl ()
{
}

class StatusInfoFactory : public CORBA::ValueFactoryBase
{
public:
  CORBA::ValueBase * create_for_unmarshal ();
};

CORBA::ValueBase *
StatusInfoFactory::create_for_unmarshal ()
{
  return new StatusInfo_impl;
}

/*
 * ----------------------------------------------------------------------
 * Observer component
 * ----------------------------------------------------------------------
 */

class TkObserver_impl : 
  virtual public MyObserver,
  virtual public CORBA::DispatcherCallback
{
private:
  Tcl_Interp * myinterp;
  CORBA::Dispatcher * _disp;
  bool _active;

public:
  TkObserver_impl (Tcl_Interp * interp)
    {
      _active = false;
      myinterp = interp;
      CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
      _disp = orb->dispatcher ();
      _disp->tm_event (this, 100);
    }

  void set_session_context (Components::SessionContext_ptr)
    {
    }

  void ccm_activate ()
    {
      if (!_active) {
	_active = true;
	Tcl_Eval (myinterp, ".status.left configure -text \"Waiting for Events ...\"");
      }
    }

  void ccm_passivate ()
    {
      if (!_active) {
	return;
      }

      _active = false;
      Tcl_Eval (myinterp, ".status.left configure -text \"Passive\"");
    }

  void ccm_remove ()
    {
      if (_disp) {
	_disp->remove (this, CORBA::Dispatcher::Timer);
      }
      Tcl_DeleteInterp (myinterp);
    }

  void callback (CORBA::Dispatcher * d, CORBA::Dispatcher::Event e)
    {
      assert (e == CORBA::Dispatcher::Timer);
      _disp->tm_event (this, 100);
      while (Tcl_DoOneEvent (TCL_DONT_WAIT));
    }

  void push_info (DiningPhilosophers::StatusInfo * si)
    {
      Tcl_Obj *com, *cmd[2], *elements[10];

      elements[0] = Tcl_NewStringObj ("name", -1);
      elements[1] = Tcl_NewStringObj ((char *) si->name(), -1);
      elements[2] = Tcl_NewStringObj ("state", -1);

      switch (si->state()) {
      case DiningPhilosophers::EATING:
	elements[3] = Tcl_NewStringObj ("EATING", -1);
	break;

      case DiningPhilosophers::THINKING:
	elements[3] = Tcl_NewStringObj ("THINKING", -1);
	break;

      case DiningPhilosophers::HUNGRY:
	elements[3] = Tcl_NewStringObj ("HUNGRY", -1);
	break;

      case DiningPhilosophers::STARVING:
	elements[3] = Tcl_NewStringObj ("STARVING", -1);
	break;

      case DiningPhilosophers::DEAD:
	elements[3] = Tcl_NewStringObj ("DEAD", -1);
	break;
      }

      elements[4] = Tcl_NewStringObj ("ticks_since_last_meal", -1);
      elements[5] = Tcl_NewIntObj ((int) si->ticks_since_last_meal());
      elements[6] = Tcl_NewStringObj ("has_left_fork", -1);
      elements[7] = Tcl_NewBooleanObj (si->has_left_fork());
      elements[8] = Tcl_NewStringObj ("has_right_fork", -1);
      elements[9] = Tcl_NewBooleanObj (si->has_right_fork());

      cmd[0] = Tcl_NewStringObj ("UpdateGUI", -1);
      cmd[1] = Tcl_NewListObj (10, elements);
      com = Tcl_NewListObj (2, cmd);
      Tcl_IncrRefCount (com);

      Tcl_EvalObjv (myinterp, 2, cmd, TCL_EVAL_GLOBAL);

      Tcl_DecrRefCount (com);
    }
};

class TkObserverHome_impl : virtual public DiningPhilosophers::CCM_ObserverHome {
public:
  TkObserverHome_impl ()
    {
      Tcl_FindExecutable (0);
    }

  Components::EnterpriseComponent_ptr create ()
    {
      Tcl_Interp * myinterp = Tcl_CreateInterp ();

      if (Tcl_Init (myinterp) != TCL_OK) {
	assert (0);
      }

      if (Tk_Init (myinterp) != TCL_OK) {
	assert (0);
      }

      Tcl_SetVar (myinterp, "maxphilosophers", "7", 0);
      
      if (Tcl_GlobalEval (myinterp, startscript) != TCL_OK) {
	assert (0);
      }
      
      return new TkObserver_impl (myinterp);
    }
};

/*
 * ----------------------------------------------------------------------
 * Entry points
 * ----------------------------------------------------------------------
 */


extern "C" {
  Components::HomeExecutorBase_ptr
  create_DiningPhilosophers_ObserverHome (CORBA::ORB_ptr orb)
  {
    CORBA::ValueFactoryBase_var f = new StatusInfoFactory;
    orb->register_value_factory ("IDL:DiningPhilosophers/StatusInfo:1.0", f);

    return new TkObserverHome_impl ();
  }
}