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

Go to the documentation of this file.

// =====================================================================================
//       Filename:  InputSequencer.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 InputSequencer : public Logger {
    public:
      InputSequencer() : m_mode(Trigger), m_stop_capture_action(NULL), m_captured(NULL) {} 

      enum Mode {
        Trigger,  

        Capture
      };

      virtual ~InputSequencer() {
        if(m_captured) 
          delete m_captured;
      };

      
      void captureNormal( ModAction* stop_action ) {
        if(m_mode == Capture) 
          log_error("captureSeq() already in capture mode.");
        else  {
            m_stop_capture_action = stop_action; 
            m_mode = Capture;

          if(m_captured) {  
            delete m_captured;
            m_captured = NULL;
          }
        }
      }

      Ev::Sequence* getCaptured() const { 
        return m_captured; 
      }; 
    
      bool handle(const InputData& input) {
        return imp_handle(input); 
      };
      

      bool handle(const ModData& input) {
        if(m_mode == Capture) {
          if(capture(input))
            m_mode = Trigger;
        }

        return imp_handle(input); 
      };

      virtual bool isCombo(const Ev::Sequence& seq) const = 0;

      virtual bool isNormal(const Ev::Sequence& seq) const = 0;

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

      bool addNormal(const Ev& event) {
        Ev::Sequence* sequence;
        if((sequence = event.getSequence()) != NULL) {
          log_debug("addNormal validating..");
          if(isNormal(*sequence)) {
            return imp_addNormal(*sequence);
          }
        }
        return false;
      }

      bool removeNormal(const Ev& event) {
        Ev::Sequence* sequence;
        if((sequence = event.getSequence()) != NULL) {
          log_debug("removeNormal validating..");
          if(isNormal(*sequence)) {
            return imp_removeNormal(*sequence);
          }
        }
        return false;
      }

      bool addCombo(const Ev& event) {
        Ev::Sequence* sequence;
        if((sequence = event.getSequence()) != NULL) {
          log_debug("addCombo validating..");
          if(isCombo(*sequence)) {
            return imp_addCombo(*sequence);
          }
        }
        return false;
      }
    protected:
      Mode m_mode;
      InputAction* m_stop_capture_action; 
      Ev::Sequence* m_captured;

    private:
      virtual Ev::Sequence* capture(const ModData& input) = 0; 

      virtual bool imp_handle(const ModData& input) = 0; 
      virtual bool imp_handle(const InputData& input) = 0; 

      virtual bool imp_addNormal(const Ev::Sequence& seq) = 0; 
      virtual bool imp_removeNormal(const Ev::Sequence& seq) = 0; 

      virtual bool imp_addCombo(const Ev::Sequence& seq) = 0; 

  };
}

---