RNBO: src/RNBO_EventSender.h Source File

1 //

2 // RNBO_EventSender.h

3 //

4 // Created by Rob Sussman on 1/22/19.

5 // Extractd from RNBO_EventVariant.h

6 //

7 //

8 

9 #ifndef _RNBO_EventSender_H_

10 #define _RNBO_EventSender_H_

11 

12 #include "RNBO_Types.h"

13 #include "RNBO_EventTarget.h"

14 #include "RNBO_EventVariant.h"

15 #include "RNBO_EmptyEvent.h"

16 #include "RNBO_ClockEvent.h"

17 #include "RNBO_MidiEvent.h"

18 

19 namespace RNBO {

20 

24  class EventSender {

25 

26  public:

27 

28  virtual ~EventSender() { }

29 

30  virtual void sendEvent(const EventVariant& ev) const {

31  Event::Type eventType = ev.getType();

32 

33  switch (eventType) {

34  case Event::Empty: handleEmptyEvent(ev.getEmptyEvent()); break;

35  case Event::Clock: handleClockEvent(ev.getClockEvent()); break;

36  case Event::Midi: handleMidiEvent(ev.getMidiEvent()); break;

37  case Event::DataRef:

38  case Event::Outlet:

39  case Event::Parameter:

40  case Event::ParameterBang:

41  case Event::Universal:

42  case Event::Message:

43  case Event::Preset:

44  case Event::Tempo:

45  case Event::Transport:

46  case Event::BeatTime:

47  case Event::TimeSignature:

48  case Event::Startup:

49  case Event::BBU:

50  default: break;

51  }

52  }

53 

54  protected:

55 

56  EventSender(EventTarget* fallbackTarget)

57  : _fallbackTarget(fallbackTarget)

58  { }

59 

60  EventSender(const EventSender& other) = default;

61  EventSender& operator=(const EventSender& other) = default;

62 

63  private:

64 

65  void handleEmptyEvent(const EmptyEvent& ee) const {

66  RNBO_UNUSED(ee);

67  // nothing to do here

68  }

69 

70  void handleClockEvent(const ClockEvent& ce) const {

71  EventTarget* eventTarget = ce.getEventTarget() ? ce.getEventTarget() : _fallbackTarget;

72 

73  if (!eventTarget) return; // what do we do here? is it even a possibility?

74  eventTarget->processClockEvent(correctTime(ce.getTime()), ce.getClockIndex(), ce.hasValue(), ce.getValue());

75  }

76 

77  void handleMidiEvent(const MidiEvent& me) const {

78  EventTarget* eventTarget = me.getEventTarget() ? me.getEventTarget() : _fallbackTarget;

79 

80  if (!eventTarget) return;

81 

82  ConstByteArray data = me.getData(); // should midi be const char* or const unsigned char*

83  if (data) {

84  Index length = me.getLength();

85  int port = me.getPortIndex();

86  eventTarget->processMidiEvent(correctTime(me.getTime()), port, data, length);

87  }

88  }

89 

90  virtual MillisecondTime correctTime(MillisecondTime time) const {

91  return time;

92  }

93 

94  EventTarget* _fallbackTarget;

95 

96  };

97 

98 } // namespace RNBO

99 

100 

101 #endif // #ifndef _RNBO_EventSender_H_