/home/jpf/code/cc/project/cmil/include/InputNode.h

Go to the documentation of this file.

// =====================================================================================
//       Filename:  InputNode.h 
//    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.
// 
// =====================================================================================


namespace cmil {

  class InputNode : public SystemClient, Logger  {
    public:
      typedef std::vector<InputNode* > NodeIndex;

      //FIXME
      static InputNode* createRoot(System* sys, unsigned long int index_size) ; 

      InputNode* const createChild(bool indexing, int id);
      InputNode* const createChild(bool forced_index, const Ev& event);

      bool deleteChild(int id);

      NodeIndex getStandardIndex();

      virtual ~InputNode() { 
        std::ostringstream dtor_ss;
        dtor_ss << "calling InputNode dtor with m_id: " << m_id; 
        log_debug(dtor_ss.str());
        cleanup(); 
      }

      std::string getName() const {
        return "InputNode";
      }

      unsigned long getTime() const {
        return m_time;
      }
      
      unsigned long getTimeMargin() const {
        return m_time_margin;
      }
      
      void setTime(unsigned long int time) {
        m_time = time;
      }

      void setTimeMargin(unsigned long int time) {
        m_time_margin = time;
      }

      NodeIndex* getIndex() const {
        return m_index;
      }


      InputNode* getChild(unsigned int id) {
        if(id <= m_index->size())
          return ((*m_index)[id]);

        log_error("getChild() returning null due to bounds error");
        return NULL;
      }

      int getChildren() const {
        int count = 0;
        if(m_index) 
          for(InputNode::NodeIndex::iterator i = m_index->begin(); i != m_index->end(); ++i) 
            if(*i) count++;

        return count;
      }

      InputAction* getAction() const {
        return m_action;
      }

      void setAction(InputAction* action) {
        m_action = action;
      }

      InputNode* getParent() const {
        return m_parent;
      }

      int getID() const {
        return m_id;
      }

      InputNode* getActiveChild() {
        return m_activechild;
      }

      void setActiveChild(InputNode* node) {
        m_activechild = node;
      }
      //InputNode(InputAction* action, System* sys, InputNode::NodeIndex& index, InputNode* const parent, const int id);


    private:
      //InputNode(InputAction* action, System* sys, InputNode::NodeIndex& index, InputNode* parent, const int id);
      //InputNode::InputNode(InputAction* action, System* sys, InputNode* const parent, const int id);

      InputNode(InputAction* action, System* const sys, const NodeIndex& index, InputNode* parent, const int id);
      InputNode(InputAction* action, System* const sys, InputNode* parent, const int id);


      void cleanup();

      InputAction* m_action;
      const System* m_system;
      NodeIndex* m_index;

      InputNode* const m_parent;
      const int m_id;

      unsigned long m_time_margin;
      unsigned long m_time;

      //this was added because i wanted fast lookup of the activechild
      //this is set to NULL in the root node as it's the only node capable of handling
      //multiple active children, the Sequencer was built to govern those among other things 

      InputNode* m_activechild;
    
      //disallow copying
      //InputNode(const InputNode& );
      InputNode& operator=(const InputNode& );
  };

  
  class ComboHandler : public SystemClient, Logger {
    public:
      ComboHandler(System* const sys) : SystemClient(sys), m_root(NULL), m_controlling(NULL) {}
      virtual ~ComboHandler() { delete m_root; }

      bool add(const Ev::Sequence& seq);
      virtual bool handle(const InputData& input);

      bool isCombo(const Ev::Sequence& seq) const; 

      virtual std::string getName() const{ return "ComboHandler"; }
     

    private:
      bool canHandle(const InputData& input) const;
      bool Merge(const Ev::Sequence& seq);
      bool check_time(const InputNode* child) const; 

      const System* m_system;

      InputNode* m_root;

      InputNode* m_controlling;
  };


  class NormalHandler : public SystemClient, Logger {
    public:
      class NodeSequence {
        public:
          NodeSequence(InputNode* last) : m_last_node(last) {}
          InputNode* getLastNode() const { return m_last_node; } 

        private:
          InputNode* const m_last_node;
      };

      typedef std::map<Ev::Sequence, NodeSequence* > AddedSequences;


      
      NormalHandler(System* const sys) : SystemClient(sys), m_root(NULL) {} 
      virtual ~NormalHandler() { 
        delete m_root; 

        for(AddedSequences::iterator i  = m_added_seq.begin(); i != m_added_seq.end() ; i++) 
          delete (i->second);
      } 
      virtual std::string getName() const { return "NormalHandler"; }

      bool add(const Ev::Sequence& seq);
      bool remove(const Ev::Sequence& seq);

      virtual bool handle(const InputData& input);
      virtual bool handle(const ModData& input);
      bool isNormal(const Ev::Sequence& seq) const;
  
    private:  
      bool canHandle(const InputData& input) const;

      bool Merge(const Ev::Sequence& seq);
      bool unMerge(const Ev::Sequence& seq);

      InputNode* HandleActivity(const ModData& input);
      InputNode* recurChildController(InputNode* const node);
      InputNode* recurParentController(InputNode* const node);

      void RemoveControl(InputNode* node);

      std::deque <InputNode* >::iterator m_i; 

      std::deque <InputNode* > m_controlnodes; 

      InputNode* m_root;

      InputNode::NodeIndex  m_active;

      AddedSequences m_added_seq;
  };



  class NodeSequencer : public InputSequencer {
    public: 
      NodeSequencer(System* const sys) : m_chandler(sys), m_nhandler(sys) {}

      virtual ~NodeSequencer() {}

      std::string getName() const { return "NodeSequencer"; }

      bool imp_handle(const ModData& input) {
        bool normal_success, combo_success;
    
        //return m_nhandler.handle(input);
        normal_success = m_nhandler.handle(input); 
        combo_success  = m_chandler.handle(input);
        return (combo_success || normal_success);
      }

      bool imp_handle(const InputData& input) {
        bool normal_success, combo_success;

        //return m_nhandler.handle(input);
        normal_success  = m_nhandler.handle(input); 
        combo_success  = m_chandler.handle(input);
        return (combo_success || normal_success);
      }

    private:
      Ev::Sequence* capture(const ModData& input); 
      bool imp_addNormal(const Ev::Sequence& seq) {
        return m_nhandler.add(seq);
      }

      bool imp_removeNormal(const Ev::Sequence& seq) {
        return m_nhandler.remove(seq);
      }

      bool imp_addCombo(const Ev::Sequence& seq) {
        return m_chandler.add(seq);
      }

      bool isCombo(const Ev::Sequence& seq) const {
        return m_chandler.isCombo(seq);
      }

      bool isNormal(const Ev::Sequence& seq) const {
        return m_nhandler.isNormal(seq);
      }

      ComboHandler m_chandler;
      NormalHandler m_nhandler;
  };
}

---