libs/surfaces/generic_midi/generic_midi_control_protocol.h

   1 /*
   2     Copyright (C) 2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef ardour_generic_midi_control_protocol_h
  21 #define ardour_generic_midi_control_protocol_h
  22
  23 #include <list>
  24 #include <glibmm/threads.h>
  25
  26 #include "ardour/types.h"
  27 #include "ardour/port.h"
  28
  29 #include "control_protocol/control_protocol.h"
  30
  31 namespace PBD {
  32         class Controllable;
  33 }
  34
  35 namespace ARDOUR {
  36         class AsyncMIDIPort;
  37         class ControllableDescriptor;
  38         class MidiPort;
  39         class Session;
  40 }
  41
  42 namespace MIDI {
  43     class Port;
  44 }
  45
  46 class MIDIControllable;
  47 class MIDIFunction;
  48 class MIDIAction;
  49
  50 class GenericMidiControlProtocol : public ARDOUR::ControlProtocol {
  51   public:
  52         GenericMidiControlProtocol (ARDOUR::Session&);
  53         virtual ~GenericMidiControlProtocol();
  54
  55         int set_active (bool yn);
  56         static bool probe() { return true; }
  57
  58         boost::shared_ptr<ARDOUR::Port> input_port () const;
  59         boost::shared_ptr<ARDOUR::Port> output_port () const;
  60
  61         void set_feedback_interval (ARDOUR::microseconds_t);
  62
  63         int set_feedback (bool yn);
  64         bool get_feedback () const;
  65
  66         boost::shared_ptr<PBD::Controllable> lookup_controllable (const ARDOUR::ControllableDescriptor&) const;
  67
  68         XMLNode& get_state ();
  69         int set_state (const XMLNode&, int version);
  70
  71         bool has_editor () const { return true; }
  72         void* get_gui () const;
  73         void  tear_down_gui ();
  74
  75         int load_bindings (const std::string&);
  76         void drop_bindings ();
  77
  78         void check_used_event (int, int);
  79
  80         std::string current_binding() const { return _current_binding; }
  81
  82         struct MapInfo {
  83             std::string name;
  84             std::string path;
  85         };
  86
  87         std::list<MapInfo> map_info;
  88         void reload_maps ();
  89
  90         void set_current_bank (uint32_t);
  91         void next_bank ();
  92         void prev_bank ();
  93
  94         void set_motorised (bool);
  95
  96         bool motorised () const {
  97                 return _motorised;
  98         }
  99
 100         void set_threshold (int);
 101
 102         int threshold () const {
 103                 return _threshold;
 104         }
 105
 106         PBD::Signal0<void> ConnectionChange;
 107
 108   private:
 109         boost::shared_ptr<ARDOUR::AsyncMIDIPort> _input_port;
 110         boost::shared_ptr<ARDOUR::AsyncMIDIPort> _output_port;
 111
 112         ARDOUR::microseconds_t _feedback_interval;
 113         ARDOUR::microseconds_t last_feedback_time;
 114
 115         bool  do_feedback;
 116         void _send_feedback ();
 117         void  send_feedback ();
 118
 119         typedef std::list<MIDIControllable*> MIDIControllables;
 120         MIDIControllables controllables;
 121
 122         typedef std::list<MIDIFunction*> MIDIFunctions;
 123         MIDIFunctions functions;
 124
 125         typedef std::list<MIDIAction*> MIDIActions;
 126         MIDIActions actions;
 127
 128         typedef std::pair<MIDIControllable*,PBD::ScopedConnection> MIDIPendingControllable;
 129         typedef std::list<MIDIPendingControllable* > MIDIPendingControllables;
 130         MIDIPendingControllables pending_controllables;
 131         Glib::Threads::Mutex controllables_lock;
 132         Glib::Threads::Mutex pending_lock;
 133
 134         bool start_learning (PBD::Controllable*);
 135         void stop_learning (PBD::Controllable*);
 136
 137         void learning_stopped (MIDIControllable*);
 138
 139         void create_binding (PBD::Controllable*, int, int);
 140         void delete_binding (PBD::Controllable*);
 141
 142         MIDIControllable* create_binding (const XMLNode&);
 143         MIDIFunction* create_function (const XMLNode&);
 144         MIDIAction* create_action (const XMLNode&);
 145
 146         void reset_controllables ();
 147         void drop_all ();
 148
 149         enum ConnectionState {
 150                 InputConnected = 0x1,
 151                 OutputConnected = 0x2
 152         };
 153
 154         int connection_state;
 155         bool connection_handler (boost::weak_ptr<ARDOUR::Port>, std::string name1, boost::weak_ptr<ARDOUR::Port>, std::string name2, bool yn);
 156         PBD::ScopedConnection port_connection;
 157         void connected();
 158
 159         std::string _current_binding;
 160         uint32_t _bank_size;
 161         uint32_t _current_bank;
 162         /** true if this surface is motorised.  If it is, we assume
 163             that the surface's controls are never out of sync with
 164             Ardour's state, so we don't have to take steps to avoid
 165             values jumping around when things are not in sync.
 166         */
 167         bool _motorised;
 168         int _threshold;
 169
 170         mutable void *gui;
 171         void build_gui ();
 172
 173
 174 };
 175
 176 #endif /* ardour_generic_midi_control_protocol_h */