X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fsurfaces%2Fmackie%2Fsurface.h;h=218e2e2cbc7c5b65978cd955af9cc56cbb9531b3;hb=e52c8e376a068c11a9a771a15977a65c067c71e6;hp=67da8fa33a8f5c4ac67dd89be4b68c03bf1227ff;hpb=79799023f5df9bec8c48dc1292a1bc2d996a28ab;p=ardour.git diff --git a/libs/surfaces/mackie/surface.h b/libs/surfaces/mackie/surface.h index 67da8fa33a..218e2e2cbc 100644 --- a/libs/surfaces/mackie/surface.h +++ b/libs/surfaces/mackie/surface.h @@ -1,108 +1,143 @@ #ifndef mackie_surface_h #define mackie_surface_h +#include + +#include + +#include "pbd/signals.h" +#include "pbd/xml++.h" +#include "midi++/types.h" + +#include "ardour/types.h" + +#include "control_protocol/types.h" + #include "controls.h" #include "types.h" -#include +#include "jog_wheel.h" -namespace Mackie -{ +namespace MIDI { + class Parser; +} -class MackieButtonHandler; -class SurfacePort; -class MackieMidiBuilder; +namespace ARDOUR { + class Stripable; + class Port; +} -/** - This represents an entire control surface, made up of Groups, - Strips and Controls. There are several collections for - ease of addressing in different ways, but only one collection - has definitive ownership. +class MidiByteArray; - It handles mapping button ids to press_ and release_ calls. +namespace ArdourSurface { - There are various emulations of the Mackie around, so specific - emulations will inherit from this to change button mapping, or - have 7 fader channels instead of 8, or whatever. +class MackieControlProtocol; - Currently there are BcfSurface and MackieSurface. +namespace Mackie +{ - TODO maybe make Group inherit from Control, for ease of ownership. -*/ -class Surface +class MackieButtonHandler; +class SurfacePort; +class MackieMidiBuilder; +class Button; +class Meter; +class Fader; +class Jog; +class Pot; +class Led; + +class Surface : public PBD::ScopedConnectionList, public sigc::trackable { public: - /** - A Surface can be made up of multiple units. eg one Mackie MCU plus - one or more Mackie MCU extenders. - - \param max_strips is the number of strips for the entire surface. - \param unit_strips is the number of strips per unit. - */ - - Surface (uint32_t max_strips, uint32_t unit_strips); + Surface (MackieControlProtocol&, const std::string& name, uint32_t number, surface_type_t stype); virtual ~Surface(); - /// Calls the virtual initialisation methods. This *must* be called after - /// construction, because c++ is too dumb to call virtual methods from - /// inside a constructor - void init(); + surface_type_t type() const { return _stype; } + uint32_t number() const { return _number; } + const std::string& name() { return _name; } + + void connected (); + + bool active() const { return _active; } typedef std::vector Controls; - - /// This collection has ownership of all the controls Controls controls; - /** - These are alternative addressing schemes - They use maps because the indices aren't always - 0-based. - - Indexed by raw_id not by id. @see Control for the distinction. - */ std::map faders; std::map pots; - std::map buttons; + std::map buttons; // index is device-DEPENDENT std::map leds; + std::map meters; + std::map controls_by_device_independent_id; - /// no strip controls in here because they usually - /// have the same names. - std::map controls_by_name; + Mackie::JogWheel* jog_wheel() const { return _jog_wheel; } + Fader* master_fader() const { return _master_fader; } - /// The collection of all numbered strips. No master - /// strip in here. + /// The collection of all numbered strips. typedef std::vector Strips; Strips strips; + uint32_t n_strips (bool with_locked_strips = true) const; + Strip* nth_strip (uint32_t n) const; + + bool stripable_is_locked_to_strip (boost::shared_ptr) const; + bool stripable_is_mapped (boost::shared_ptr) const; + /// This collection owns the groups typedef std::map Groups; Groups groups; - uint32_t max_strips() const { return _max_strips; } - - /// map button ids to calls to press_ and release_ in mbh - virtual void handle_button (MackieButtonHandler & mbh, ButtonState bs, Button & button); + SurfacePort& port() const { return *_port; } + + void map_stripables (const std::vector >&); + + void update_strip_selection (); + + const MidiByteArray& sysex_hdr() const; + + void periodic (ARDOUR::microseconds_t now_usecs); + void redisplay (ARDOUR::microseconds_t now_usecs, bool force); + void hui_heartbeat (); + + void handle_midi_pitchbend_message (MIDI::Parser&, MIDI::pitchbend_t, uint32_t channel_id); + void handle_midi_controller_message (MIDI::Parser&, MIDI::EventTwoBytes*); + void handle_midi_note_on_message (MIDI::Parser&, MIDI::EventTwoBytes*); + + /// Connect the any signal from the parser to handle_midi_any + /// unless it's already connected + void connect_to_signals (); + + /// write a sysex message + void write_sysex (const MidiByteArray& mba); + void write_sysex (MIDI::byte msg); + /// proxy write for port + void write (const MidiByteArray&); -public: /// display an indicator of the first switched-in Route. Do nothing by default. - virtual void display_bank_start( SurfacePort &, MackieMidiBuilder &, uint32_t /*current_bank*/ ) {}; - - /// called from MackieControlPRotocol::zero_all to turn things off - virtual void zero_all( SurfacePort &, MackieMidiBuilder & ) {}; + void display_bank_start (uint32_t /*current_bank*/); + + /// called from MackieControlProtocol::zero_all to turn things off + void zero_all (); + void zero_controls (); /// turn off leds around the jog wheel. This is for surfaces that use a pot /// pretending to be a jog wheel. - virtual void blank_jog_ring( SurfacePort &, MackieMidiBuilder & ) {}; + void blank_jog_ring (); + + void display_timecode (const std::string & /*timecode*/, const std::string & /*timecode_last*/); + + /// sends MCP "reset" message to surface + void reset (); + + void recalibrate_faders (); + void toggle_backlight (); + void set_touch_sensitivity (int); - virtual bool has_timecode_display() const = 0; - virtual void display_timecode( SurfacePort &, MackieMidiBuilder &, const std::string & /*timecode*/, const std::string & /*timecode_last*/) {}; - -public: /** This is used to calculate the clicks per second that define a transport speed of 1.0 for the jog wheel. 100.0 is 10 clicks per second, 50.5 is 5 clicks per second. */ - virtual float scrub_scaling_factor() = 0; + float scrub_scaling_factor() const; /** The scaling factor function for speed increase and decrease. At @@ -111,16 +146,79 @@ public: high definition control at low speeds and quick speed changes to/from higher speeds. */ - virtual float scaled_delta( const ControlState & state, float current_speed ) = 0; + float scaled_delta (float delta, float current_speed); + + // display the first 2 chars of the msg in the 2 char display + // . is appended to the previous character, so A.B. would + // be two characters + void show_two_char_display (const std::string & msg, const std::string & dots = " "); + void show_two_char_display (unsigned int value, const std::string & dots = " "); + + void update_view_mode_display (bool with_helpful_text); + void update_flip_mode_display (); + + void subview_mode_changed (); + + MackieControlProtocol& mcp() const { return _mcp; } -protected: - virtual void init_controls(); - virtual void init_strips (); + void next_jog_mode (); + void set_jog_mode (Mackie::JogWheel::Mode); - const uint32_t _max_strips; - const uint32_t _unit_strips; + void notify_metering_state_changed(); + void turn_it_on (); + + void display_message_for (std::string const& msg, uint64_t msecs); + + bool connection_handler (boost::weak_ptr, std::string name1, boost::weak_ptr, std::string name2, bool); + + void master_monitor_may_have_changed (); + + XMLNode& get_state (); + int set_state (const XMLNode&, int version); + + bool get_qcon_flag() { return is_qcon; } + + private: + MackieControlProtocol& _mcp; + SurfacePort* _port; + surface_type_t _stype; + uint32_t _number; + std::string _name; + bool _active; + bool _connected; + Mackie::JogWheel* _jog_wheel; + Fader* _master_fader; + float _last_master_gain_written; + PBD::ScopedConnection master_connection; + + void handle_midi_sysex (MIDI::Parser&, MIDI::byte *, size_t count); + MidiByteArray host_connection_query (MidiByteArray& bytes); + MidiByteArray host_connection_confirmation (const MidiByteArray& bytes); + + void say_hello (); + void init_controls (); + void init_strips (uint32_t n); + void setup_master (); + void master_gain_changed (); + + enum ConnectionState { + InputConnected = 0x1, + OutputConnected = 0x2 + }; + + int connection_state; + + // QCon Flag + bool is_qcon; + + MidiByteArray display_line (std::string const& msg, int line_num); + + public: + /* IP MIDI devices need to keep a handle on this and destroy it */ + GSource* input_source; }; +} } #endif