Merge branch 'cairocanvas' of git.ardour.org:ardour/ardour into cairocanvas

[ardour.git] / libs / midi++2 / midi++ / parser.h

diff --git a/libs/midi++2/midi++/parser.h b/libs/midi++2/midi++/parser.h
index 6733740ff797bf35d10445f03d7b82f22f834eed..420e7fcb7bb89a71115c8b0d76bf81d4ebb89945 100644 (file)
--- a/libs/midi++2/midi++/parser.h
+++ b/libs/midi++2/midi++/parser.h
@@ -23,28 +23,40 @@
 #include <string>
 #include <iostream>
 
-#include <sigc++/sigc++.h>
+#include "pbd/signals.h"
 
-#include <midi++/types.h>
+#include "midi++/libmidi_visibility.h"
+#include "midi++/types.h"
 
 namespace MIDI {
 
 class Port;
 class Parser;
 
-typedef sigc::signal<void, Parser &, byte>                 OneByteSignal;
-typedef sigc::signal<void, Parser &, EventTwoBytes *>      TwoByteSignal;
-typedef sigc::signal<void, Parser &, pitchbend_t>          PitchBendSignal;
-typedef sigc::signal<void, Parser &, byte *, size_t> Signal;
+typedef PBD::Signal1<void,Parser&>                   ZeroByteSignal;
+typedef PBD::Signal2<void,Parser&,unsigned short>    BankSignal;
+typedef PBD::Signal2<void,Parser&,framecnt_t>        TimestampedSignal;
+typedef PBD::Signal2<void,Parser&, byte>             OneByteSignal;
+typedef PBD::Signal2<void,Parser &, EventTwoBytes *> TwoByteSignal;
+typedef PBD::Signal2<void,Parser &, pitchbend_t>     PitchBendSignal;
+typedef PBD::Signal3<void,Parser &, byte *, size_t>  Signal;
 
-class Parser : public sigc::trackable {
+class LIBMIDIPP_API Parser {
  public:
-       Parser (Port &p);
+       Parser ();
        ~Parser ();
+
+       /* sets the time that will be reported for any MTC or MIDI Clock
+          message the next time ::scanner() parses such a message. It should
+          therefore be set before every byte passed into ::scanner().
+       */
        
+       framecnt_t get_timestamp() const { return _timestamp; }
+       void set_timestamp (const framecnt_t timestamp) { _timestamp = timestamp; } 
+
        /* signals that anyone can connect to */
        
-       OneByteSignal         bank_change;
+       BankSignal            bank_change;
        TwoByteSignal         note_on;
        TwoByteSignal         note_off;
        TwoByteSignal         poly_pressure;
@@ -53,7 +65,7 @@ class Parser : public sigc::trackable {
        PitchBendSignal       pitchbend;
        TwoByteSignal         controller;
 
-       OneByteSignal         channel_bank_change[16];
+       BankSignal            channel_bank_change[16];
        TwoByteSignal         channel_note_on[16];
        TwoByteSignal         channel_note_off[16];
        TwoByteSignal         channel_poly_pressure[16];
@@ -61,11 +73,11 @@ class Parser : public sigc::trackable {
        OneByteSignal         channel_program_change[16];
        PitchBendSignal       channel_pitchbend[16];
        TwoByteSignal         channel_controller[16];
-       sigc::signal<void, Parser &>          channel_active_preparse[16];
-       sigc::signal<void, Parser &>          channel_active_postparse[16];
-
-       OneByteSignal         mtc_quarter_frame;
+       ZeroByteSignal        channel_active_preparse[16];
+       ZeroByteSignal        channel_active_postparse[16];
 
+       OneByteSignal         mtc_quarter_frame; /* see below for more useful signals */
+       Signal                mtc;
        Signal                raw_preparse;
        Signal                raw_postparse;
        Signal                any;
@@ -74,18 +86,16 @@ class Parser : public sigc::trackable {
        Signal                position;
        Signal                song;
 
-       Signal                       mtc;
-       sigc::signal<void,Parser&>   mtc_qtr;
+       ZeroByteSignal        all_notes_off;
+       ZeroByteSignal        tune;
+       ZeroByteSignal        active_sense;
+       ZeroByteSignal        reset;
+       ZeroByteSignal        eox;
 
-       sigc::signal<void, Parser &>                     all_notes_off;
-       sigc::signal<void, Parser &>                     tune;
-       sigc::signal<void, Parser &, nframes_t>          timing;
-       sigc::signal<void, Parser &, nframes_t>          start;
-       sigc::signal<void, Parser &, nframes_t>          stop;
-       sigc::signal<void, Parser &, nframes_t>          contineu;  /* note spelling */
-       sigc::signal<void, Parser &>          active_sense;
-       sigc::signal<void, Parser &>          reset;
-       sigc::signal<void, Parser &>          eox;
+       TimestampedSignal     timing;
+       TimestampedSignal     start;
+       TimestampedSignal     stop;
+       TimestampedSignal     contineu;  /* note spelling */
 
        /* This should really be protected, but then derivatives of Port
           can't access it.
@@ -97,13 +107,12 @@ class Parser : public sigc::trackable {
        const char *midi_event_type_name (MIDI::eventType);
        void trace (bool onoff, std::ostream *o, const std::string &prefix = "");
        bool tracing() { return trace_stream != 0; }
-       Port &port() { return _port; }
 
        void set_offline (bool);
        bool offline() const { return _offline; }
-       sigc::signal<void> OfflineStatusChanged;
+       PBD::Signal0<void> OfflineStatusChanged;
 
-       sigc::signal<int, byte *, size_t> edit;
+       PBD::Signal2<int,byte *, size_t> edit;
 
        void set_mmc_forwarding (bool yn) {
                _mmc_forward = yn;
@@ -111,23 +120,15 @@ class Parser : public sigc::trackable {
 
        /* MTC */
 
-       enum MTC_Status {
-               MTC_Stopped = 0,
-               MTC_Forward,
-               MTC_Backward
-       };
-
        MTC_FPS mtc_fps() const { return _mtc_fps; }
        MTC_Status  mtc_running() const { return _mtc_running; }
        const byte *mtc_current() const { return _mtc_time; }
        bool        mtc_locked() const  { return _mtc_locked; }
        
-       const nframes_t get_midi_clock_timestamp() const { return _midi_clock_timestamp; }
-       void set_midi_clock_timestamp(const nframes_t timestamp) { _midi_clock_timestamp = timestamp; } 
-
-       sigc::signal<void,MTC_Status> mtc_status;
-       sigc::signal<bool>            mtc_skipped;
-       sigc::signal<void,const byte*,bool> mtc_time;
+       PBD::Signal3<void, Parser &, int, framecnt_t>      mtc_qtr;
+       PBD::Signal3<void, const byte *, bool, framecnt_t> mtc_time;
+       PBD::Signal1<void, MTC_Status>                     mtc_status;
+       PBD::Signal0<bool>                                 mtc_skipped;
 
        void set_mtc_forwarding (bool yn) {
                _mtc_forward = yn;
@@ -136,13 +137,12 @@ class Parser : public sigc::trackable {
        void reset_mtc_state ();
        
   private:
-       Port &_port;
        /* tracing */
-
+       
        std::ostream *trace_stream;
        std::string trace_prefix;
        void trace_event (Parser &p, byte *msg, size_t len);
-       sigc::connection trace_connection;
+       PBD::ScopedConnection trace_connection;
 
        size_t message_counter[256];
 
@@ -172,7 +172,7 @@ class Parser : public sigc::trackable {
        bool       _mtc_locked;
        byte last_qtr_frame;
        
-       nframes_t _midi_clock_timestamp;
+       framecnt_t _timestamp;
 
        ParseState pre_variable_state;
        MIDI::eventType pre_variable_msgtype;