/home/jpf/code/cc/project/cmil/src/InputNode.cpp

Go to the documentation of this file.

// =====================================================================================
//       Filename:  InputNode.cpp 
//    Description:  
//        Created:  02/15/2007 08:47:46 PM EST
//       Revision:  none
//       Compiler:  gcc 3.4.6
// 
//         Author:  John P. Feltz 
//          Email:  jfeltz@gmail.com
//        License:  Copyright (c) 2006-2007, John P. Feltz 
//                  This program is free software; you can redistribute it and/or
//                  modify it under the terms of the GNU General Public License as
//                  published by the Free Software Foundation, version 2 of the
//                  License.
//                  This program is distributed in the hope that it will be
//                  useful, but WITHOUT ANY WARRANTY; without even the implied
//                  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//                  PURPOSE.  //                  See the GNU General Public License version 2 for more details.
// 
// =====================================================================================

#include <System.h>

#include <InputSequencer.h>
#include <InputNode.h>
#include <InputContext.h>


namespace cmil {
  using std::string;

  InputNode::InputNode(InputAction* action, System* const sys, const NodeIndex& index, InputNode* parent, const int id) : 
    SystemClient(sys),
    m_action(action), 
    m_index(new NodeIndex(index)), 
    m_parent(parent),
    m_id(id), 
    m_time_margin(0), 
    m_time(0), 
    m_activechild(NULL) 
  {
      std::ostringstream debug_ss;
      debug_ss << "index initialized with size of: " << m_index->size() ; 
      log_debug(debug_ss.str());
  }

  InputNode::InputNode(InputAction* action, System* const sys, InputNode* parent, const int id) : 
    SystemClient(sys),
    m_action(action), 
    m_index(NULL), 
    m_parent(parent), 
    m_id(id), 
    m_activechild(NULL)
  {}

  void InputNode::cleanup() {
    std::ostringstream debug_ss;

    if(m_index) {
      debug_ss << "cleanup() m_index found of size:" << m_index->size();
      log_debug(debug_ss.str());

      for(InputNode::NodeIndex::iterator i = m_index->begin(); i != m_index->end(); ++i) {
        if(*i) {
          log_debug("cleanup() found non-null node in m_index, deleting ");
          delete (*i);
        }
      }

      delete m_index;
    }
  }

  InputNode* InputNode::createRoot(System* sys, unsigned long int index_size) { 
    //InputNode* test_node = new InputNode(NULL, NULL, NodeIndex(55), NULL, 0);

    return new InputNode(NULL, sys, NodeIndex(index_size), NULL, 0);
  }

  InputNode* const InputNode::createChild(bool indexing, int id) {
    if(!m_index) {
      log_error("createChild(bool,int) returning NULL due to lack of an m_index to work with.");
      return NULL;
    }

    if(indexing) {
      (*m_index)[id] = new InputNode(NULL, getSystem(), NodeIndex(SystemClient::getSize()), this, id);
    }
    else
      (*m_index)[id] = new InputNode(NULL, getSystem(), this, id);

    return (*m_index)[id];
  }


  InputNode* const InputNode::createChild(bool forced_index, const Ev& event) {
    int id;
    std::ostringstream debug_ss;
    const bool with_index = true;
    const bool without_index = false;

    if(!m_index) {
      log_error("createChild(bool,event) returning NULL due to lack of an m_index to work with.");
      return NULL;
    }

    debug_ss << "createChild(Event), this m_id: " << m_id;
    log_debug(debug_ss.str());

    log_debug("createChild(Event) locating ID for given event");

    if( (id = SystemClient::getID(event) )) {
      if(getChild(id)) {
        log_debug("creatChild(Event) returning pre-exisiting node");
        return getChild(id);  
      }

      if(!forced_index) {
        log_debug( std::string("createChild(Event) determining kind of child to create for event:").append( event.getName() ));
        if(!(dynamic_cast<ModData*>(getData(id)))) 
          return createChild(without_index, id);  
        else  
          return createChild(with_index, id); 
      }
      else
        return createChild(with_index, id); 
    }

    log_error("createChild(Event) returning NULL");
    return NULL;
  }

  bool InputNode::deleteChild(int id) {
    InputNode* child;
    if( (child = getChild(id)) ) {  
      delete child;
     ((*m_index)[id]) = NULL;

      return true;
    }

    return false;
  }

  bool NormalHandler::handle(const InputData& input) {
    InputNode* child;
    std::ostringstream debug_ss;
  
    if(!canHandle(input)) 
      return false;
  
    for(m_i = m_controlnodes.begin() ; m_i != m_controlnodes.end() ; m_i++) {
      //log_debug( "handle() iterating through control nodes.."); 
      //check for the child by input index value 
  
      if((child = (*(*m_i)->getIndex())[input.getID()])  != NULL) {
        if(child->getAction())
          input.run(child->getAction());
  
        debug_ss <<" handle( " << input.getName() << ") handled. ";
        log_debug(debug_ss.str());
        debug_ss.str("");

        return true;
      }
    }
  
    if(m_root)
      if((child = (*m_root->getIndex())[input.getID()]) != NULL) {
        input.run(child->getAction());
        log_debug(string("handle(InputData) : ").append(input.getName()).append(" handled."));
        return true;
      }
  
    log_debug(string("handle(InputData) : ").append(input.getName()).append(" not handled."));
    return false;
  }


  //TODO This needs major cleanup.  
  bool NormalHandler::handle(const ModData& input) {
    if(!canHandle(input)) 
      return false;

    log_debug(string("Handle(ModData) : ").append(input.getName()));

    if(m_active[input.getID()]) {
      log_debug(string("Handle(ModData) : found in active active index: ").append(input.getName()));

      if(!input.getState())  {
        (((m_active[input.getID()])->getParent())->setActiveChild(NULL));

        RemoveControl(m_active[input.getID()]);
      }

      if((m_active[input.getID()])->getAction()) 
        input.run((m_active[input.getID()])->getAction());
    
      m_active[input.getID()] = NULL;

      log_debug(string("Handle(ModData) : ").append(input.getName()).append(" handled, inactivity set."));
      return true;
    }
    else {
      if(input.getState()) {

        if((m_active[input.getID()] = HandleActivity(input)) != NULL) {
          log_debug(string("Handle(ModData) : ").append(input.getName()).append(" handled, activity set"));
          return true;
        }
        else
          log_debug(string("Handle(ModData) : ").append(input.getName()).append(" not handled, no activity set"));

        log_debug(string("Handle(ModData) : ").append(input.getName()).append(" not handled due to no sequence found, "));
        return false;
      }
      return false;
    }
  }


  bool ComboHandler::isCombo(const Ev::Sequence& seq) const {
    InputData*   tmp_input;
    InputAction* tmp_action;

    if( !(  seq.back().getAction() )  ) { 
      log_error("isCombo() : event is not part of a valid sequence due to missing action"); 
      return false;
    }

    for(Ev::Sequence::const_iterator i = seq.begin() ; i!= seq.end(); i++) {
      log_debug(string("isCombo() : iteratoring to event named: ").append((*i).getName())); 
      
      if( ( tmp_input = getData((*i))) == NULL ) {
        log_error(string("isCombo() : sequence found invalid due no InputData found for event: ").append((*i).getName()));
        return false;
      }
      
      if((tmp_action = (*i).getAction()) != NULL) {
        if( i != --(seq.end()) ) {
          log_error(string("isCombo() : action found in wrong position of sequence. Ev: ").append((*i).getName())); 
          return false;
        }
        else if(!tmp_input->isActionCompatible(tmp_action)) {
          log_error("isCombo() : action found incompatible with event. "); 
          return false;
        }

        log_debug("isCombo() : returning true "); 
        return true;
      }
    }

    log_error("isCombo() : returning false ");
    return false;
  }

  bool NormalHandler::isNormal(const Ev::Sequence& seq) const {
    InputData*   tmp_input;
    InputAction* tmp_action;

    if( !( seq.back().getAction() )  ) { 
      log_error("isNormal() : event is not part of a valid sequence due to missing action"); 
      return false;
    }

    for(Ev::Sequence::const_iterator i = seq.begin() ; i!= seq.end(); i++) {
      log_debug(string("isNormal() : iteratoring to event named: ").append((*i).getName())); 
        if(Ev::getEventCount(seq, *(i)) > 1) {
          log_debug("isNormal() : returning false"); 
          return false;
        }
      
       if( ( tmp_input = getData(*i)) == NULL ) {
         log_error(string("isNormal() : sequence found invalid due no InputData found for event: ").append((*i).getName()));
         return false;
       }
       else if( i != --(seq.end()) ) {
          if(dynamic_cast<ModData*>(tmp_input) == NULL) {
          log_error("isNormal() : sequence found invalid due to a non-ModData type having dependant events.");
          return false;
        }
       }
      
      if((tmp_action = (*i).getAction()) != NULL) {
        if( i != --(seq.end()) ) {
          log_error(string("isNormal() : action found in wrong position of sequence. Ev: ").append((*i).getName())); 
          return false;
        }
        else if(!tmp_input->isActionCompatible(tmp_action)) {
          log_error("isNormal() : action found incompatible with event. "); 
          return false;
        }

        log_debug("isNormal() : returning true "); 
        return true;
      }
    }

    return false;
  }
  
  bool NormalHandler::add(const Ev::Sequence& seq) {
    std::cout << std::endl;

    if( m_added_seq.find(seq) != m_added_seq.end()) {
      log_error(" add() found matching pre-existing sequence, not adding."); 
      return false;
    }

    log_debug("add(seq) : defering sequence to merge function."); 
    return Merge(seq);
  }

  bool NormalHandler::remove(const Ev::Sequence& seq) {
    std::cout << std::endl;

    if( m_added_seq.find(seq) == m_added_seq.end()) {
      log_error(" remove(seq) no existing sequence found, not removing."); 
      return false;
    }

    log_debug("remove(seq) : defering sequence to unmerge function.");  
    return unMerge(seq);
  }

  bool ComboHandler::add(const Ev::Sequence& seq) {
      std::cout << std::endl;
      log_debug("add(seq) : defering sequence to merge function."); 
      return Merge(seq);
  }

  bool ComboHandler::canHandle(const InputData& input) const {
    if(!m_root) {
      //log_debug(std::string("canHandle() ").append(input.getName()).append(" not handled due to no sequences stored."));
      return false;
    }
    return true;
  }

  bool ComboHandler::check_time(const InputNode* child) const { 
    unsigned long child_time   = child->getTime();
    unsigned long child_margin = child->getTimeMargin();
    unsigned long parent_time  = 0;

    if(!child->getParent()) {
      log_error("check_time() failing due to being called on a root node.");
      return false;
    }

    if(!(child->getParent())->getParent()) {
      log_debug("check_time returning true due to calling from m_root node");
      return true;
    }

    parent_time = child->getParent()->getTime();

    if((child_time - parent_time) <= child_margin) { 
      log_debug("check_time() returning true because of time verification.");
      return true;
    }

    log_debug("check_time() returning false due to time check failure.");
    return false;
  }

  bool ComboHandler::handle(const InputData& input) {
    InputNode* child;

    if(!canHandle(input) || !input.getState()) 
      return false;
    
  
    if ( (child = m_controlling->getChild(input.getID())) != NULL) {
      child->setTime(input.getTime());
      if(check_time(child))
      {
        if(child->getAction()) {
           input.run(child->getAction());
           m_controlling = m_root;
        }
        else  {
          log_debug(string("handle(InputData) moving to next child in sequence: ").append(input.getName()));  
          child->setTime(input.getTime());  
          m_controlling = child; 
        }

        log_debug(string("handle(InputData) : ").append(input.getName()).append(" handled."));
        return true; 
      }
    }

    m_controlling = m_root;
    log_debug(string("handle(InputData) : ").append(input.getName()).append(" not handled."));
    return false; 
  }

  bool ComboHandler::Merge(const Ev::Sequence& seq) {
    std::ostringstream debug_ss;
    InputAction* tmp_action;
    InputNode* current;

    if(!m_root) {
      log_debug("Merge() creating root node");
      m_root = InputNode::createRoot(getSystem(), getSize());
      m_controlling = m_root;
    }

    current = m_root;

    for(Ev::Sequence::const_iterator i = seq.begin() ; i!=seq.end(); i++) {
      //log_debug(string("  Merge() iterating through event sequence, name: ").append((*i).getName()));

      if((current = current->createChild(true, *i)) == NULL) {
        log_error("  Merge() Unable to merge sequence due to InputNode creation error.");
        return false;
      }

      current->setTimeMargin( (*i).getTimeMargin() );

      if((tmp_action = (*i).getAction()) != NULL) {
        log_debug(string("  Merge() found action at event, assigning: ").append((*i).getName())); 

        current->setAction(tmp_action);

        return true;
      }
      else 
        log_debug(string("  Merge() did not find an action at event: ").append((*i).getName()));
    }
    
    log_error("Merge() Unable to merge sequence due to no action being found.");
    return false;
  }

  bool NormalHandler::canHandle(const InputData& input) const {
    if(!m_root) {
      log_debug(std::string("canHandle() ").append(input.getName()).append(" not handled due to no sequences stored."));
      return false;
    }
    if(m_active.size()) {
      if(m_active.size() <= input.getID()) {
        log_error(std::string("canHandle() ").append(input.getName()).append(" not handled due to input not being availabile in present index."));
        return false;
      }
    }
    else {
      log_debug(std::string("canHandle() ").append(input.getName()).append(" not handled due to no seqeuences stored."));
      return false;
    }

    //log_debug(std::string("canHandle() ").append(input.getName()).append(" returning true"));
    return true;
  }

  bool NormalHandler::Merge(const Ev::Sequence& seq) {
    std::ostringstream debug_ss;
    InputAction* tmp_action;
    InputNode* current;

    if(!m_root) {
      log_debug("Merge() creating root node");
      m_root = InputNode::createRoot(getSystem(), getSize());
    }

    if(!m_active.size()) { 
      log_debug("Merge() setting m_active" );
      m_active = InputNode::NodeIndex(SystemClient::getSize());
    }

    current = m_root;

    for(Ev::Sequence::const_iterator i = seq.begin() ; i!=seq.end(); i++) {
      //log_debug(string("  Merge() iterating through event sequence, name: ").append((*i).getName()));

      if((current = current->createChild(false, (*i))) == NULL)
        return false;

      if((tmp_action = (*i).getAction()) != NULL) {
        log_debug(string("  Merge() found action at event: ").append((*i).getName())); 

        current->setAction(tmp_action);

        m_added_seq[seq] = new NodeSequence(current);
        return true;
      }
      else 
        log_debug(string("  Merge() did not find an action at event: ").append((*i).getName()));
    }
    
    log_error("Merge() Unable to merge sequence due to no action being found.");
    return false;
  }

  bool NormalHandler::unMerge(const Ev::Sequence& seq) {
    InputNode* parent;
    InputNode* current;

    if(!m_root) {
      log_debug("unMerge() found no root node, returning false");
      return false; 
    }

    if(m_added_seq[seq]) {
      current = m_added_seq[seq]->getLastNode();
      m_added_seq.erase(seq);
    }
    else {
      log_error("unMerge() didn't find the sequence on what should be second check.");
      return false;
    }
  
    for(Ev::Sequence::const_iterator i = seq.end() ; i!=seq.begin(); --i) {
      if( (current->getChildren()) || (!current->getParent()) ) 
        continue;

      parent = current->getParent();
      parent->deleteChild(current->getID());

      current = parent;
    }

    log_debug("unMerge() finishing removal"); 
    return true;
  }

  
  InputNode* NormalHandler::HandleActivity(const ModData& input) {
    InputNode* child;

//    log_debug(string("HandleActivity() : ").append(input.getName()));

    for(m_i = m_controlnodes.begin() ; m_i != m_controlnodes.end() ; m_i++) {
      if((child = (*(*m_i)->getIndex())[input.getID()]) != NULL) {
        if(child->getAction())
          input.run(child->getAction());

        (*m_i)->setActiveChild(child);
        (*m_i) = recurChildController(child);

        log_debug(string("HandleActivity(ModData) ").append(input.getName()).append( "successfully handled."));
        return child;
      }
    }

    log_debug(" HandleActivity() checking root since no control nodes found.");

    if(m_root)
      if((child = (*m_root->getIndex())[input.getID()]) != NULL) {
        if(child->getAction()) {
          log_debug("HandleActivity() running found action.");
          input.run(child->getAction());
        }

        if(child->getIndex() != NULL) 
          m_controlnodes.push_front(child);

        return child;
      }

    log_debug(string("HandleActivity(ModeData) ").append(input.getName()).append(" not handled."));
    return NULL;
  }


  InputNode* NormalHandler::recurChildController(InputNode* const node) {
    if((node->getIndex() != NULL) ) { 
      if(node->getActiveChild() != NULL) 
        return recurChildController(node->getActiveChild());
      else 
        return node;
    }

    return node->getParent(); 
  }

  InputNode* NormalHandler::recurParentController(InputNode* const node) {
    if(!node->getParent())
      return NULL;

    if(m_active[node->getID()]) 
      return node;

    return recurParentController(node->getParent());
  }

  void NormalHandler::RemoveControl(InputNode* node) {
    InputNode* controller = recurChildController(node);

    for(m_i = m_controlnodes.begin() ; m_i != m_controlnodes.end() ; m_i++) 
      if((*m_i)->getID() == controller->getID()) {
        
    
      InputNode* new_controller = recurParentController(node->getParent());

      if (new_controller== NULL)
        m_controlnodes.erase(m_i);
      else {
        (*m_i) = new_controller; 
      }
      break;
    }
  }

  Ev::Sequence* NodeSequencer::capture(const ModData& input) {
    if(input.getState()) {
      if(m_captured == NULL) 
        m_captured = new Ev::Sequence();

      m_captured->push_back(input.createEv());  
    }
    else {
    
    input.run(m_stop_capture_action); 

     if(m_captured) 
       return m_captured;
    }

    return NULL;
  }; 
}

---