From 05d35395916f6d00f230ddd64ee0abbea3b5a09c Mon Sep 17 00:00:00 2001
From: Jan Lentfer <jan.lentfer@web.de>
Date: Fri, 21 Sep 2018 16:06:16 +0200
Subject: [PATCH] LCXL: complete overhaul and Mixbus support

---
 .../surfaces/launch_control_xl/controllers.cc | 1232 ++++++++++++++---
 .../launch_control_xl/launch_control_xl.cc    |  714 ++++++++--
 .../launch_control_xl/launch_control_xl.h     |  287 ++--
 3 files changed, 1805 insertions(+), 428 deletions(-)

diff --git a/libs/surfaces/launch_control_xl/controllers.cc b/libs/surfaces/launch_control_xl/controllers.cc
index eca0f7b7d7..37c048034f 100644
--- a/libs/surfaces/launch_control_xl/controllers.cc
+++ b/libs/surfaces/launch_control_xl/controllers.cc
@@ -34,44 +34,170 @@ using std::cerr;
 void
 LaunchControlXL::build_maps ()
 {
-	/* Knobs */
+	cc_knob_map.clear();
+	id_knob_map.clear();
+	cc_fader_map.clear();
+	id_fader_map.clear();
+	nn_note_button_map.clear();
+	id_note_button_map.clear();
+	cc_controller_button_map.clear();
+	id_controller_button_map.clear();
 
+	/* Knobs */
 	boost::shared_ptr<Knob> knob;
 
-	#define MAKE_KNOB(i,cc,index,a) \
-		knob.reset (new Knob ((i), (cc), (index), (a), (*this))); \
+	#define MAKE_KNOB(i,cc,index,c_on,c_off,a) \
+		knob.reset (new Knob ((i), (cc), (index), (c_on), (c_off), (a), (*this))); \
 		cc_knob_map.insert (std::make_pair (knob->controller_number(), knob)); \
-		id_knob_map.insert (std::make_pair (knob->id(), knob))
+		id_knob_map.insert (std::make_pair (knob->id(), knob));
+	#define MAKE_DM_KNOB(i,cc,index,c_on,c_off,action,check) \
+		knob.reset (new Knob ((i), (cc), (index), (c_on), (c_off), (action), (check), (*this))); \
+		cc_knob_map.insert (std::make_pair (knob->controller_number(), knob)); \
+		id_knob_map.insert (std::make_pair (knob->id(), knob));
 
-	MAKE_KNOB (SendA1, 13, 0, &LaunchControlXL::knob_sendA1);
-	MAKE_KNOB (SendA2, 14, 1, &LaunchControlXL::knob_sendA2);
-	MAKE_KNOB (SendA3, 15, 2, &LaunchControlXL::knob_sendA3);
-	MAKE_KNOB (SendA4, 16, 3, &LaunchControlXL::knob_sendA4);
-	MAKE_KNOB (SendA5, 17, 4, &LaunchControlXL::knob_sendA5);
-	MAKE_KNOB (SendA6, 18, 5, &LaunchControlXL::knob_sendA6);
-	MAKE_KNOB (SendA7, 19, 6, &LaunchControlXL::knob_sendA7);
-	MAKE_KNOB (SendA8, 20, 7, &LaunchControlXL::knob_sendA8);
+	if (!device_mode()) {	/* mixer mode */
+		MAKE_KNOB (SendA1, 13, 0, RedFull, RedLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendA, this, 0)));
+		MAKE_KNOB (SendA2, 14, 1, YellowFull, YellowLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendA, this, 1)));
+		MAKE_KNOB (SendA3, 15, 2, GreenFull, GreenLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendA, this, 2)));
+		MAKE_KNOB (SendA4, 16, 3, AmberFull, AmberLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendA, this, 3)));
+		MAKE_KNOB (SendA5, 17, 4, RedFull, RedLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendA, this, 4)));
+		MAKE_KNOB (SendA6, 18, 5, YellowFull, YellowLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendA, this, 5)));
+		MAKE_KNOB (SendA7, 19, 6, GreenFull, GreenLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendA, this, 6)));
+		MAKE_KNOB (SendA8, 20, 7, AmberFull, AmberLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendA, this, 7)));
 
-	MAKE_KNOB (SendB1, 29, 8, &LaunchControlXL::knob_sendB1);
-	MAKE_KNOB (SendB2, 30, 9, &LaunchControlXL::knob_sendB2);
-	MAKE_KNOB (SendB3, 31, 10, &LaunchControlXL::knob_sendB3);
-	MAKE_KNOB (SendB4, 32, 11, &LaunchControlXL::knob_sendB4);
-	MAKE_KNOB (SendB5, 33, 12, &LaunchControlXL::knob_sendB5);
-	MAKE_KNOB (SendB6, 34, 13, &LaunchControlXL::knob_sendB6);
-	MAKE_KNOB (SendB7, 35, 14, &LaunchControlXL::knob_sendB7);
-	MAKE_KNOB (SendB8, 36, 15, &LaunchControlXL::knob_sendB8);
+		MAKE_KNOB (SendB1, 29, 8, RedFull, RedLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendB, this, 0)));
+		MAKE_KNOB (SendB2, 30, 9, YellowFull, YellowLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendB, this, 1)));
+		MAKE_KNOB (SendB3, 31, 10, GreenFull, GreenLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendB, this, 2)));
+		MAKE_KNOB (SendB4, 32, 11, AmberFull, AmberLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendB, this, 3)));
+		MAKE_KNOB (SendB5, 33, 12, RedFull, RedLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendB, this, 4)));
+		MAKE_KNOB (SendB6, 34, 13, YellowFull, YellowLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendB, this, 5)));
+		MAKE_KNOB (SendB7, 35, 14, GreenFull, GreenLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendB, this, 6)));
+		MAKE_KNOB (SendB8, 36, 15, AmberFull, AmberLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_sendB, this, 7)));
+
+		MAKE_KNOB (Pan1, 49, 16, RedFull, RedLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_pan, this, 0)));
+		MAKE_KNOB (Pan2, 50, 17, YellowFull, YellowLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_pan, this, 1)));
+		MAKE_KNOB (Pan3, 51, 18, GreenFull, GreenLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_pan, this, 2)));
+		MAKE_KNOB (Pan4, 52, 19, AmberFull, AmberLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_pan, this, 3)));
+		MAKE_KNOB (Pan5, 53, 20, RedFull, RedLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_pan, this, 4)));
+		MAKE_KNOB (Pan6, 54, 21, YellowFull, YellowLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_pan, this, 5)));
+		MAKE_KNOB (Pan7, 55, 22, GreenFull, GreenLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_pan, this, 6)));
+		MAKE_KNOB (Pan8, 56, 23, AmberFull, AmberLow, boost::function<void ()> (boost::bind (&LaunchControlXL::knob_pan, this, 7)));
+
+	} else {	/* device mode */
+
+#ifdef MIXBUS // from here Mixbus Standard + 32C
+		MAKE_DM_KNOB (SendB5, 33, 12, RedFull, RedLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_trim, this, SendB5)),
+				boost::bind(&LaunchControlXL::dm_check_trim, this));
+		MAKE_DM_KNOB (SendB6, 34, 13, GreenFull, GreenLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_comp, this, SendB6, CompMakeup)),
+				boost::bind(&LaunchControlXL::dm_mb_comp_enabled,this));
+		MAKE_DM_KNOB (SendB7, 35, 14, GreenFull, GreenLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_comp, this, SendB7, CompSpeed)),
+				boost::bind(&LaunchControlXL::dm_mb_comp_enabled, this));
+		MAKE_DM_KNOB (SendB8, 36, 15, GreenFull, GreenLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_comp, this, SendB8, CompMode)),
+				boost::bind(&LaunchControlXL::dm_mb_comp_enabled, this));
+
+		/* Pan Knobs -> Sends */
+		for (uint8_t i = 0; i < 8; ++i) {
+			MAKE_DM_KNOB (static_cast<KnobID>(i + 16), (i + 49), (i + 16), GreenLow, YellowLow, boost::function<void()>
+				(boost::bind (&LaunchControlXL::dm_mb_sends, this, static_cast<KnobID>(i + 16))),
+				boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_check_send_knob, this, static_cast<KnobID>(i + 16))));
+		}
+
+#ifdef MIXBUS32C // from here 32C only
+
+		if (first_selected_stripable() && (first_selected_stripable()->is_master() || first_selected_stripable()->mixbus())) {
+			MAKE_DM_KNOB (SendA1, 13, 0, AmberFull, AmberLow, boost::function<void ()>
+					(boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA1, true, 0)),
+					boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 0)));
+			MAKE_DM_KNOB (SendA2, 14, 1, AmberFull, AmberLow, boost::function<void ()>
+					(boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA2, true, 1)),
+					boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 1)));
+			MAKE_DM_KNOB (SendA3, 15, 2, AmberFull, AmberLow, boost::function<void ()>
+					(boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA3, true, 2)),
+					boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 2)));
+			MAKE_DM_KNOB (SendA6, 18, 5, RedLow, RedLow, boost::function<void ()>
+					(boost::bind (&LaunchControlXL::dm_pan_width, this, SendA6)),
+					boost::bind(&LaunchControlXL::dm_check_pan_width, this));
+			MAKE_DM_KNOB (SendA7, 19, 6, AmberLow, AmberLow, boost::function<void ()>
+					(boost::bind (&LaunchControlXL::dm_mb_tapedrive, this, SendA7)),
+					boost::bind(&LaunchControlXL::dm_mb_has_tapedrive, this));
+		} else {
+			MAKE_DM_KNOB (SendA1, 13, 0, AmberFull, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA1, false, 0)),
+			              boost::bind(&LaunchControlXL::dm_mb_eq_freq_enabled, this));
+			MAKE_DM_KNOB (SendA2, 14, 1, AmberFull, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA2, true, 0)),
+			              boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 0)));
+			MAKE_DM_KNOB (SendA3, 15, 2, YellowLow, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA3, false, 1)),
+			              boost::bind(&LaunchControlXL::dm_mb_eq_freq_enabled, this));
+			MAKE_DM_KNOB (SendA4, 16, 3, YellowLow, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA4, true, 1)),
+			              boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 1)));
+			MAKE_DM_KNOB (SendA5, 17, 4, AmberFull, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA5, false, 2)),
+			              boost::bind(&LaunchControlXL::dm_mb_eq_freq_enabled, this));
+			MAKE_DM_KNOB (SendA6, 18, 5, AmberFull, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA6, true, 2)),
+			              boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 2)));
+			MAKE_DM_KNOB (SendA7, 19, 6, YellowLow, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA7, false, 3)),
+			              boost::bind(&LaunchControlXL::dm_mb_eq_freq_enabled, this));
+			MAKE_DM_KNOB (SendA8, 20, 7, YellowLow, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA8, true, 3)),
+			              boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 3)));
+		}
+			MAKE_DM_KNOB (SendB1, 29, 8, YellowFull, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_flt_frq, this, SendB1, true)),
+			              boost::bind(&LaunchControlXL::dm_mb_flt_enabled, this));
+			MAKE_DM_KNOB (SendB2, 30, 9, YellowFull, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_mb_flt_frq, this, SendB2, false)),
+			              boost::bind(&LaunchControlXL::dm_mb_flt_enabled, this));
+			MAKE_DM_KNOB (SendB4, 32, 11, RedLow, AmberLow, boost::function<void ()>
+			              (boost::bind (&LaunchControlXL::dm_pan_azi, this, SendB4)),
+			              boost::bind(&LaunchControlXL::dm_check_pan_azi, this));
+
+#else	// from here Mixbus Standard only
+		MAKE_DM_KNOB (SendA1, 13, 0, AmberFull, AmberLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA1, true, 0)),
+				boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 0)));
+		MAKE_DM_KNOB (SendA2, 14, 1, AmberFull, AmberLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA2, true, 1)),
+				boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 1)));
+		MAKE_DM_KNOB (SendA3, 15, 2, AmberFull, AmberLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_eq, this, SendA3, true, 2)),
+				boost::function<uint8_t ()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 2)));
+		MAKE_DM_KNOB (SendA5, 17, 4, RedLow, AmberLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_pan_azi, this, SendA5)),
+				boost::bind(&LaunchControlXL::dm_check_pan_azi, this));
+		MAKE_DM_KNOB (SendA6, 18, 5, RedLow, RedLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_pan_width, this, SendA6)),
+				boost::bind(&LaunchControlXL::dm_check_pan_width, this));
+		MAKE_DM_KNOB (SendA7, 19, 6, AmberLow, AmberLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_tapedrive, this, SendA7)),
+				boost::bind(&LaunchControlXL::dm_mb_has_tapedrive, this));
+		MAKE_DM_KNOB (SendB1, 29, 8, YellowFull, AmberLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_eq, this, SendB1, false, 0)),
+				boost::bind(&LaunchControlXL::dm_mb_eq_freq_enabled, this));
+		MAKE_DM_KNOB (SendB2, 30, 9, YellowFull, AmberLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_eq, this, SendB2, false, 1)),
+				boost::bind(&LaunchControlXL::dm_mb_eq_freq_enabled, this));
+		MAKE_DM_KNOB (SendB3, 31, 10, YellowFull, AmberLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_eq, this, SendB3, false, 2)),
+				boost::bind(&LaunchControlXL::dm_mb_eq_freq_enabled, this));
+		MAKE_DM_KNOB (SendB4, 32, 11, YellowFull, AmberLow, boost::function<void ()>
+				(boost::bind (&LaunchControlXL::dm_mb_flt_frq, this, SendB4, true)),
+				boost::bind(&LaunchControlXL::dm_mb_eq_freq_enabled, this));
+#endif
+#else // from here Ardour
+#endif
+	}
 
-	MAKE_KNOB (Pan1, 49, 16, &LaunchControlXL::knob_pan1);
-	MAKE_KNOB (Pan2, 50, 17, &LaunchControlXL::knob_pan2);
-	MAKE_KNOB (Pan3, 51, 18, &LaunchControlXL::knob_pan3);
-	MAKE_KNOB (Pan4, 52, 19, &LaunchControlXL::knob_pan4);
-	MAKE_KNOB (Pan5, 53, 20, &LaunchControlXL::knob_pan5);
-	MAKE_KNOB (Pan6, 54, 21, &LaunchControlXL::knob_pan6);
-	MAKE_KNOB (Pan7, 55, 22, &LaunchControlXL::knob_pan7);
-	MAKE_KNOB (Pan8, 56, 23, &LaunchControlXL::knob_pan8);
 
 	/* Faders */
-
 	boost::shared_ptr<Fader> fader;
 
 	#define MAKE_FADER(i,cc,a) \
@@ -79,32 +205,44 @@ LaunchControlXL::build_maps ()
 		cc_fader_map.insert (std::make_pair (fader->controller_number(), fader)); \
 		id_fader_map.insert (std::make_pair (fader->id(), fader))
 
-	MAKE_FADER (Fader1, 77, &LaunchControlXL::fader_1);
-	MAKE_FADER (Fader2, 78, &LaunchControlXL::fader_2);
-	MAKE_FADER (Fader3, 79, &LaunchControlXL::fader_3);
-	MAKE_FADER (Fader4, 80, &LaunchControlXL::fader_4);
-	MAKE_FADER (Fader5, 81, &LaunchControlXL::fader_5);
-	MAKE_FADER (Fader6, 82, &LaunchControlXL::fader_6);
-	MAKE_FADER (Fader7, 83, &LaunchControlXL::fader_7);
-	MAKE_FADER (Fader8, 84, &LaunchControlXL::fader_8);
+	if (!device_mode()) {	/* mix mode */
+		for (uint8_t i = 0; i < 8; ++i) {
+			MAKE_FADER(static_cast<FaderID>(i), i+77, boost::function<void()>
+				(boost::bind (&LaunchControlXL::fader, this, i)));
+		}
 
+	} else {	/* device mode */
+		MAKE_FADER(Fader1, 77,  boost::function<void()>
+			(boost::bind (&LaunchControlXL::dm_fader, this, Fader1)));
+#ifdef MIXBUS
+		MAKE_FADER(Fader2, 78,  boost::function<void()>
+			(boost::bind (&LaunchControlXL::dm_mb_comp_thresh, this, Fader2)));
+#endif
+	}
 
 	/* Buttons */
-
 	boost::shared_ptr<ControllerButton> controller_button;
 	boost::shared_ptr<NoteButton> note_button;
 
 
-	#define MAKE_TRACK_BUTTON_PRESS(i,nn,index,color,p) \
-		note_button.reset (new TrackButton ((i), (nn), (index), (color), (p), (*this))); \
+	#define MAKE_TRACK_BUTTON_PRESS(i,nn,index,c_on,c_off,p,check) \
+		note_button.reset (new TrackButton ((i), (nn), (index), (c_on), (c_off), (p), \
+		boost::bind(&LaunchControlXL::relax, this), boost::bind(&LaunchControlXL::relax, this), (check), (*this))); \
+		nn_note_button_map.insert (std::make_pair (note_button->note_number(), note_button)); \
+		id_note_button_map.insert (std::make_pair (note_button->id(), note_button))
+	#define MAKE_CTRL_BUTTON_PRESS(i,nn,index,c_on,c_off,p,check) \
+		note_button.reset (new TrackButton ((i), (nn), (index), (c_on), (c_off),  (p), \
+		boost::bind(&LaunchControlXL::relax, this), boost::bind(&LaunchControlXL::relax, this), (check), (*this))); \
 		nn_note_button_map.insert (std::make_pair (note_button->note_number(), note_button)); \
 		id_note_button_map.insert (std::make_pair (note_button->id(), note_button))
 	#define MAKE_SELECT_BUTTON_PRESS(i,cc,index,p) \
-		controller_button.reset (new SelectButton ((i), (cc), (index), (p), (*this))); \
+		controller_button.reset (new SelectButton ((i), (cc), (index), (p), \
+		boost::bind(&LaunchControlXL::relax, this), boost::bind(&LaunchControlXL::relax, this), (*this))); \
 		cc_controller_button_map.insert (std::make_pair (controller_button->controller_number(), controller_button)); \
 		id_controller_button_map.insert (std::make_pair (controller_button->id(), controller_button))
 	#define MAKE_TRACK_STATE_BUTTON_PRESS(i,nn,index,p) \
-		note_button.reset (new TrackStateButton ((i), (nn), (index), (p), (*this))); \
+		note_button.reset (new TrackStateButton ((i), (nn), (index), (p), \
+		boost::bind(&LaunchControlXL::relax, this), boost::bind(&LaunchControlXL::relax, this), (*this))); \
 		nn_note_button_map.insert (std::make_pair (note_button->note_number(), note_button)); \
 		id_note_button_map.insert (std::make_pair (note_button->id(), note_button))
 		#define MAKE_TRACK_STATE_BUTTON_PRESS_RELEASE_LONG(i,nn,index, p,r,l) \
@@ -112,34 +250,124 @@ LaunchControlXL::build_maps ()
 			nn_note_button_map.insert (std::make_pair (note_button->note_number(), note_button)); \
 			id_note_button_map.insert (std::make_pair (note_button->id(), note_button))
 
+	/* Track Focus Buttons */
+	if (!device_mode()) {	/* mixer mode */
+		for (uint8_t i = 0; i < 4; ++i) {
+			MAKE_TRACK_BUTTON_PRESS(static_cast<ButtonID>(i), i+41, i+24, YellowFull, YellowLow,
+				boost::function<void()>	(boost::bind (&LaunchControlXL::button_track_focus, this, i)),
+				boost::function<uint8_t()> (boost::bind (&LaunchControlXL::dm_check_dummy, this, dev_nonexistant)));
+		}
 
-	MAKE_TRACK_BUTTON_PRESS(Focus1, 41, 24, YellowLow, &LaunchControlXL::button_track_focus_1);
-	MAKE_TRACK_BUTTON_PRESS(Focus2, 42, 25, YellowLow, &LaunchControlXL::button_track_focus_2);
-	MAKE_TRACK_BUTTON_PRESS(Focus3, 43, 26, YellowLow, &LaunchControlXL::button_track_focus_3);
-	MAKE_TRACK_BUTTON_PRESS(Focus4, 44, 27, YellowLow, &LaunchControlXL::button_track_focus_4);
-	MAKE_TRACK_BUTTON_PRESS(Focus5, 57, 28, YellowLow, &LaunchControlXL::button_track_focus_5);
-	MAKE_TRACK_BUTTON_PRESS(Focus6, 58, 29, YellowLow, &LaunchControlXL::button_track_focus_6);
-	MAKE_TRACK_BUTTON_PRESS(Focus7, 59, 30, YellowLow, &LaunchControlXL::button_track_focus_7);
-	MAKE_TRACK_BUTTON_PRESS(Focus8, 60, 31, YellowLow, &LaunchControlXL::button_track_focus_8);
-	MAKE_TRACK_BUTTON_PRESS(Control1, 73, 32, AmberLow, &LaunchControlXL::button_track_control_1);
-	MAKE_TRACK_BUTTON_PRESS(Control2, 74, 33, AmberLow, &LaunchControlXL::button_track_control_2);
-	MAKE_TRACK_BUTTON_PRESS(Control3, 75, 34, AmberLow, &LaunchControlXL::button_track_control_3);
-	MAKE_TRACK_BUTTON_PRESS(Control4, 76, 35, AmberLow, &LaunchControlXL::button_track_control_4);
-	MAKE_TRACK_BUTTON_PRESS(Control5, 89, 36, AmberLow, &LaunchControlXL::button_track_control_5);
-	MAKE_TRACK_BUTTON_PRESS(Control6, 90, 37, AmberLow, &LaunchControlXL::button_track_control_6);
-	MAKE_TRACK_BUTTON_PRESS(Control7, 91, 38, AmberLow, &LaunchControlXL::button_track_control_7);
-	MAKE_TRACK_BUTTON_PRESS(Control8, 92, 39, AmberLow, &LaunchControlXL::button_track_control_8);
+		for (uint8_t i = 0; i < 4; ++i) {
+			MAKE_TRACK_BUTTON_PRESS(static_cast<ButtonID>(i+4), i+57, i+28, YellowFull, YellowLow,
+				boost::function<void()>	(boost::bind (&LaunchControlXL::button_track_focus, this, i+4)),
+				boost::function<uint8_t()> (boost::bind (&LaunchControlXL::dm_check_dummy, this, dev_nonexistant)));
+		}
 
-	MAKE_SELECT_BUTTON_PRESS(SelectUp, 104, 44, &LaunchControlXL::button_select_up);
-	MAKE_SELECT_BUTTON_PRESS(SelectDown, 105, 45, &LaunchControlXL::button_select_down);
-	MAKE_SELECT_BUTTON_PRESS(SelectLeft, 106, 46, &LaunchControlXL::button_select_left);
-	MAKE_SELECT_BUTTON_PRESS(SelectRight, 107, 47, &LaunchControlXL::button_select_right);
+	} else {		/* device mode */
+#ifdef MIXBUS
+		for (uint8_t i = 0; i < 4; ++i) {
+			MAKE_TRACK_BUTTON_PRESS(static_cast<ButtonID>(i), i+41, i+24, GreenFull, YellowLow,
+				boost::function<void()>	(boost::bind (&LaunchControlXL::dm_mb_send_switch, this, static_cast<ButtonID>(i))),
+				boost::function<uint8_t()> (boost::bind (&LaunchControlXL::dm_mb_check_send_button, this, i)));
 
-	MAKE_TRACK_STATE_BUTTON_PRESS_RELEASE_LONG(Device, 105, 40, &LaunchControlXL::relax, &LaunchControlXL::button_device, &LaunchControlXL::button_device_long_press);;
-	MAKE_TRACK_STATE_BUTTON_PRESS(Mute, 106, 41, &LaunchControlXL::button_mute);
-	MAKE_TRACK_STATE_BUTTON_PRESS(Solo, 107, 42, &LaunchControlXL::button_solo);
-	MAKE_TRACK_STATE_BUTTON_PRESS(Record, 108, 43, &LaunchControlXL::button_record);
+		}
 
+		for (uint8_t i = 0; i < 4; ++i) {
+			MAKE_TRACK_BUTTON_PRESS(static_cast<ButtonID>(i+4), i+57, i+28, GreenFull, YellowLow,
+				boost::function<void()>	(boost::bind (&LaunchControlXL::dm_mb_send_switch, this, static_cast<ButtonID>(i+4))),
+				boost::function<uint8_t()> (boost::bind (&LaunchControlXL::dm_mb_check_send_button, this, i+4)));
+		}
+#endif
+	}
+	/* Track Control Buttons */
+	if (!device_mode()) {	/* mixer mode */
+		/* Control Buttons in mix mode change their color dynamically so we won't set them here */
+		for (uint8_t i = 0; i < 4; ++i) {
+			MAKE_CTRL_BUTTON_PRESS(static_cast<ButtonID>(i+8), i+73, i+32, Off, Off,
+				boost::function<void()>	(boost::bind (&LaunchControlXL::button_press_track_control, this, i)),
+				boost::function<uint8_t()> (boost::bind (&LaunchControlXL::dm_check_dummy, this, dev_nonexistant)));
+		}
+
+		for (uint8_t i = 0; i < 4; ++i) {
+			MAKE_CTRL_BUTTON_PRESS(static_cast<ButtonID>(i+12), i+89, i+36, Off, Off,
+				boost::function<void()>	(boost::bind (&LaunchControlXL::button_press_track_control, this, i+4)),
+				boost::function<uint8_t()> (boost::bind (&LaunchControlXL::dm_check_dummy, this, dev_nonexistant)));
+		}
+
+	} else { /*device mode */
+#ifdef MIXBUS // from here Mixbus Standard + 32C
+		MAKE_CTRL_BUTTON_PRESS(Control1, 73, 32, YellowFull, YellowLow, (boost::bind (&LaunchControlXL::dm_mute_switch, this)),
+			boost::bind (&LaunchControlXL::dm_mute_enabled, this));
+		MAKE_CTRL_BUTTON_PRESS(Control2, 74, 33, GreenFull, GreenLow, (boost::bind (&LaunchControlXL::dm_solo_switch, this)),
+			boost::bind (&LaunchControlXL::dm_solo_enabled, this));
+		MAKE_CTRL_BUTTON_PRESS(Control3, 75, 34, AmberFull, AmberLow, (boost::bind (&LaunchControlXL::dm_mb_eq_switch, this)),
+			boost::function<uint8_t()> (boost::bind(&LaunchControlXL::dm_mb_eq_gain_enabled, this, 0)));
+
+
+#ifdef MIXBUS32C // from here 32C only
+		MAKE_CTRL_BUTTON_PRESS(Control4, 76, 35, AmberFull, AmberLow,
+			boost::function<void()> (boost::bind (&LaunchControlXL::dm_mb_eq_shape_switch, this, 0)),
+			boost::function<uint8_t()> (boost::bind(&LaunchControlXL::dm_mb_eq_shape_enabled, this, 0 )));
+		MAKE_CTRL_BUTTON_PRESS(Control5, 89, 36, AmberFull, AmberLow,
+			boost::function<void()> (boost::bind (&LaunchControlXL::dm_mb_eq_shape_switch, this, 3)),
+			boost::function<uint8_t()> (boost::bind(&LaunchControlXL::dm_mb_eq_shape_enabled, this, 3 )));
+		MAKE_CTRL_BUTTON_PRESS(Control6, 90, 37, YellowFull, YellowLow, (boost::bind (&LaunchControlXL::dm_mb_flt_switch, this)),
+			boost::bind(&LaunchControlXL::dm_mb_flt_enabled, this));
+		MAKE_CTRL_BUTTON_PRESS(Control7, 91, 38, GreenFull, GreenLow, (boost::bind (&LaunchControlXL::dm_mb_master_assign_switch, this)),
+			boost::bind(&LaunchControlXL::dm_mb_master_assign_enabled, this));
+		MAKE_CTRL_BUTTON_PRESS(Control8, 92, 39, GreenFull, GreenLow, (boost::bind (&LaunchControlXL::dm_mb_comp_switch, this)),
+			boost::bind(&LaunchControlXL::dm_mb_comp_enabled, this));
+
+#else // from here Mixbus Standard only
+		MAKE_CTRL_BUTTON_PRESS(Control5, 89, 36, GreenFull, GreenLow, (boost::bind (&LaunchControlXL::dm_mb_master_assign_switch, this)),
+			boost::bind(&LaunchControlXL::dm_mb_master_assign_enabled, this));
+		MAKE_CTRL_BUTTON_PRESS(Control7, 91, 38, GreenFull, GreenLow, (boost::bind (&LaunchControlXL::dm_mb_comp_switch, this)),
+			boost::bind(&LaunchControlXL::dm_mb_comp_enabled, this));
+		MAKE_CTRL_BUTTON_PRESS(Control8, 92, 39, RedFull, RedLow, (boost::bind (&LaunchControlXL::dm_recenable_switch, this)),
+			boost::bind(&LaunchControlXL::dm_recenable_enabled, this));
+
+#endif
+#else // Ardour
+#endif
+	}
+
+	/* Select and Mode Buttons on the right side */
+
+	/* Sends Select buttons are independent of mode */
+	MAKE_SELECT_BUTTON_PRESS(SelectUp, 104, 44, boost::function<void()> (boost::bind (&LaunchControlXL::send_bank_switch, this, false)));
+	MAKE_SELECT_BUTTON_PRESS(SelectDown, 105, 45,  boost::function<void()> (boost::bind (&LaunchControlXL::send_bank_switch, this, true)));
+
+	/* Device Button needs to be always there */
+	MAKE_TRACK_STATE_BUTTON_PRESS_RELEASE_LONG(Device, 105, 40,
+		boost::bind (&LaunchControlXL::relax, this) ,
+		boost::bind (&LaunchControlXL::button_device, this),
+	        boost::bind (&LaunchControlXL::button_device_long_press, this));
+
+
+	if (!device_mode()) {	/* mixer mode */
+		MAKE_SELECT_BUTTON_PRESS(SelectLeft, 106, 46, boost::bind (&LaunchControlXL::button_select_left, this));
+		MAKE_SELECT_BUTTON_PRESS(SelectRight, 107, 47, boost::bind (&LaunchControlXL::button_select_right, this));
+
+		//MAKE_TRACK_STATE_BUTTON_PRESS(Mute, 106, 41, boost::bind (&LaunchControlXL::button_mute, this));
+
+		MAKE_TRACK_STATE_BUTTON_PRESS_RELEASE_LONG(Mute, 106, 41,
+			boost::bind (&LaunchControlXL::relax, this) ,
+			boost::bind (&LaunchControlXL::button_mute, this),
+	        boost::bind (&LaunchControlXL::button_mute_long_press, this));
+
+		MAKE_TRACK_STATE_BUTTON_PRESS_RELEASE_LONG(Solo, 107, 42,
+			boost::bind (&LaunchControlXL::relax, this) ,
+			boost::bind (&LaunchControlXL::button_solo, this),
+	        boost::bind (&LaunchControlXL::button_solo_long_press, this));
+
+		//MAKE_TRACK_STATE_BUTTON_PRESS(Solo, 107, 42, boost::bind (&LaunchControlXL::button_solo, this));
+		MAKE_TRACK_STATE_BUTTON_PRESS(Record, 108, 43, boost::bind (&LaunchControlXL::button_record, this));
+
+	} else {	/* device mode */
+		MAKE_SELECT_BUTTON_PRESS(SelectLeft, 106, 46,  boost::bind (&LaunchControlXL::dm_select_prev_strip, this));
+		MAKE_SELECT_BUTTON_PRESS(SelectRight, 107, 47,  boost::bind (&LaunchControlXL::dm_select_next_strip, this));
+	}
 }
 
 std::string
@@ -349,77 +577,63 @@ LaunchControlXL::get_ac_by_state(uint8_t n) {
 		return ac;
 }
 
+boost::shared_ptr<LaunchControlXL::Knob>
+LaunchControlXL::knob_by_id(KnobID id)
+{
+	IDKnobMap::iterator k = id_knob_map.find(id);
+	return boost::dynamic_pointer_cast<Knob> (k->second);
+
+}
+
 boost::shared_ptr<LaunchControlXL::Knob>*
 LaunchControlXL::knobs_by_column(uint8_t col, boost::shared_ptr<Knob>* knob_col)
 {
 	for (uint8_t n = 0; n < 3; ++n) {
-		knob_col[n] = id_knob_map.find(static_cast<KnobID>(col+n*8))->second;
+		if (id_knob_map.find(static_cast<KnobID>(col+n*8)) != id_knob_map.end()) {
+			knob_col[n] = id_knob_map.find(static_cast<KnobID>(col+n*8))->second;
+		}
 	}
 
 	return knob_col;
 }
 
 void
-LaunchControlXL::update_knob_led(uint8_t n)
+LaunchControlXL::update_knob_led_by_id (uint8_t id, LEDColor color)
+{
+
+	boost::shared_ptr<Knob> knob = 0;
+	IDKnobMap::iterator k = id_knob_map.find(static_cast<KnobID>(id));
+
+	if (k != id_knob_map.end()) {
+		knob = k->second;
+	}
+
+	knob->set_color(color);
+	write (knob->state_msg());
+}
+
+void
+LaunchControlXL::update_knob_led_by_strip(uint8_t n)
 {
 	LEDColor color;
 
-	uint32_t absolute_strip_num = (n + bank_start) % 8;
-
-	if (stripable[n]) {
-		switch (absolute_strip_num) {
-			case 0:
-			case 4:
-				if (stripable[n]->is_selected()) {
-					color = RedFull;
-				} else {
-					color = RedLow;
-				}
-				break;
-
-			case 1:
-			case 5:
-				if (stripable[n]->is_selected()) {
-					color = YellowFull;
-				} else {
-					color = YellowLow;
-				}
-				break;
-
-			case 2:
-			case 6:
-				if (stripable[n]->is_selected()) {
-					color = GreenFull;
-				} else {
-					color = GreenLow;
-				}
-				break;
-
-			case 3:
-			case 7:
-				if (stripable[n]->is_master()) {
-					color = RedFull;
-				} else {
-					if (stripable[n]->is_selected()) {
-						color = AmberFull;
-					} else {
-						color = AmberLow;
-					}
-				}
-		}
-	}
-
 	boost::shared_ptr<Knob> knobs_col[3];
 	knobs_by_column(n, knobs_col);
 
-	for  (uint8_t s = 0; s < 3; ++s)
-	{
-		if (stripable[n]) {
-			knobs_col[s]->set_color(color);
-		} else {
-			knobs_col[s]->set_color(Off);
+	for  (uint8_t s = 0; s < 3; ++s) {
+		if (knobs_col[s]) {
+			if (stripable[n]) {
+				if (stripable[n]->is_selected()) {
+					color = knobs_col[s]->color_enabled();
+				} else {
+					color = knobs_col[s]->color_disabled();
+				}
+				knobs_col[s]->set_color(color);
+			} else {
+				knobs_col[s]->set_color(Off);
+			}
+			write (knobs_col[s]->state_msg());
 		}
-		write (knobs_col[s]->state_msg());
 	}
 }
 
@@ -432,43 +646,22 @@ LaunchControlXL::update_track_control_led(uint8_t n)
 		return;
 	}
 
+	if ((buttons_down.find(Device) != buttons_down.end())) {
+		/* Don't update LEDs if Device button is hold - we are working on selected strips */
+		return;
+	}
+
 	if (stripable[n]) {
-		boost::shared_ptr<AutomationControl> ac = get_ac_by_state(n);
-
-		switch(track_mode()) {
-			case TrackMute:
+			boost::shared_ptr<AutomationControl> ac = get_ac_by_state(n);
+			if (ac) {
 				if (ac->get_value()) {
-					b->set_color(YellowFull);
+					b->set_color(b->color_enabled());
 				} else {
-					b->set_color(AmberLow);
+				b->set_color(b->color_disabled());
 				}
-				break;
-			case TrackSolo:
-				if (ac && !(stripable[n]->is_master())) {
-					if (ac->get_value()) {
-						b->set_color(GreenFull);
-					} else {
-						b->set_color(GreenLow);
-					}
-				} else {
-					b->set_color(Off);
-				}
-				break;
-			case TrackRecord:
-				if (ac) {
-					if (ac->get_value()) {
-						b->set_color(RedFull);
-					} else {
-						b->set_color(RedLow);
-					}
-				} else {
-					b->set_color(Off);
-				}
-				break;
-
-			default:
-			break;
-		}
+			} else {
+				b->set_color(Off);
+			}
 	} else {
 		b->set_color(Off);
 	}
@@ -481,7 +674,8 @@ LaunchControlXL::solo_mute_rec_changed(uint32_t n) {
 	if (!stripable[n]) {
 		return;
 	}
-	update_track_control_led(n);
+	switch_bank(bank_start);
+	//update_track_control_led(n);
 }
 
 void
@@ -497,6 +691,8 @@ LaunchControlXL::solo_iso_changed(uint32_t n)
 void
 LaunchControlXL::solo_iso_led_bank ()
 {
+	if (device_mode()) { return; }
+
 	int stripable_counter = get_amount_of_tracks();
 
 	if (!(buttons_down.find(Device) != buttons_down.end())) {
@@ -510,7 +706,9 @@ LaunchControlXL::solo_iso_led_bank ()
 				} else {
 					b->set_color(Off);
 				}
-				write (b->state_msg());
+				if (b) {
+					write (b->state_msg());
+				}
 			}
 		}
 		LaunchControlXL::set_refresh_leds_flag(true);
@@ -526,12 +724,13 @@ LaunchControlXL::master_send_changed(uint32_t n)
 	} else {
 		master_send_led_bank();
 	}
-
 }
 
 void
 LaunchControlXL::master_send_led_bank ()
 {
+	if (device_mode()) { return; }
+
 	if (!(buttons_down.find(Device) != buttons_down.end())) {
 		return;
 	} else {
@@ -546,7 +745,9 @@ LaunchControlXL::master_send_led_bank ()
 					b->set_color(Off);
 				}
 			}
-			write (b->state_msg());
+			if (b) {
+				write (b->state_msg());
+			}
 		}
 		LaunchControlXL::set_refresh_leds_flag(true);
 	}
@@ -600,7 +801,7 @@ LaunchControlXL::knob_sendA(uint8_t n)
 	if (buttons_down.find(Device) != buttons_down.end()) { // Device button hold
 		ac = stripable[n]->trim_control();
 	} else {
-		ac = stripable[n]->send_level_controllable (0);
+		ac = stripable[n]->send_level_controllable (send_bank_base());
 	}
 
 	if (ac && check_pick_up(knob, ac)) {
@@ -635,7 +836,7 @@ LaunchControlXL::knob_sendB(uint8_t n)
 		/* something */
 	#endif
 	} else {
-		ac = stripable[n]->send_level_controllable (1);
+		ac = stripable[n]->send_level_controllable (send_bank_base() + 1);
 	}
 
 	if (ac && check_pick_up(knob, ac)) {
@@ -664,15 +865,16 @@ LaunchControlXL::knob_pan(uint8_t n)
 	boost::shared_ptr<AutomationControl> ac;
 
 	if (buttons_down.find(Device) != buttons_down.end()) { // Device button hold
-	#ifdef MIXBUS
+#ifdef MIXBUS
 		ac = stripable[n]->comp_threshold_controllable();
-	#else
+#else
 		ac = stripable[n]->pan_width_control();
-	#endif
+#endif
 	} else {
 		ac = stripable[n]->pan_azimuth_control();
 	}
 
+
 	if (ac && check_pick_up(knob, ac)) {
 		ac->set_value ( ac->interface_to_internal( knob->value() / 127.0), PBD::Controllable::UseGroup );
 	}
@@ -702,7 +904,7 @@ LaunchControlXL::button_track_focus(uint8_t n)
 }
 
 void
-LaunchControlXL::button_track_control(uint8_t n) {
+LaunchControlXL::button_press_track_control(uint8_t n) {
 	if (!stripable[n]) {
 		return;
 	}
@@ -742,9 +944,11 @@ LaunchControlXL::button_track_mode(TrackMode state)
 		boost::shared_ptr<TrackStateButton> solo = boost::dynamic_pointer_cast<TrackStateButton> (id_note_button_map[Solo]);
 		boost::shared_ptr<TrackStateButton> record = boost::dynamic_pointer_cast<TrackStateButton> (id_note_button_map[Record]);
 
-		write(mute->state_msg((state == TrackMute)));
-		write(solo->state_msg((state == TrackSolo)));
-		write(record->state_msg((state == TrackRecord)));
+		if (mute && solo && record) {
+			write(mute->state_msg((state == TrackMute)));
+			write(solo->state_msg((state == TrackSolo)));
+			write(record->state_msg((state == TrackRecord)));
+		}
 }
 
 void
@@ -760,26 +964,29 @@ LaunchControlXL::button_select_right()
 }
 
 void
-LaunchControlXL::button_select_up()
-{
-
-}
-
-void
-LaunchControlXL::button_select_down()
-{
-
+LaunchControlXL::send_bank_switch(bool down) {
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("send_bank_switch - down: %1\n", down));
+	if (down) {
+		set_send_bank(+2);
+	} else {
+		set_send_bank(-2);
+	}
 }
 
 void
 LaunchControlXL::button_device()
 {
-
+#ifndef MIXBUS
+	return; // currently device mode only on Mixbus
+#endif
+	LaunchControlXL::set_device_mode(!device_mode());
 }
 
 void
 LaunchControlXL::button_device_long_press()
 {
+	if (device_mode()) { return ; }
+
 	solo_iso_led_bank();
 #ifdef MIXBUS
 	master_send_led_bank();
@@ -796,6 +1003,12 @@ LaunchControlXL::button_mute()
 	}
 }
 
+void
+LaunchControlXL::button_mute_long_press()
+{
+	session->cancel_all_mute();
+}
+
 void
 LaunchControlXL::button_solo()
 {
@@ -806,6 +1019,12 @@ LaunchControlXL::button_solo()
 	}
 }
 
+void
+LaunchControlXL::button_solo_long_press()
+{
+	cancel_all_solo();
+}
+
 void
 LaunchControlXL::button_record()
 {
@@ -821,7 +1040,7 @@ LaunchControlXL::button_long_press_timeout (ButtonID id, boost::shared_ptr<Butto
 {
 	if (buttons_down.find (id) != buttons_down.end()) {
 		DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("long press timeout for %1, invoking method\n", id));
-		(this->*button->long_press_method) ();
+		(button->long_press_method) ();
 	} else {
 		DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("long press timeout for %1, expired/cancelled\n", id));
 		/* release happened and somehow we were not cancelled */
@@ -839,7 +1058,666 @@ LaunchControlXL::button_long_press_timeout (ButtonID id, boost::shared_ptr<Butto
 void
 LaunchControlXL::start_press_timeout (boost::shared_ptr<Button> button, ButtonID id)
 {
+	ButtonID no_timeout_buttons[] = { SelectUp, SelectDown, SelectLeft, SelectRight };
+
+	for (size_t n = 0; n < sizeof (no_timeout_buttons) / sizeof (no_timeout_buttons[0]); ++n) {
+		if (id == no_timeout_buttons[n]) {
+			DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Not using timeout for button id %1\n", id));
+			return;
+		}
+	}
+
 	Glib::RefPtr<Glib::TimeoutSource> timeout = Glib::TimeoutSource::create (500); // milliseconds
 	button->timeout_connection = timeout->connect (sigc::bind (sigc::mem_fun (*this, &LaunchControlXL::button_long_press_timeout), id, button));
 	timeout->attach (main_loop()->get_context());
 }
+
+
+/* Device Mode functions */
+
+void
+LaunchControlXL::dm_select_prev_strip()
+{
+	access_action ("Editor/select-prev-stripable");
+}
+
+void
+LaunchControlXL::dm_select_next_strip()
+{
+	access_action ("Editor/select-next-stripable");
+}
+
+uint8_t
+LaunchControlXL::dm_check_dummy (DeviceStatus ds)
+{
+	return ds;
+}
+
+void
+LaunchControlXL::dm_fader (FaderID id) {
+
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Fader> fader;
+
+	IDFaderMap::iterator f = id_fader_map.find(id);
+
+	if (f != id_fader_map.end()) {
+		fader = f->second;
+	}
+
+	ac = first_selected_stripable()->gain_control();
+	if (ac && check_pick_up(fader, ac)) {
+		ac->set_value ( ac->interface_to_internal( fader->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_check_pan_azi()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+	if (first_selected_stripable()->pan_azimuth_control()) {
+			dev_status = dev_active;
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_pan_azi (KnobID k)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Knob> knob = knob_by_id (k);
+
+	ac = first_selected_stripable()->pan_azimuth_control();
+
+	if (ac && check_pick_up(knob, ac)) {
+		ac->set_value ( ac->interface_to_internal( knob->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+
+uint8_t
+LaunchControlXL::dm_check_pan_width()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+	if (first_selected_stripable()->pan_width_control()) {
+			dev_status = dev_active;
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_pan_width (KnobID k)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	DEBUG_TRACE (DEBUG::LaunchControlXL, "dm_pan_width()\n");
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Knob> knob = knob_by_id (k);
+
+	ac = first_selected_stripable()->pan_width_control();
+
+	if (ac && check_pick_up(knob, ac)) {
+		ac->set_value ( ac->interface_to_internal( knob->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_check_trim()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+	if (first_selected_stripable()->trim_control()) {
+			dev_status = dev_active;
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_trim (KnobID k)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Knob> knob = knob_by_id (k);
+
+	ac = first_selected_stripable()->trim_control();
+
+	if (ac && check_pick_up(knob, ac)) {
+		ac->set_value ( ac->interface_to_internal( knob->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_mute_enabled()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+	if (first_selected_stripable()->mute_control()->get_value()) {
+		dev_status = dev_active;
+	} else {
+		dev_status = dev_inactive;
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_mute_switch()
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	if (first_selected_stripable()->mute_control()) {
+		first_selected_stripable()->mute_control()->set_value(!first_selected_stripable()->mute_control()->get_value(), PBD::Controllable::NoGroup);
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_solo_enabled()
+{
+	if (!first_selected_stripable() || first_selected_stripable()->is_master()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+	if (first_selected_stripable()->solo_control()) {
+		if (first_selected_stripable()->solo_control()->get_value()) {
+			dev_status = dev_active;
+		} else {
+			dev_status = dev_inactive;
+		}
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_solo_switch()
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	if (first_selected_stripable()->solo_control()) {
+		first_selected_stripable()->solo_control()->set_value(!first_selected_stripable()->solo_control()->get_value(), PBD::Controllable::NoGroup);
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_recenable_enabled()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+	if (first_selected_stripable()->rec_enable_control()) {
+		if (first_selected_stripable()->rec_enable_control()->get_value()) {
+			dev_status = dev_active;
+		}  else {
+			dev_status = dev_inactive;
+		}
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_recenable_switch()
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	if (first_selected_stripable()->rec_enable_control()) {
+		first_selected_stripable()->rec_enable_control()->set_value(!first_selected_stripable()->rec_enable_control()->get_value(), PBD::Controllable::NoGroup);
+	}
+}
+
+
+#ifdef MIXBUS
+uint8_t
+LaunchControlXL::dm_mb_eq_freq_enabled()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+
+	if (first_selected_stripable()->eq_enable_controllable()) {
+		if (first_selected_stripable()->eq_enable_controllable()->get_value()) {
+			dev_status = dev_active;
+		} else {
+			dev_status = dev_inactive;
+		}
+	}
+
+	if (first_selected_stripable()->mixbus() || first_selected_stripable()->is_master()) {
+		dev_status = dev_nonexistant;
+	}
+
+	return dev_status;
+}
+
+
+uint8_t
+LaunchControlXL::dm_mb_eq_gain_enabled(uint8_t band)
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+
+	if (first_selected_stripable()->eq_enable_controllable()) {
+		if (first_selected_stripable()->eq_enable_controllable()->get_value()) {
+			dev_status = dev_active;
+		} else {
+			dev_status = dev_inactive;
+		}
+	}
+
+	if (first_selected_stripable()->mixbus() && band > 3) {
+		dev_status = dev_nonexistant;
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_mb_eq (KnobID k, bool gain, uint8_t band)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Knob> knob = knob_by_id (k);
+	if (gain) {
+		ac = first_selected_stripable()->eq_gain_controllable(band);
+	} else {
+		ac = first_selected_stripable()->eq_freq_controllable(band);
+	}
+
+	if (ac && check_pick_up(knob, ac)) {
+		ac->set_value ( ac->interface_to_internal( knob->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+void
+LaunchControlXL::dm_mb_eq_shape_switch (uint8_t band)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	if (first_selected_stripable()->eq_shape_controllable(band)) {
+	first_selected_stripable()->eq_shape_controllable(band)->set_value
+			(!first_selected_stripable()->eq_shape_controllable(band)->get_value(), PBD::Controllable::NoGroup );
+	}
+}
+
+
+uint8_t
+LaunchControlXL::dm_mb_eq_shape_enabled(uint8_t band)
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+
+	if (first_selected_stripable()->eq_shape_controllable(band)) {
+		if (first_selected_stripable()->eq_shape_controllable(band)->get_value()) {
+			dev_status = dev_active;
+		} else {
+			dev_status = dev_inactive;
+		}
+	}
+
+	return dev_status;
+}
+
+
+void
+LaunchControlXL::dm_mb_eq_switch()
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	if (first_selected_stripable()->eq_enable_controllable()) {
+		first_selected_stripable()->eq_enable_controllable()->set_value
+			(!first_selected_stripable()->eq_enable_controllable()->get_value(), PBD::Controllable::NoGroup );
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_mb_flt_enabled()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	DEBUG_TRACE (DEBUG::LaunchControlXL, "dm_mb_flt_enabled()\n");
+	uint8_t dev_status = dev_nonexistant;
+
+	if (first_selected_stripable()->filter_enable_controllable(true)) {
+		DEBUG_TRACE (DEBUG::LaunchControlXL, "dm_mb_flt_enabled() - filter exists\n");
+		if (first_selected_stripable()->filter_enable_controllable(true)->get_value()) {
+			DEBUG_TRACE (DEBUG::LaunchControlXL, "dm_mb_flt_enabled: get_value true\n");
+			dev_status = dev_active;
+		} else {
+			dev_status = dev_inactive;
+		}
+	}
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose("dm_mb_flt_enabled: dev_status: %1\n", (int)dev_status));
+	return dev_status;
+}
+
+
+void
+LaunchControlXL::dm_mb_flt_switch()
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	if (first_selected_stripable()->filter_enable_controllable(true)) {
+		first_selected_stripable()->filter_enable_controllable(true)->set_value
+			(!first_selected_stripable()->filter_enable_controllable(true)->get_value(), PBD::Controllable::NoGroup );
+	}
+}
+
+
+
+void
+LaunchControlXL::dm_mb_flt_frq (KnobID k, bool hpf)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Knob> knob = knob_by_id (k);
+	if (hpf) {
+		ac = first_selected_stripable()->filter_freq_controllable(true);
+	} else {
+		ac = first_selected_stripable()->filter_freq_controllable(false);
+	}
+
+	if (ac && check_pick_up(knob, ac)) {
+		ac->set_value ( ac->interface_to_internal( knob->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_mb_check_send_knob (KnobID k)
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t send = static_cast<uint8_t> (k) - 16 + 4 * send_bank_base();
+
+	uint8_t dev_status = dev_nonexistant;
+
+	if (first_selected_stripable()->send_enable_controllable(send)) {
+		dev_status = dev_inactive;
+		if (first_selected_stripable()->send_enable_controllable(send)->get_value()) {
+			dev_status = dev_active;
+		}
+	}
+
+	return dev_status;
+}
+
+uint8_t
+LaunchControlXL::dm_mb_check_send_button (uint8_t s)
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+
+	uint8_t send = s + 4 * send_bank_base();
+
+	uint8_t dev_status = dev_nonexistant;
+
+	if (first_selected_stripable()->send_enable_controllable(send)) {
+		dev_status = dev_inactive;
+		if (first_selected_stripable()->send_enable_controllable(send)->get_value()) {
+			dev_status = dev_active;
+		}
+	}
+
+	return dev_status;
+}
+
+
+
+void
+LaunchControlXL::dm_mb_sends (KnobID k)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Knob> knob = knob_by_id (k);
+
+	uint8_t send = static_cast<uint8_t> (k) - 16 + 4 * send_bank_base();
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose("dm_mb_send: knobid '%1'\n", k));
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose("dm_mb_send: send '%1'\n", (int)send));
+
+
+	if (buttons_down.find(Device) != buttons_down.end()) { // Device button hold
+		ac = first_selected_stripable()->send_pan_azi_controllable(send);
+	} else {
+		ac = first_selected_stripable()->send_level_controllable(send);
+	}
+
+	if (ac && check_pick_up(knob, ac)) {
+		ac->set_value ( ac->interface_to_internal( knob->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_mb_comp_enabled()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+	if (first_selected_stripable()->comp_enable_controllable()) {
+		if (first_selected_stripable()->comp_enable_controllable()->get_value()) {
+			dev_status = dev_active;
+		} else {
+			dev_status = dev_inactive;
+		}
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_mb_comp_switch()
+{
+	DEBUG_TRACE (DEBUG::LaunchControlXL, "dm_mb_comp_siwtch() \n");
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	if (first_selected_stripable()->comp_enable_controllable()) {
+		DEBUG_TRACE (DEBUG::LaunchControlXL, "comp_enable_controllable exists\n");
+		DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose("comp_enable_controllable(): '%1'\n", first_selected_stripable()->comp_enable_controllable()->get_value() ));
+		first_selected_stripable()->comp_enable_controllable()->set_value
+			(!first_selected_stripable()->comp_enable_controllable()->get_value(), PBD::Controllable::NoGroup);
+	}
+
+}
+
+void
+LaunchControlXL::dm_mb_comp (KnobID k, CompParam c)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Knob> knob = knob_by_id (k);
+
+	switch (c) {
+		case (CompMakeup):
+			ac = first_selected_stripable()->comp_makeup_controllable();
+			break;
+		case (CompMode):
+			ac = first_selected_stripable()->comp_mode_controllable();
+			break;
+		case (CompSpeed):
+			ac = first_selected_stripable()->comp_speed_controllable();
+			break;
+	}
+
+		if (ac && check_pick_up(knob, ac)) {
+		ac->set_value ( ac->interface_to_internal( knob->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+void
+LaunchControlXL::dm_mb_comp_thresh (FaderID id) {
+
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Fader> fader;
+
+	IDFaderMap::iterator f = id_fader_map.find(id);
+
+	if (f != id_fader_map.end()) {
+		fader = f->second;
+	}
+
+	ac = first_selected_stripable()->comp_threshold_controllable();
+	if (ac && check_pick_up(fader, ac)) {
+		ac->set_value ( ac->interface_to_internal( fader->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_mb_has_tapedrive()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+
+	if (first_selected_stripable()->mixbus() || first_selected_stripable()->is_master()) {
+		dev_status = dev_active;
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_mb_tapedrive (KnobID k)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> ac;
+	boost::shared_ptr<Knob> knob = knob_by_id (k);
+
+	ac = first_selected_stripable()->tape_drive_controllable();
+
+	if (ac && check_pick_up(knob, ac)) {
+		ac->set_value ( ac->interface_to_internal( knob->value() / 127.0), PBD::Controllable::UseGroup );
+	}
+}
+
+uint8_t
+LaunchControlXL::dm_mb_master_assign_enabled()
+{
+	if (!first_selected_stripable()) {
+		return dev_nonexistant;
+	}
+
+	uint8_t dev_status = dev_nonexistant;
+
+	if (first_selected_stripable()->master_send_enable_controllable()) {
+		if (first_selected_stripable()->master_send_enable_controllable()->get_value()) {
+			dev_status = dev_active;
+		} else {
+			dev_status = dev_inactive;
+		}
+	}
+
+	return dev_status;
+}
+
+void
+LaunchControlXL::dm_mb_master_assign_switch()
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	if (first_selected_stripable()->master_send_enable_controllable()) {
+		first_selected_stripable()->master_send_enable_controllable()->set_value
+			(!first_selected_stripable()->master_send_enable_controllable()->get_value(), PBD::Controllable::NoGroup );
+	}
+}
+
+void
+LaunchControlXL::dm_mb_send_switch(ButtonID id)
+{
+	if (!first_selected_stripable()) {
+		return;
+	}
+
+	boost::shared_ptr<Button> button = id_note_button_map[id];;
+
+	uint8_t send = static_cast<uint8_t> (id) + 4 * send_bank_base();
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose("dm_mb_send: buttonid '%1'\n", (int)id));
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose("dm_mb_send: send '%1'\n", (int)send));
+
+	if (first_selected_stripable()->send_enable_controllable(send)) {
+		DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose("dm_mb_send: send '%1' exists\n", (int)send));
+		first_selected_stripable()->send_enable_controllable(send)->set_value
+			(!first_selected_stripable()->send_enable_controllable(send)->get_value(), PBD::Controllable::UseGroup);
+	}
+}
+
+#endif
diff --git a/libs/surfaces/launch_control_xl/launch_control_xl.cc b/libs/surfaces/launch_control_xl/launch_control_xl.cc
index 2a942eb3e6..287534a169 100644
--- a/libs/surfaces/launch_control_xl/launch_control_xl.cc
+++ b/libs/surfaces/launch_control_xl/launch_control_xl.cc
@@ -32,17 +32,21 @@
 #include "ardour/amp.h"
 #include "ardour/async_midi_port.h"
 #include "ardour/audioengine.h"
+#include "ardour/audio_track.h"
 #include "ardour/debug.h"
 #include "ardour/midiport_manager.h"
 #include "ardour/midi_track.h"
 #include "ardour/midi_port.h"
+#include "ardour/route.h"
 #include "ardour/session.h"
 #include "ardour/solo_isolate_control.h"
 #include "ardour/tempo.h"
 #include "ardour/types_convert.h"
+#include "ardour/vca.h"
 #include "ardour/vca_manager.h"
 
 
+
 #include "gtkmm2ext/gui_thread.h"
 
 #include "gui.h"
@@ -71,7 +75,12 @@ LaunchControlXL::LaunchControlXL (ARDOUR::Session& s)
 	, _track_mode(TrackMute)
 	, _template_number(8) // default template (factory 1)
 	, _fader8master (false)
+	, _device_mode (false)
+#ifdef MIXBUS32C
+	, _fss_is_mixbus (false)
+#endif
 	, _refresh_leds_flag (false)
+	, _send_bank_base (0)
 	, bank_start (0)
 	, connection_state (ConnectionState (0))
 	, gui (0)
@@ -80,8 +89,6 @@ LaunchControlXL::LaunchControlXL (ARDOUR::Session& s)
 	lcxl = this;
 	/* we're going to need this */
 
-	build_maps ();
-
 	/* master cannot be removed, so no need to connect to going-away signal */
 	master = session->master_out ();
 
@@ -91,19 +98,11 @@ LaunchControlXL::LaunchControlXL (ARDOUR::Session& s)
 
 	ports_acquire ();
 
-	/* catch arrival and departure of LaunchControlXL itself */
-	ARDOUR::AudioEngine::instance()->PortRegisteredOrUnregistered.connect (port_reg_connection, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::port_registration_handler, this), this);
-
 	/* Catch port connections and disconnections */
 	ARDOUR::AudioEngine::instance()->PortConnectedOrDisconnected.connect (port_connection, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::connection_handler, this, _1, _2, _3, _4, _5), this);
 
-	/* Launch Control XL ports might already be there */
-	port_registration_handler ();
-
 	session->RouteAdded.connect (session_connections, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::stripables_added, this), lcxl);
 	session->vca_manager().VCAAdded.connect (session_connections, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::stripables_added, this), lcxl);
-
-	switch_bank (bank_start);
 }
 
 LaunchControlXL::~LaunchControlXL ()
@@ -147,7 +146,14 @@ LaunchControlXL::begin_using_device ()
 
 	connect_session_signals ();
 
+	build_maps();
+
+	reset(template_number());
+
 	init_buttons (true);
+	init_knobs ();
+	button_track_mode(track_mode());
+	set_send_bank(0);
 
 	in_use = true;
 
@@ -249,14 +255,159 @@ LaunchControlXL::bundles ()
 	return b;
 }
 
+void
+LaunchControlXL::init_knobs_and_buttons()
+{
+	init_knobs();
+	init_buttons();
+}
+
+void
+LaunchControlXL::init_buttons()
+{
+	init_buttons(false);
+}
+
+void
+LaunchControlXL::init_buttons (ButtonID buttons[], uint8_t i)
+{
+	for (uint8_t n = 0; n < i; ++n) {
+		boost::shared_ptr<TrackButton> button = boost::dynamic_pointer_cast<TrackButton> (id_note_button_map[buttons[n]]);
+		if (button) {
+			switch ((button->check_method)()) {
+				case (dev_nonexistant):
+					button->set_color(Off);
+					break	;
+				case (dev_inactive):
+					button->set_color(button->color_disabled());
+					break;
+				case (dev_active):
+					button->set_color(button->color_enabled());
+					break;
+			}
+			DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Button %1 check_method returned: %2\n", n, (int)button->check_method()));
+			DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Write state_msg for Button:%1\n", n));
+			write (button->state_msg());
+		}
+	}
+	/* set "Track Select" LEDs always on - we cycle through stripables */
+	boost::shared_ptr<SelectButton> sl = boost::dynamic_pointer_cast<SelectButton>(id_controller_button_map[SelectLeft]);
+	boost::shared_ptr<SelectButton> sr = boost::dynamic_pointer_cast<SelectButton>(id_controller_button_map[SelectRight]);
+	if (sl && sr) {
+		write(sl->state_msg(true));
+		write(sr->state_msg(true));
+	}
+
+	boost::shared_ptr<TrackStateButton> db =  boost::dynamic_pointer_cast<TrackStateButton>(id_note_button_map[Device]);
+	if (db) {
+		write(db->state_msg(device_mode()));
+	}
+}
 
 void
 LaunchControlXL::init_buttons (bool startup)
 {
-	reset(template_number());
-
-	if (startup) {
+	if (startup && !device_mode()) {
 		switch_bank(bank_start);
+		return;
+	}
+
+	if (device_mode()) {
+		ButtonID buttons[] = { Focus1, Focus2, Focus3, Focus4, Focus5, Focus6, Focus7, Focus8,
+			Control1, Control2, Control3, Control4, Control5, Control6, Control7, Control8 };
+
+		for (size_t n = 0; n < sizeof (buttons) / sizeof (buttons[0]); ++n) {
+			boost::shared_ptr<TrackButton> button = boost::dynamic_pointer_cast<TrackButton> (id_note_button_map[buttons[n]]);
+			if (button) {
+				switch ((button->check_method)()) {
+					case (dev_nonexistant):
+						button->set_color(Off);
+						break;
+					case (dev_inactive):
+						button->set_color(button->color_disabled());
+						break;
+					case (dev_active):
+						button->set_color(button->color_enabled());
+						break;
+				}
+				DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Button %1 check_method returned: %2\n", n, (int)button->check_method()));
+				DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Write state_msg for Button:%1\n", n));
+				write (button->state_msg());
+			}
+		}
+	}
+
+	/* set "Track Select" LEDs always on - we cycle through stripables */
+	boost::shared_ptr<SelectButton> sl = boost::dynamic_pointer_cast<SelectButton>(id_controller_button_map[SelectLeft]);
+	boost::shared_ptr<SelectButton> sr = boost::dynamic_pointer_cast<SelectButton>(id_controller_button_map[SelectRight]);
+	if (sl && sr) {
+		write(sl->state_msg(true));
+		write(sr->state_msg(true));
+	}
+#ifdef MIXBUS // for now we only offer a device mode for Mixbus
+	boost::shared_ptr<TrackStateButton> db =  boost::dynamic_pointer_cast<TrackStateButton>(id_note_button_map[Device]);
+	if (db) {
+		write(db->state_msg(device_mode()));
+	}
+#endif
+}
+
+void
+LaunchControlXL::init_knobs (KnobID knobs[], uint8_t i)
+{
+	for (uint8_t n = 0; n < i ; ++n) {
+		DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("init_knobs from array - n:%1\n", n));
+		boost::shared_ptr<Knob> knob = id_knob_map[knobs[n]];
+		if (knob) {
+			switch ((knob->check_method)()) {
+				case (dev_nonexistant):
+					knob->set_color(Off);
+					break;
+				case (dev_inactive):
+					knob->set_color(knob->color_disabled());
+					break;
+				case (dev_active):
+					knob->set_color(knob->color_enabled());
+					break;
+			}
+			DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Write state_msg for Knob:%1\n", n));
+			write (knob->state_msg());
+		}
+	}
+}
+
+
+void
+LaunchControlXL::init_knobs ()
+{
+	if (!device_mode()) {
+		for (int n = 0; n < 8; ++n) {
+			update_knob_led_by_strip(n);
+		}
+	} else {
+		KnobID knobs[] = {	SendA1, SendA2, SendA3, SendA4, SendA5, SendA6, SendA7, SendA8,
+							SendB1, SendB2, SendB3, SendB4, SendB5, SendB6, SendB7, SendB8,
+							Pan1, Pan2, Pan3, Pan4, Pan5, Pan6, Pan7, Pan8 };
+
+		for (size_t n = 0; n < sizeof (knobs) / sizeof (knobs[0]); ++n) {
+			boost::shared_ptr<Knob> knob = id_knob_map[knobs[n]];
+			if (knob) {
+				switch ((knob->check_method)()) {
+					case (dev_nonexistant):
+						knob->set_color(Off);
+						break;
+					case (dev_inactive):
+						knob->set_color(knob->color_disabled());
+						break;
+					case (dev_active):
+						knob->set_color(knob->color_enabled());
+						break;
+				}
+
+				DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Write state_msg for Knob:%1\n", n));
+				write (knob->state_msg());
+			}
+		}
 	}
 }
 
@@ -402,8 +553,14 @@ LaunchControlXL::handle_midi_sysex (MIDI::Parser&, MIDI::byte* raw_bytes, size_t
 
 	switch (msg[6]) {
 	case 0x77: /* template change */
-		DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Template change: %1 n", msg[7]));
+		DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Template change: %1\n", (int)msg[7]));
 		_template_number = msg[7];
+		bank_start = 0;
+		if (!device_mode ()) {
+			switch_bank(bank_start);
+		} else {
+			init_device_mode();
+		}
 		break;
 	}
 }
@@ -412,44 +569,45 @@ LaunchControlXL::handle_midi_sysex (MIDI::Parser&, MIDI::byte* raw_bytes, size_t
 void
 LaunchControlXL::handle_button_message(boost::shared_ptr<Button> button, MIDI::EventTwoBytes* ev)
 {
-  if (ev->value) {
-    /* any press cancels any pending long press timeouts */
-    for (set<ButtonID>::iterator x = buttons_down.begin(); x != buttons_down.end(); ++x) {
-	    boost::shared_ptr<ControllerButton> cb = id_controller_button_map[*x];
-	    boost::shared_ptr<NoteButton>	nb = id_note_button_map[*x];
+	if (ev->value) {
+		/* any press cancels any pending long press timeouts */
+		for (set<ButtonID>::iterator x = buttons_down.begin(); x != buttons_down.end(); ++x) {
+			boost::shared_ptr<ControllerButton> cb = id_controller_button_map[*x];
+			boost::shared_ptr<NoteButton>	nb = id_note_button_map[*x];
 			if (cb != 0) {
 				cb->timeout_connection.disconnect();
 			} else if (nb != 0) {
-					nb->timeout_connection.disconnect();
+				nb->timeout_connection.disconnect();
 			}
-    }
+		}
 
-    buttons_down.insert(button->id());
-    DEBUG_TRACE(DEBUG::LaunchControlXL, string_compose("button pressed: %1\n", LaunchControlXL::button_name_by_id(button->id())));
-    start_press_timeout(button, button->id());
-  } else {
-    DEBUG_TRACE(DEBUG::LaunchControlXL, string_compose("button depressed: %1\n", LaunchControlXL::button_name_by_id(button->id())));
-    buttons_down.erase(button->id());
-    button->timeout_connection.disconnect();
-    if (button ==  id_note_button_map[Device] && refresh_leds_flag()) {
-	    switch_bank (bank_start);
-    }
-  }
+		buttons_down.insert(button->id());
+		DEBUG_TRACE(DEBUG::LaunchControlXL, string_compose("button pressed: %1\n", LaunchControlXL::button_name_by_id(button->id())));
+		start_press_timeout(button, button->id());
+	} else {
+		DEBUG_TRACE(DEBUG::LaunchControlXL, string_compose("button depressed: %1\n", LaunchControlXL::button_name_by_id(button->id())));
+		buttons_down.erase(button->id());
+		button->timeout_connection.disconnect();
+		if (button ==  id_note_button_map[Device] && refresh_leds_flag()) {
+			switch_bank (bank_start);
+		}
+	}
 
 	set<ButtonID>::iterator c = consumed.find(button->id());
 
-  if (c == consumed.end()) {
-    if (ev->value == 0) {
-      (this->*button->release_method)();
-    } else {
-      (this->*button->press_method)();
-    }
-  } else {
-    DEBUG_TRACE(DEBUG::LaunchControlXL, "button was consumed, ignored\n");
-    consumed.erase(c);
-  }
+	if (c == consumed.end()) {
+		if (ev->value == 0) {
+			(button->release_method)();
+		} else {
+			(button->press_method)();
+		}
+	} else {
+		DEBUG_TRACE(DEBUG::LaunchControlXL, "button was consumed, ignored\n");
+		consumed.erase(c);
+	}
 }
 
+
 bool
 LaunchControlXL::check_pick_up(boost::shared_ptr<Controller> controller, boost::shared_ptr<AutomationControl> ac)
 {
@@ -477,11 +635,11 @@ LaunchControlXL::handle_midi_controller_message (MIDI::Parser& parser, MIDI::Eve
 	} else if (f != cc_fader_map.end()) {
 		boost::shared_ptr<Fader> fader = f->second;
 		fader->set_value(ev->value);
-		(this->*fader->action_method)();
+		(fader->action_method)();
 	} else if (k != cc_knob_map.end()) {
 		boost::shared_ptr<Knob> knob = k->second;
 		knob->set_value(ev->value);
-		(this->*knob->action_method)();
+		(knob->action_method)();
 	}
 }
 
@@ -647,47 +805,6 @@ LaunchControlXL::set_state (const XMLNode & node, int version)
 	return retval;
 }
 
-void
-LaunchControlXL::port_registration_handler ()
-{
-	if (!_async_in || !_async_out || !_input_port || !_output_port) {
-		/* ports not registered yet */
-		return;
-	}
-
-	if (_async_in->connected() && _async_out->connected()) {
-		/* don't waste cycles here */
-		return;
-	}
-
-#ifdef __APPLE__
-	/* the origin of the numeric magic identifiers is known only to Ableton
-	   and may change in time. This is part of how CoreMIDI works.
-	*/
-	string input_port_name = X_("system:midi_capture_1319078870");
-	string output_port_name = X_("system:midi_playback_3409210341");
-#else
-	string input_port_name = X_("Novation Launch Control XL MIDI 1 in");
-	string output_port_name = X_("Novation Launch Control XL MIDI 1 out");
-#endif
-	vector<string> in;
-	vector<string> out;
-
-	AudioEngine::instance()->get_ports (string_compose (".*%1", input_port_name), DataType::MIDI, PortFlags (IsPhysical|IsOutput), in);
-	AudioEngine::instance()->get_ports (string_compose (".*%1", output_port_name), DataType::MIDI, PortFlags (IsPhysical|IsInput), out);
-
-	if (!in.empty() && !out.empty()) {
-		cerr << "LaunchControlXL: both ports found\n";
-		cerr << "\tconnecting to " << in.front() <<  " + " << out.front() << endl;
-		if (!_async_in->connected()) {
-			AudioEngine::instance()->connect (_async_in->name(), in.front());
-		}
-		if (!_async_out->connected()) {
-			AudioEngine::instance()->connect (_async_out->name(), out.front());
-		}
-	}
-}
-
 bool
 LaunchControlXL::connection_handler (boost::weak_ptr<ARDOUR::Port>, std::string name1, boost::weak_ptr<ARDOUR::Port>, std::string name2, bool yn)
 {
@@ -760,29 +877,164 @@ LaunchControlXL::input_port()
 /* Stripables handling */
 
 void
-LaunchControlXL::stripable_selection_changed () // we don't need it but it's needs to be declared...
+LaunchControlXL::stripable_selection_changed ()
 {
+	if (!device_mode()) {
+		switch_bank (bank_start);
+	} else {
+#ifdef MIXBUS32C
+		if (first_selected_stripable()) {
+			bool fss_unchanged;
+			fss_unchanged = (fss_is_mixbus() == (first_selected_stripable()->mixbus() || first_selected_stripable()->is_master()));
+				if (!fss_unchanged) {
+				reset(template_number());
+				build_maps();
+				store_fss_type();
+			}
+		}
+#endif
+		init_knobs_and_buttons();
+		init_dm_callbacks();
+	}
 }
 
 
 void
 LaunchControlXL::stripable_property_change (PropertyChange const& what_changed, uint32_t which)
 {
+	if (!device_mode()) {
+		if (what_changed.contains (Properties::hidden)) {
+			switch_bank (bank_start);
+		}
 
-	if (what_changed.contains (Properties::hidden)) {
-		switch_bank (bank_start);
+		if (what_changed.contains (Properties::selected)) {
+
+			if (!stripable[which]) {
+				return;
+			}
+			if (which < 8) {
+				update_track_focus_led ((uint8_t) which);
+				update_knob_led_by_strip((uint8_t) which);
+			}
+		}
+	} else {
+		init_knobs_and_buttons();
+	}
+}
+/* strip filter definitions */
+
+static bool flt_default (boost::shared_ptr<Stripable> s) {
+	if (s->is_master() || s->is_monitor()) {
+		return false;
+	}
+	return (boost::dynamic_pointer_cast<Route>(s) != 0 ||
+			boost::dynamic_pointer_cast<VCA>(s) != 0);
+}
+
+static bool flt_track (boost::shared_ptr<Stripable> s) {
+	return boost::dynamic_pointer_cast<Track>(s) != 0;
+}
+
+static bool flt_auxbus (boost::shared_ptr<Stripable> s) {
+	if (s->is_master() || s->is_monitor()) {
+		return false;
+	}
+	if (boost::dynamic_pointer_cast<Route>(s) == 0) {
+		return false;
+	}
+#ifdef MIXBUS
+	if (s->mixbus () > 0) {
+		return false;
+	}
+#endif
+	return boost::dynamic_pointer_cast<Track>(s) == 0;
+}
+
+#ifdef MIXBUS
+static bool flt_mixbus (boost::shared_ptr<Stripable> s) {
+	if (s->mixbus () == 0) {
+		return false;
+	}
+	return boost::dynamic_pointer_cast<Track>(s) == 0;
+}
+#endif
+
+static bool flt_vca (boost::shared_ptr<Stripable> s) {
+	return boost::dynamic_pointer_cast<VCA>(s) != 0;
+}
+
+static bool flt_selected (boost::shared_ptr<Stripable> s) {
+	return s->is_selected ();
+}
+
+#ifdef MIXBUS
+#else
+static bool flt_rec_armed (boost::shared_ptr<Stripable> s) {
+	boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(s);
+	if (!t) {
+		return false;
+	}
+	return t->rec_enable_control ()->get_value () > 0;
+}
+#endif
+
+static bool flt_mains (boost::shared_ptr<Stripable> s) {
+	return (s->is_master() || s->is_monitor());
+}
+
+void
+LaunchControlXL::filter_stripables(StripableList& strips) const
+{
+	typedef bool (*FilterFunction)(boost::shared_ptr<Stripable>);
+	FilterFunction flt;
+
+	switch ((int)template_number()) {
+		case 8:
+			flt = &flt_default;
+			break;
+		case 9:
+			flt = &flt_track;
+			break;
+		case 10:
+			flt = &flt_auxbus;
+			break;
+#ifdef MIXBUS
+		case 11:
+			flt = &flt_mixbus;
+			break;
+		case 12:
+			flt = &flt_vca;
+			break;
+#else
+		case 11:
+			flt = &flt_vca;
+			break;
+		case 12:
+			flt = &flt_rec_armed;
+			break;
+#endif
+		case 13:
+			flt = &flt_selected;
+			break;
+		case 14:	// Factory Template 7 behaves strange
+			break;  // don't map it to anyhting
+		case 15:
+			flt = &flt_mains;
+			break;
 	}
 
-	if (what_changed.contains (Properties::selected)) {
+	StripableList all;
+	session->get_stripables (all);
 
-		if (!stripable[which]) {
-			return;
-		}
-		if (which < 8) {
-			update_track_focus_led ((uint8_t) which);
-			update_knob_led((uint8_t) which);
+	for (StripableList::const_iterator s = all.begin(); s != all.end(); ++s) {
+		if ((*s)->is_auditioner ()) { continue; }
+		if ((*s)->is_hidden ()) { continue; }
+
+		if ((*flt)(*s)) {
+			strips.push_back (*s);
 		}
 	}
+	strips.sort (Stripable::Sorter(true));
 }
 
 void
@@ -795,78 +1047,197 @@ LaunchControlXL::switch_template (uint8_t t)
 void
 LaunchControlXL::switch_bank (uint32_t base)
 {
+	if (device_mode()) { return; }
+
+	reset(template_number());
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("switch_bank bank_start:%1\n", bank_start));
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("switch_bank base:%1\n", base));
+
+	StripableList strips;
+	filter_stripables (strips);
+	
+	set_send_bank(0);
+
+	set_send_bank(0);
+
 	boost::shared_ptr<SelectButton> sl = boost::dynamic_pointer_cast<SelectButton>(id_controller_button_map[SelectLeft]);
 	boost::shared_ptr<SelectButton> sr = boost::dynamic_pointer_cast<SelectButton>(id_controller_button_map[SelectRight]);
 
-	/* work backwards so we can tell if we should actually switch banks */
-
 	boost::shared_ptr<Stripable> s[8];
-	uint32_t different = 0;
+	boost::shared_ptr<Stripable> next_base = 0;
+	uint32_t stripable_counter = get_amount_of_tracks();
+	uint32_t skip = base;
+	uint32_t n = 0;
 
-
-	int stripable_counter = get_amount_of_tracks();
-
-	for (int n = 0; n < stripable_counter; ++n) {
-		s[n] = session->get_remote_nth_stripable (base+n, PresentationInfo::Flag (PresentationInfo::Route|PresentationInfo::VCA));
-		if (s[n] != stripable[n]) {
-			different++;
+	for (StripableList::const_iterator strip = strips.begin(); strip != strips.end(); ++strip) {
+		DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("StripableList iterator - skip: %1, n: %2\n", skip, n));
+		if (skip > 0) {
+			--skip;
+			continue;
 		}
+
+		if (n < stripable_counter) {
+			DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("StripableList iterator - assigning stripable for n: %1\n", n));
+			s[n] = *strip;
+		}
+
+		if (n == stripable_counter) { /* last strip +1 -> another bank exists */
+			DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("StripableList iterator - n: %1. Filling next_base\n", n));
+			next_base = *strip;
+			bank_start = base;
+			break;
+		}
+
+		++n;
 	}
 
 	if (!s[0]) {
 		/* not even the first stripable exists, do nothing */
+		DEBUG_TRACE (DEBUG::LaunchControlXL, "not even first stripable exists.. returning\n");
 		return;
 	}
 
 	if (sl && sr) {
-		boost::shared_ptr<Stripable> next_base = session->get_remote_nth_stripable (base+8, PresentationInfo::Flag (PresentationInfo::Route|PresentationInfo::VCA));
-		write(sl->state_msg((base)));
-		write(sr->state_msg((next_base != 0)));
+		write(sl->state_msg(base));
+		write(sr->state_msg(next_base != 0));
 	}
 
 	stripable_connections.drop_connections ();
 
-	for (int n = 0; n < stripable_counter; ++n) {
+	for (uint32_t n = 0; n < stripable_counter; ++n) {
 		stripable[n] = s[n];
 	}
 
-	/* at least one stripable in this bank */
-
-	bank_start = base;
-
 	for (int n = 0; n < 8; ++n) {
-
+		DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Binding Callbacks for n: %1\n", n));
 		if (stripable[n]) {
-			/* stripable goes away? refill the bank, starting at the same point */
+			DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("Binding Callbacks stripable[%1] exists\n", n));
 
-			stripable[n]->DropReferences.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::switch_bank, this, bank_start), lcxl);
-			stripable[n]->presentation_info().PropertyChanged.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::stripable_property_change, this, _1, n), lcxl);
-			stripable[n]->solo_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::solo_changed, this, n), lcxl);
-			stripable[n]->mute_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::mute_changed, this, n), lcxl);
+			stripable[n]->DropReferences.connect (stripable_connections, MISSING_INVALIDATOR,
+					boost::bind (&LaunchControlXL::switch_bank, this, bank_start), lcxl);
+			stripable[n]->presentation_info().PropertyChanged.connect (stripable_connections, MISSING_INVALIDATOR,
+					boost::bind (&LaunchControlXL::stripable_property_change, this, _1, n), lcxl);
+			stripable[n]->solo_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR,
+					boost::bind (&LaunchControlXL::solo_changed, this, n), lcxl);
+			stripable[n]->mute_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR,
+					boost::bind (&LaunchControlXL::mute_changed, this, n), lcxl);
 			if (stripable[n]->solo_isolate_control()) {	/*VCAs are stripables without isolate solo */
-				stripable[n]->solo_isolate_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::solo_iso_changed, this,n ), lcxl);
+				stripable[n]->solo_isolate_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR,
+						boost::bind (&LaunchControlXL::solo_iso_changed, this,n ), lcxl);
 			}
 #ifdef MIXBUS
 			if (stripable[n]->master_send_enable_controllable()) {
-				stripable[n]->master_send_enable_controllable()->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::master_send_changed, this,n ), lcxl);
+				stripable[n]->master_send_enable_controllable()->Changed.connect (stripable_connections, MISSING_INVALIDATOR,
+						boost::bind (&LaunchControlXL::master_send_changed, this,n ), lcxl);
 			}
 #endif
 			if (stripable[n]->rec_enable_control()) {
-				stripable[n]->rec_enable_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::rec_changed, this, n), lcxl);
+				stripable[n]->rec_enable_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR,
+						boost::bind (&LaunchControlXL::rec_changed, this, n), lcxl);
+
 			}
+
 		}
 		update_track_focus_led(n);
-		button_track_mode(track_mode());
-		update_knob_led(n);
+		update_track_control_led(n);
+		update_knob_led_by_strip(n);
 	}
+	button_track_mode(track_mode());
+}
+
+void
+LaunchControlXL::init_dm_callbacks()
+{
+	stripable_connections.drop_connections ();
+
+	if (!first_selected_stripable()) {
+		return;
+	}
+	if (first_selected_stripable()->mute_control()) {
+		first_selected_stripable()->mute_control()->Changed.connect (stripable_connections,
+		MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_buttons,this), lcxl);
+	}
+	if (first_selected_stripable()->solo_control()) {
+		first_selected_stripable()->solo_control()->Changed.connect (stripable_connections,
+		MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_buttons,this), lcxl);
+	}
+	if (first_selected_stripable()->rec_enable_control()) {
+		first_selected_stripable()->rec_enable_control()->Changed.connect (stripable_connections,
+		MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_buttons,this), lcxl);
+	}
+#ifdef MIXBUS
+	if (first_selected_stripable()->eq_enable_controllable()) {
+		first_selected_stripable()->eq_enable_controllable()->Changed.connect (stripable_connections,
+		MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_knobs_and_buttons,this), lcxl);
+	}
+	if (first_selected_stripable()->eq_shape_controllable(0)) {
+		first_selected_stripable()->eq_shape_controllable(0)->Changed.connect (stripable_connections,
+		MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_buttons,this), lcxl);
+	}
+	if (first_selected_stripable()->eq_shape_controllable(3)) {
+		first_selected_stripable()->eq_shape_controllable(3)->Changed.connect (stripable_connections,
+		MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_buttons,this), lcxl);
+	}
+
+	if (first_selected_stripable()->comp_enable_controllable()) {
+		first_selected_stripable()->comp_enable_controllable()->Changed.connect (stripable_connections,
+		MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_knobs_and_buttons,this), lcxl);
+	}
+	if (first_selected_stripable()->filter_enable_controllable(true)) { // only handle one case, as Mixbus only has one
+		first_selected_stripable()->filter_enable_controllable(true)->Changed.connect (stripable_connections,
+		MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_knobs_and_buttons, this), lcxl);
+	}
+	if (first_selected_stripable()->master_send_enable_controllable()) {
+		first_selected_stripable()->master_send_enable_controllable()->Changed.connect (stripable_connections,
+		MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_knobs_and_buttons, this), lcxl);
+	}
+
+	for (uint8_t se = 0; se < 12 ; ++se) {
+		if (first_selected_stripable()->send_enable_controllable(se)) {
+			first_selected_stripable()->send_enable_controllable(se)->Changed.connect (stripable_connections,
+			MISSING_INVALIDATOR, boost::bind (&LaunchControlXL::init_knobs_and_buttons, this), lcxl);
+		}
+	}
+#endif
+}
+
+
+#ifdef MIXBUS32C
+void
+LaunchControlXL::store_fss_type()
+{
+	if (first_selected_stripable()) {
+		if (first_selected_stripable()->mixbus() || first_selected_stripable()->is_master()) {
+			_fss_is_mixbus = true;
+		} else {
+			_fss_is_mixbus = false;
+		}
+	}
+}
+#endif
+
+void
+LaunchControlXL::init_device_mode()
+{
+	DEBUG_TRACE (DEBUG::LaunchControlXL, "Initializing device mode\n");
+	init_knobs();
+	init_buttons(false);
+#ifdef MIXBUS32C
+	store_fss_type();
+#endif
+	init_dm_callbacks();
 }
 
 void
 LaunchControlXL::stripables_added ()
 {
 	DEBUG_TRACE (DEBUG::LaunchControlXL, "LaunchControlXL::new stripable added!\n");
-	/* reload current bank */
-	switch_bank (bank_start);
+	if (!device_mode()) {
+		/* reload current bank */
+		switch_bank (bank_start);
+	} else {
+		return;
+	}
 }
 
 
@@ -874,21 +1245,54 @@ void LaunchControlXL::set_track_mode (TrackMode mode) {
 	_track_mode = mode;
 
 	// now do led stuffs to signify the change
+
+	ButtonID trk_cntrl_btns[] = {	Control1, Control2, Control3, Control4,
+					Control5, Control6, Control7, Control8 };
+
+	LEDColor color_on, color_off;
 	switch(mode) {
 		case TrackMute:
-
+			color_on = YellowFull;
+			color_off = YellowLow;
 			break;
 		case TrackSolo:
-
+			color_on = GreenFull;
+			color_off = GreenLow;
 			break;
 		case TrackRecord:
-
+			color_on = RedFull;
+			color_off = RedLow;
 			break;
 	default:
 		break;
 	}
+
+	for ( size_t n = 0 ; n < sizeof (trk_cntrl_btns) / sizeof (trk_cntrl_btns[0]); ++n) {
+		boost::shared_ptr<TrackButton> b = boost::dynamic_pointer_cast<TrackButton> (id_note_button_map[trk_cntrl_btns[n]]);
+		if (b) {
+			b->set_color_enabled(color_on);
+			b->set_color_disabled(color_off);
+		}
+	}
 }
 
+void
+LaunchControlXL::set_device_mode (bool yn)
+{
+	_device_mode = yn;
+	reset(template_number());
+	boost::shared_ptr<TrackStateButton> db =  boost::dynamic_pointer_cast<TrackStateButton>(id_note_button_map[Device]);
+	write(db->state_msg(_device_mode));
+	set_send_bank(0);
+	build_maps();
+	if (device_mode()) {
+		init_device_mode();
+	} else {
+		switch_bank (bank_start);
+	}
+}
+
+
 void
 LaunchControlXL::set_fader8master (bool yn)
 {
@@ -907,6 +1311,58 @@ LaunchControlXL::set_fader8master (bool yn)
 	switch_bank (bank_start);
 }
 
+void
+LaunchControlXL::set_send_bank (int offset)
+{
+	if ((_send_bank_base == 0 && offset < 0) || (_send_bank_base == 4 && offset > 0)) {
+		return;
+	}
+
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("set_send_bank - _send_bank_base: %1 \n", send_bank_base()));
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("set_send_bank - applying offset %1 \n", offset));
+
+	boost::shared_ptr<SelectButton> sbu = boost::dynamic_pointer_cast<SelectButton>(id_controller_button_map[SelectUp]);
+	boost::shared_ptr<SelectButton> sbd = boost::dynamic_pointer_cast<SelectButton>(id_controller_button_map[SelectDown]);
+
+	if (!sbu || !sbd ) {
+		return;
+	}
+
+	_send_bank_base = _send_bank_base + offset;
+	_send_bank_base = max (0, min (4, _send_bank_base));
+
+	DEBUG_TRACE (DEBUG::LaunchControlXL, string_compose ("set_send_bank - _send_bank_base: %1 \n", send_bank_base()));
+
+
+#ifdef MIXBUS
+	if (device_mode()) {	/* in device mode rebuild send led bindings */
+		build_maps();
+		//init_knobs_and_buttons();
+		KnobID knobs[] = { Pan1, Pan2, Pan3, Pan4, Pan5, Pan6, Pan7, Pan8 };
+		ButtonID buttons[] = { Focus1, Focus2, Focus3, Focus4, Focus5, Focus6, Focus7, Focus8 };
+		init_knobs (knobs, 8);
+		init_buttons (buttons, 8);
+	}
+#endif
+	switch (_send_bank_base) {
+		case 0:
+		case 1:
+			write (sbu->state_msg(false));
+			write (sbd->state_msg(true));
+			break;
+		case 2:
+		case 3:
+			write (sbu->state_msg(true));
+			write (sbd->state_msg(true));
+			break;
+		case 4:
+		case 5:
+			write (sbu->state_msg(true));
+			write (sbd->state_msg(false));
+			break;
+	}
+}
+
 int
 LaunchControlXL::get_amount_of_tracks ()
 {
diff --git a/libs/surfaces/launch_control_xl/launch_control_xl.h b/libs/surfaces/launch_control_xl/launch_control_xl.h
index 3bc496bdba..fcea6d2bfa 100644
--- a/libs/surfaces/launch_control_xl/launch_control_xl.h
+++ b/libs/surfaces/launch_control_xl/launch_control_xl.h
@@ -137,13 +137,26 @@ public:
 		Pan8
 	};
 
-	enum LEDFlag { Normal = 0xC, Blink = 0x8, DoubleBuffering = 0x0 };
+	enum DeviceStatus {
+		dev_nonexistant = 0,
+		dev_inactive,
+		dev_active
+	};
 
+	enum LEDFlag { Normal = 0xC, Blink = 0x8, DoubleBuffering = 0x0 };
 	enum LEDColor { Off=0, RedLow = 1, RedFull = 3, GreenLow = 16, GreenFull = 48, YellowLow = 34, YellowFull = 51, AmberLow = 18, AmberFull = 35};
 
 
+#ifdef MIXBUS
+	enum CompParam {
+		CompMakeup,
+		CompMode,
+		CompSpeed
+	};
+#endif
+
 	struct Controller {
-		Controller(uint8_t cn,  uint8_t val, void (LaunchControlXL::*action)())
+		Controller(uint8_t cn,  uint8_t val, boost::function<void ()> action)
 		: _controller_number(cn)
 		, _value(val)
 		, action_method(action) {}
@@ -157,7 +170,7 @@ public:
 		uint8_t _value;
 
 		public:
-		void (LaunchControlXL::*action_method)();
+		boost::function<void ()> action_method;
 	};
 
 	struct LED {
@@ -189,31 +202,20 @@ public:
 	};
 
 	struct Button {
-		Button(ButtonID id)
-			: press_method(&LaunchControlXL::relax)
-			, release_method(&LaunchControlXL::relax)
-			, long_press_method(&LaunchControlXL::relax), _id(id) {}
-
-		Button(ButtonID id, void (LaunchControlXL::*press)())
+		Button(ButtonID id, boost::function<void ()> press, boost::function<void ()> release,
+				boost::function<void ()> long_press)
 			: press_method(press)
-			, release_method(&LaunchControlXL::relax)
-			, long_press_method(&LaunchControlXL::relax), _id(id) {}
-
-		Button(ButtonID id, void (LaunchControlXL::*press)(), void (LaunchControlXL::*release)())
-			: press_method(press), release_method(release)
-			, long_press_method(&LaunchControlXL::relax), _id(id) {}
-
-		Button(ButtonID id, void (LaunchControlXL::*press)(), void (LaunchControlXL::*release)(), void (LaunchControlXL::*long_press)())
-			: press_method(press), release_method(release)
-			, long_press_method(long_press), _id(id) {}
+			, release_method(release)
+			, long_press_method(long_press),
+			_id(id) {}
 
 		virtual ~Button() {}
 
 		ButtonID id() const { return _id; }
 
-		void (LaunchControlXL::*press_method)();
-		void (LaunchControlXL::*release_method)();
-		void (LaunchControlXL::*long_press_method)();
+		boost::function<void ()> press_method;
+		boost::function<void ()> release_method;
+		boost::function<void ()> long_press_method;
 
 		sigc::connection timeout_connection;
 
@@ -222,15 +224,12 @@ public:
 	};
 
 	struct ControllerButton : public Button {
-
 		ControllerButton(ButtonID id, uint8_t cn,
-				void (LaunchControlXL::*press)())
-			: Button(id, press), _controller_number(cn) {}
+				boost::function<void ()> press,
+				boost::function<void ()> release,
+				boost::function<void ()> long_release)
+			: Button(id, press, release, long_release), _controller_number(cn) {}
 
-		ControllerButton(ButtonID id, uint8_t cn,
-				void (LaunchControlXL::*press)(),
-				void (LaunchControlXL::*release)())
-			: Button(id, press, release), _controller_number(cn) {}
 
 
 		uint8_t controller_number() const { return _controller_number; }
@@ -240,18 +239,10 @@ public:
 	};
 
 	struct NoteButton : public Button {
-
-		NoteButton(ButtonID id, uint8_t cn, void (LaunchControlXL::*press)())
-			: Button(id, press), _note_number(cn) {}
-
 		NoteButton(ButtonID id, uint8_t cn,
-				void (LaunchControlXL::*press)(),
-				void (LaunchControlXL::*release)())
-			: Button(id, press, release), _note_number(cn) {}
-		NoteButton(ButtonID id, uint8_t cn,
-				void (LaunchControlXL::*press)(),
-				void (LaunchControlXL::*release)(),
-				void (LaunchControlXL::*release_long)())
+				boost::function<void ()> press,
+				boost::function<void ()> release,
+				boost::function<void ()> release_long)
 			: Button(id, press, release, release_long), _note_number(cn) {}
 
 		uint8_t note_number() const { return _note_number; }
@@ -261,40 +252,52 @@ public:
 	};
 
 	struct TrackButton : public NoteButton, public MultiColorLED {
-		TrackButton(ButtonID id, uint8_t nn, uint8_t index, LEDColor color,
-				void (LaunchControlXL::*press)(), LaunchControlXL& l)
-			: NoteButton(id, nn, press), MultiColorLED(index, color, l) {}
-
-		TrackButton(ButtonID id, uint8_t nn, uint8_t index, LEDColor color,
-				void (LaunchControlXL::*press)(),
-				void (LaunchControlXL::*release)(),
+		TrackButton(ButtonID id, uint8_t nn, uint8_t index, LEDColor c_on, LEDColor c_off,
+				boost::function<void ()> press,
+				boost::function<void ()> release,
+				boost::function<void ()> release_long,
+				boost::function<uint8_t ()> check,
 				LaunchControlXL& l)
-			: NoteButton(id, nn, press, release), MultiColorLED(index, color, l) {}
+			: NoteButton(id, nn, press, release, release_long)
+			, MultiColorLED(index, Off, l)
+			, check_method(check)
+			, _color_enabled (c_on)
+			, _color_disabled (c_off) {}
+
+
+
+
+		LEDColor color_enabled() const { return _color_enabled; }
+		LEDColor color_disabled() const { return _color_disabled; }
+		void set_color_enabled (LEDColor c_on) { _color_enabled = c_on; }
+		void set_color_disabled (LEDColor c_off) { _color_disabled = c_off; }
+		boost::function<uint8_t ()> check_method;
+
 
 		MidiByteArray state_msg(bool light = true) const;
+
+		private:
+		LEDColor _color_enabled;
+		LEDColor _color_disabled;
 	};
 
 	struct SelectButton : public ControllerButton, public LED {
-		SelectButton(ButtonID id, uint8_t cn, uint8_t index, void (LaunchControlXL::*press)(), LaunchControlXL& l)
-			: ControllerButton(id, cn, press), LED(index, RedFull, l) {}
+		SelectButton(ButtonID id, uint8_t cn, uint8_t index,
+				boost::function<void ()> press,
+				boost::function<void ()> release,
+				boost::function<void ()> long_release,
+				LaunchControlXL& l)
+			: ControllerButton(id, cn, press, release, long_release), LED(index, RedFull, l) {}
+
 
 		MidiByteArray state_msg(bool light) const;
 	};
 
 	struct TrackStateButton : public NoteButton, public LED {
-		TrackStateButton(ButtonID id, uint8_t nn, uint8_t index, void (LaunchControlXL::*press)(), LaunchControlXL& l)
-			: NoteButton(id, nn, press)
-			, LED(index, YellowLow, l) {}
-
-		TrackStateButton(ButtonID id, uint8_t nn, uint8_t index, void (LaunchControlXL::*press)(),
-				void (LaunchControlXL::*release)(),
-				LaunchControlXL& l)
-			: NoteButton(id, nn, press, release)
-			, LED(index, YellowLow, l) {}
-
-		TrackStateButton(ButtonID id, uint8_t nn, uint8_t index, void (LaunchControlXL::*press)(),
-				void (LaunchControlXL::*release)(),
-				void (LaunchControlXL::*release_long)(),
+		TrackStateButton(ButtonID id, uint8_t nn, uint8_t index,
+				boost::function<void ()> press,
+				boost::function<void ()> release,
+				boost::function<void ()> release_long,
 				LaunchControlXL& l)
 			: NoteButton(id, nn, press, release, release_long)
 			, LED(index, YellowLow, l) {}
@@ -303,7 +306,7 @@ public:
 	};
 
 	struct Fader : public Controller {
-		Fader(FaderID id, uint8_t cn, void (LaunchControlXL::*action)())
+		Fader(FaderID id, uint8_t cn, boost::function<void ()> action)
 			: Controller(cn, 0, action), _id(id) {} // minimal value
 
 		FaderID id() const { return _id; }
@@ -315,17 +318,36 @@ public:
 	};
 
 	struct Knob : public Controller, public MultiColorLED {
-		Knob(KnobID id, uint8_t cn, uint8_t index, void (LaunchControlXL::*action)(), LaunchControlXL &l)
+		Knob(KnobID id, uint8_t cn, uint8_t index, LEDColor c_on, LEDColor c_off, boost::function<void ()> action,
+			LaunchControlXL &l)
 			: Controller(cn, 64, action)
 			, MultiColorLED(index, Off, l)
-			, _id(id) {} // knob 50/50 value
+			, _id(id)
+			, _color_enabled (c_on)
+			, _color_disabled (c_off) {} // knob 50/50 value
+
+		Knob(KnobID id, uint8_t cn, uint8_t index, LEDColor c_on, LEDColor c_off, boost::function<void ()> action,
+			boost::function<uint8_t ()> check, LaunchControlXL &l)
+			: Controller(cn, 64, action)
+			, MultiColorLED(index, Off, l)
+			, check_method(check)
+			, _id(id)
+			, _color_enabled (c_on)
+			, _color_disabled (c_off) {} // knob 50/50 value
+
+
 
 		KnobID id() const { return _id; }
+		LEDColor color_enabled() const { return _color_enabled; }
+		LEDColor color_disabled() const { return _color_disabled; }
+		boost::function<uint8_t ()> check_method;
 
 		MidiByteArray state_msg(bool light = true) const;
 
 		private:
 		KnobID _id;
+		LEDColor _color_enabled;
+		LEDColor _color_disabled;
 	};
 
 public:
@@ -368,19 +390,36 @@ public:
 	void set_refresh_leds_flag (bool yn);
 	bool refresh_leds_flag () const { return _refresh_leds_flag; }
 
+	void set_device_mode (bool yn);
+	bool device_mode () const { return _device_mode; }
+
+#ifdef MIXBUS32C
+	void store_fss_type();
+	bool fss_is_mixbus() const { return _fss_is_mixbus; }
+#endif
 	TrackMode track_mode() const { return _track_mode; }
 	void set_track_mode(TrackMode mode);
 
 	uint8_t template_number() const { return _template_number; }
 
+	void set_send_bank (int offset);
+	void send_bank_switch(bool up);
+	int send_bank_base () const { return _send_bank_base; }
+
 private:
 	bool in_use;
 	TrackMode _track_mode;
 	uint8_t _template_number;
 
 	bool _fader8master;
+	bool _device_mode;
+#ifdef MIXBUS32C
+	bool _fss_is_mixbus;
+#endif
 	bool _refresh_leds_flag;
 
+	int _send_bank_base;
+
 	void do_request(LaunchControlRequest *);
 
 	int begin_using_device();
@@ -426,9 +465,18 @@ private:
 	bool button_long_press_timeout(ButtonID id, boost::shared_ptr<Button> button);
 	void start_press_timeout(boost::shared_ptr<Button> , ButtonID);
 
+	void init_buttons();
 	void init_buttons(bool startup);
+	void init_buttons (ButtonID buttons[], uint8_t i);
+	void init_knobs();
+	void init_knobs(KnobID knobs[], uint8_t i);
+	void init_knobs_and_buttons();
+
+	void init_device_mode();
+	void init_dm_callbacks();
 
 	void switch_template(uint8_t t);
+	void filter_stripables (ARDOUR::StripableList& strips) const;
 
 	void build_maps();
 
@@ -463,57 +511,63 @@ private:
 	void notify_parameter_changed(std::string);
 
 	/* Knob methods */
-
+	boost::shared_ptr<Knob> knob_by_id(KnobID id);
 	boost::shared_ptr<Knob>* knobs_by_column(uint8_t col, boost::shared_ptr<Knob>* knob_col);
-	void update_knob_led(uint8_t n);
+	void update_knob_led_by_strip(uint8_t n);
+	void update_knob_led_by_id(uint8_t id, LEDColor color);
 
 	void knob_sendA(uint8_t n);
 	void knob_sendB(uint8_t n);
 	void knob_pan(uint8_t n);
 
+	uint8_t dm_check_dummy(DeviceStatus ds);
 
-	void knob_sendA1() { knob_sendA(0); }
-	void knob_sendA2() { knob_sendA(1); }
-	void knob_sendA3() { knob_sendA(2); }
-	void knob_sendA4() { knob_sendA(3); }
-	void knob_sendA5() { knob_sendA(4); }
-	void knob_sendA6() { knob_sendA(5); }
-	void knob_sendA7() { knob_sendA(6); }
-	void knob_sendA8() { knob_sendA(7); }
+	void dm_fader(FaderID id);
+	uint8_t dm_check_pan_azi ();
+	void dm_pan_azi(KnobID k);
+	uint8_t dm_check_pan_width();
+	void dm_pan_width (KnobID k);
+	uint8_t dm_check_trim ();
+	void dm_trim(KnobID k);
+	uint8_t dm_mute_enabled();
+	void dm_mute_switch();
+	uint8_t dm_solo_enabled();
+	void dm_solo_switch();
+	uint8_t dm_recenable_enabled();
+	void dm_recenable_switch();
+	void dm_select_prev_strip();
+	void dm_select_next_strip();
 
-	void knob_sendB1() { knob_sendB(0); }
-	void knob_sendB2() { knob_sendB(1); }
-	void knob_sendB3() { knob_sendB(2); }
-	void knob_sendB4() { knob_sendB(3); }
-	void knob_sendB5() { knob_sendB(4); }
-	void knob_sendB6() { knob_sendB(5); }
-	void knob_sendB7() { knob_sendB(6); }
-	void knob_sendB8() { knob_sendB(7); }
-
-	void knob_pan1() { knob_pan(0); }
-	void knob_pan2() { knob_pan(1); }
-	void knob_pan3() { knob_pan(2); }
-	void knob_pan4() { knob_pan(3); }
-	void knob_pan5() { knob_pan(4); }
-	void knob_pan6() { knob_pan(5); }
-	void knob_pan7() { knob_pan(6); }
-	void knob_pan8() { knob_pan(7); }
+#ifdef MIXBUS
+	void dm_mb_eq_switch();
+	void dm_mb_eq (KnobID k, bool gain, uint8_t band);
+	uint8_t dm_mb_eq_freq_enabled();
+	uint8_t dm_mb_eq_gain_enabled(uint8_t band);
+	void dm_mb_eq_shape_switch(uint8_t band);
+	uint8_t dm_mb_eq_shape_enabled(uint8_t band);
+	uint8_t dm_mb_flt_enabled();
+	void dm_mb_flt_frq (KnobID k, bool hpf);
+	void dm_mb_flt_switch();
+	void dm_mb_send_enabled(KnobID k);
+	uint8_t dm_mb_check_send_knob(KnobID k);
+	uint8_t dm_mb_check_send_button(uint8_t s);
+	void dm_mb_sends (KnobID k);
+	void dm_mb_send_switch (ButtonID b);
+	uint8_t dm_mb_comp_enabled();
+	void dm_mb_comp_switch();
+	void dm_mb_comp (KnobID k, CompParam c);
+	void dm_mb_comp_thresh (FaderID id);
+	uint8_t dm_mb_has_tapedrive();
+	void dm_mb_tapedrive (KnobID k);
+	uint8_t dm_mb_master_assign_enabled();
+	void dm_mb_master_assign_switch();
+#endif
 
 	/* Fader methods */
-
 	void fader(uint8_t n);
 
-	void fader_1() { fader(0); }
-	void fader_2() { fader(1); }
-	void fader_3() { fader(2); }
-	void fader_4() { fader(3); }
-	void fader_5() { fader(4); }
-	void fader_6() { fader(5); }
-	void fader_7() { fader(6); }
-	void fader_8() { fader(7); }
 
 	/* Button methods */
-
 	boost::shared_ptr<TrackButton> track_button_by_range(uint8_t n, uint8_t first, uint8_t middle);
 	boost::shared_ptr<TrackButton> focus_button_by_column(uint8_t col) { return track_button_by_range(col, 41, 57) ; }
 	boost::shared_ptr<TrackButton> control_button_by_column(uint8_t col) { return track_button_by_range(col, 73, 89) ; }
@@ -523,7 +577,9 @@ private:
 	void button_device_long_press();
 	void button_track_mode(TrackMode state);
 	void button_mute();
+	void button_mute_long_press();
 	void button_solo();
+	void button_solo_long_press();
 	void button_record();
 	void button_select_up();
 	void button_select_down();
@@ -531,29 +587,15 @@ private:
 	void button_select_right();
 
 	void button_track_focus(uint8_t n);
-	void button_track_control(uint8_t n);
+	void button_press_track_control(uint8_t n);
+	void button_release_track_control(uint8_t n);
 
 	boost::shared_ptr<ARDOUR::AutomationControl> get_ac_by_state(uint8_t n);
 	void update_track_focus_led(uint8_t n);
 	void update_track_control_led(uint8_t n);
 
-	void button_track_focus_1() { button_track_focus(0); }
-	void button_track_focus_2() { button_track_focus(1); }
-	void button_track_focus_3() { button_track_focus(2); }
-	void button_track_focus_4() { button_track_focus(3); }
-	void button_track_focus_5() { button_track_focus(4); }
-	void button_track_focus_6() { button_track_focus(5); }
-	void button_track_focus_7() { button_track_focus(6); }
-	void button_track_focus_8() { button_track_focus(7); }
-
-	void button_track_control_1() { button_track_control(0); }
-	void button_track_control_2() { button_track_control(1); }
-	void button_track_control_3() { button_track_control(2); }
-	void button_track_control_4() { button_track_control(3); }
-	void button_track_control_5() { button_track_control(4); }
-	void button_track_control_6() { button_track_control(5); }
-	void button_track_control_7() { button_track_control(6); }
-	void button_track_control_8() { button_track_control(7); }
+	void send_bank_switch_0() { send_bank_switch(0); }
+	void send_bank_switch_1() { send_bank_switch(1); }
 
 	/* stripables */
 
@@ -569,13 +611,14 @@ private:
 
 	void solo_changed (uint32_t n) { solo_mute_rec_changed(n); }
 	void mute_changed (uint32_t n) { solo_mute_rec_changed(n); }
+	void rec_changed (uint32_t n) { solo_mute_rec_changed(n); }
 	void solo_iso_changed (uint32_t n);
 	void solo_iso_led_bank ();
 #ifdef MIXBUS
 	void master_send_changed (uint32_t n);
 	void master_send_led_bank ();
 #endif
-	void rec_changed (uint32_t n) { solo_mute_rec_changed(n); }
+
 	void solo_mute_rec_changed (uint32_t n);
 
 	/* special Stripable */