X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fmidi_time_axis.cc;h=a4ffc442a3f7414093be61da1ef2d90f5dd65a73;hb=5e0c6af4062a2982fb90ad318973ab1d4beed2b9;hp=9db4a18ef4abe5ef5b3a6ec08a1be215e52183d2;hpb=e092fe33afc5cfd566e156f0d565cb1d0c1194f2;p=ardour.git diff --git a/gtk2_ardour/midi_time_axis.cc b/gtk2_ardour/midi_time_axis.cc index 9db4a18ef4..a4ffc442a3 100644 --- a/gtk2_ardour/midi_time_axis.cc +++ b/gtk2_ardour/midi_time_axis.cc @@ -19,6 +19,8 @@ #include #include +#include // for ffs(3) + #include #include #include @@ -55,8 +57,6 @@ #include "ardour/track.h" #include "ardour/types.h" -#include "midi++/names.h" - #include "ardour_ui.h" #include "ardour_button.h" #include "automation_line.h" @@ -68,6 +68,7 @@ #include "ghostregion.h" #include "gui_thread.h" #include "keyboard.h" +#include "midi_channel_selector.h" #include "midi_scroomer.h" #include "midi_streamview.h" #include "midi_region_view.h" @@ -96,8 +97,8 @@ using namespace Gtkmm2ext; using namespace Editing; // Minimum height at which a control is displayed -static const uint32_t MIDI_CONTROLS_BOX_MIN_HEIGHT = 162; -static const uint32_t KEYBOARD_MIN_HEIGHT = 140; +static const uint32_t MIDI_CONTROLS_BOX_MIN_HEIGHT = 140; +static const uint32_t KEYBOARD_MIN_HEIGHT = 130; MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session* sess, Canvas& canvas) : AxisView(sess) // virtually inherited @@ -112,9 +113,10 @@ MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session* sess, Canvas& can , _meter_color_mode_item(0) , _channel_color_mode_item(0) , _track_color_mode_item(0) + , _channel_selector (0) , _step_edit_item (0) , controller_menu (0) - , _step_editor (0) + , _step_editor (0) { } @@ -128,9 +130,9 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) if (is_track ()) { _piano_roll_header = new PianoRollHeader(*midi_view()); _range_scroomer = new MidiScroomer(midi_view()->note_range_adjustment); - _range_scroomer->DoubleClicked.connect (sigc::bind ( - sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), - MidiStreamView::ContentsRange, false)); + _range_scroomer->DoubleClicked.connect ( + sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), + MidiStreamView::ContentsRange, false)); } /* This next call will result in our height being set up, so it must come after @@ -144,10 +146,15 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) subplugin_menu.set_name ("ArdourContextMenu"); if (!gui_property ("note-range-min").empty ()) { - midi_view()->apply_note_range (atoi (gui_property ("note-range-min").c_str()), atoi (gui_property ("note-range-max").c_str()), true); + midi_view()->apply_note_range (atoi (gui_property ("note-range-min").c_str()), + atoi (gui_property ("note-range-max").c_str()), + true); } - midi_view()->NoteRangeChanged.connect (sigc::mem_fun (*this, &MidiTimeAxisView::note_range_changed)); - _view->ContentsHeightChanged.connect (sigc::mem_fun (*this, &MidiTimeAxisView::contents_height_changed)); + + midi_view()->NoteRangeChanged.connect ( + sigc::mem_fun (*this, &MidiTimeAxisView::note_range_changed)); + _view->ContentsHeightChanged.connect ( + sigc::mem_fun (*this, &MidiTimeAxisView::contents_height_changed)); ignore_toggle = false; @@ -162,17 +169,25 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) processors_changed (RouteProcessorChange ()); - _route->processors_changed.connect (*this, invalidator (*this), boost::bind (&MidiTimeAxisView::processors_changed, this, _1), gui_context()); + _route->processors_changed.connect (*this, invalidator (*this), + boost::bind (&MidiTimeAxisView::processors_changed, this, _1), + gui_context()); if (is_track()) { - _piano_roll_header->SetNoteSelection.connect (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection)); - _piano_roll_header->AddNoteSelection.connect (sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection)); - _piano_roll_header->ExtendNoteSelection.connect (sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection)); - _piano_roll_header->ToggleNoteSelection.connect (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection)); + _piano_roll_header->SetNoteSelection.connect ( + sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection)); + _piano_roll_header->AddNoteSelection.connect ( + sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection)); + _piano_roll_header->ExtendNoteSelection.connect ( + sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection)); + _piano_roll_header->ToggleNoteSelection.connect ( + sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection)); /* Suspend updates of the StreamView during scroomer drags to speed things up */ - _range_scroomer->DragStarting.connect (sigc::mem_fun (*midi_view(), &MidiStreamView::suspend_updates)); - _range_scroomer->DragFinishing.connect (sigc::mem_fun (*midi_view(), &MidiStreamView::resume_updates)); + _range_scroomer->DragStarting.connect ( + sigc::mem_fun (*midi_view(), &MidiStreamView::suspend_updates)); + _range_scroomer->DragFinishing.connect ( + sigc::mem_fun (*midi_view(), &MidiStreamView::resume_updates)); /* Put the scroomer and the keyboard in a VBox with a padding label so that they can be reduced in height for stacked-view @@ -186,16 +201,34 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) v->pack_start (*manage (new Label ("")), true, true); v->show (); h->show (); - controls_hbox.pack_start(*v); + controls_hbox.pack_start(*v, false, false); controls_ebox.set_name ("MidiTrackControlsBaseUnselected"); controls_base_selected_name = "MidiTrackControlsBaseSelected"; controls_base_unselected_name = "MidiTrackControlsBaseUnselected"; - midi_view()->NoteRangeChanged.connect (sigc::mem_fun(*this, &MidiTimeAxisView::update_range)); + midi_view()->NoteRangeChanged.connect ( + sigc::mem_fun(*this, &MidiTimeAxisView::update_range)); /* ask for notifications of any new RegionViews */ - _view->RegionViewAdded.connect (sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added)); + _view->RegionViewAdded.connect ( + sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added)); + + midi_track()->PlaybackChannelModeChanged.connect (*this, invalidator (*this), + boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this), + gui_context()); + midi_track()->PlaybackChannelMaskChanged.connect (*this, invalidator (*this), + boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this), + gui_context()); + midi_track()->CaptureChannelModeChanged.connect (*this, invalidator (*this), + boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this), + gui_context()); + midi_track()->CaptureChannelMaskChanged.connect (*this, invalidator (*this), + boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this), + gui_context()); + + playback_channel_mode_changed (); + capture_channel_mode_changed (); if (!_editor.have_idled()) { /* first idle will do what we need */ @@ -204,7 +237,6 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) } } - MIDI::Name::MidiPatchManager& patch_manager = MIDI::Name::MidiPatchManager::instance(); MIDI::Name::MasterDeviceNames::Models::const_iterator m = patch_manager.all_models().begin(); @@ -212,77 +244,106 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) _midnam_model_selector.append_text(m->c_str()); } + if (gui_property (X_("midnam-model-name")).empty()) { + set_gui_property (X_("midnam-model-name"), "Generic"); + } + + if (gui_property (X_("midnam-custom-device-mode")).empty()) { + boost::shared_ptr device_names = get_device_names(); + if (device_names) { + set_gui_property (X_("midnam-custom-device-mode"), + *device_names->custom_device_mode_names().begin()); + } + } + _midnam_model_selector.set_active_text (gui_property (X_("midnam-model-name"))); - model_changed(); _midnam_custom_device_mode_selector.set_active_text (gui_property (X_("midnam-custom-device-mode"))); - _midnam_model_selector.signal_changed().connect(sigc::mem_fun(*this, &MidiTimeAxisView::model_changed)); - _midnam_custom_device_mode_selector.signal_changed().connect( - sigc::mem_fun(*this, &MidiTimeAxisView::custom_device_mode_changed)); - ARDOUR_UI::instance()->set_tip (_midnam_model_selector, _("External MIDI Device")); ARDOUR_UI::instance()->set_tip (_midnam_custom_device_mode_selector, _("External Device Mode")); _midi_controls_box.set_homogeneous(false); _midi_controls_box.set_border_width (10); - if (!patch_manager.all_models().empty()) { - _channel_selector.set_border_width(2); - _midi_controls_box.resize(3, 2); - _midi_controls_box.attach(_channel_selector, 0, 2, 0, 1); - _midi_controls_box.attach(*manage(new HSeparator()), 0, 2, 1, 2); + _channel_status_box.set_homogeneous (false); + _channel_status_box.set_spacing (6); + + _channel_selector_button.set_label (_("Chns")); + ARDOUR_UI::instance()->set_tip (_channel_selector_button, _("Click to edit channel settings")); + + /* fixed sized labels to prevent silly nonsense (though obviously, + * they cause their own too) + */ + + _playback_channel_status.set_size_request (65, -1); + _capture_channel_status.set_size_request (60, -1); + + _channel_status_box.pack_start (_playback_channel_status, false, false); + _channel_status_box.pack_start (_capture_channel_status, false, false); + _channel_status_box.pack_start (_channel_selector_button, false, false); + _channel_status_box.show_all (); + + _channel_selector_button.signal_clicked().connect (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_channel_selector)); + + _midi_controls_box.pack_start (_channel_status_box, false, false, 10); + + if (!patch_manager.all_models().empty()) { _midnam_model_selector.set_size_request(22, 30); _midnam_model_selector.set_border_width(2); - _midi_controls_box.attach(_midnam_model_selector, 0, 1, 2, 3); + _midnam_model_selector.show (); + _midi_controls_box.pack_start (_midnam_model_selector); _midnam_custom_device_mode_selector.set_size_request(10, 30); _midnam_custom_device_mode_selector.set_border_width(2); - _midi_controls_box.attach(_midnam_custom_device_mode_selector, 1, 2, 2, 3); - } else { - _midi_controls_box.attach(_channel_selector, 0, 1, 0, 1); - } + _midnam_custom_device_mode_selector.show (); - controls_vbox.pack_start(_midi_controls_box, false, false); + _midi_controls_box.pack_start (_midnam_custom_device_mode_selector); + } - // restore channel selector settings - _channel_selector.set_channel_mode(midi_track()->get_channel_mode(), midi_track()->get_channel_mask()); - _channel_selector.mode_changed.connect( - sigc::mem_fun(*midi_track(), &MidiTrack::set_channel_mode)); - _channel_selector.mode_changed.connect( - sigc::mem_fun(*this, &MidiTimeAxisView::set_channel_mode)); + model_changed(); + custom_device_mode_changed(); - string prop = gui_property ("color-mode"); - if (!prop.empty()) { - _color_mode = ColorMode (string_2_enum(prop, _color_mode)); - if (_color_mode == ChannelColors) { - _channel_selector.set_channel_colors(CanvasNoteEvent::midi_channel_colors); + _midnam_model_selector.signal_changed().connect( + sigc::mem_fun(*this, &MidiTimeAxisView::model_changed)); + _midnam_custom_device_mode_selector.signal_changed().connect( + sigc::mem_fun(*this, &MidiTimeAxisView::custom_device_mode_changed)); + + controls_vbox.pack_start(_midi_controls_box, false, false); + + const string color_mode = gui_property ("color-mode"); + if (!color_mode.empty()) { + _color_mode = ColorMode (string_2_enum(color_mode, _color_mode)); + if (_channel_selector && _color_mode == ChannelColors) { + _channel_selector->set_channel_colors(CanvasNoteEvent::midi_channel_colors); } } set_color_mode (_color_mode, true, false); - prop = gui_property ("note-mode"); - if (!prop.empty()) { - _note_mode = NoteMode (string_2_enum (prop, _note_mode)); + const string note_mode = gui_property ("note-mode"); + if (!note_mode.empty()) { + _note_mode = NoteMode (string_2_enum (note_mode, _note_mode)); if (_percussion_mode_item) { _percussion_mode_item->set_active (_note_mode == Percussive); } } - /* Look for any GUI object state nodes that represent automation children that should exist, and create - * the children. + /* Look for any GUI object state nodes that represent automation children + * that should exist, and create the children. */ - list gui_ids = gui_object_state().all_ids (); + const list gui_ids = gui_object_state().all_ids (); for (list::const_iterator i = gui_ids.begin(); i != gui_ids.end(); ++i) { PBD::ID route_id; bool has_parameter; Evoral::Parameter parameter (0, 0, 0); - bool const p = AutomationTimeAxisView::parse_state_id (*i, route_id, has_parameter, parameter); + bool const p = AutomationTimeAxisView::parse_state_id ( + *i, route_id, has_parameter, parameter); if (p && route_id == _route->id () && has_parameter) { - create_automation_child (parameter, string_is_affirmative (gui_object_state().get_string (*i, X_("visible")))); + const std::string& visible = gui_object_state().get_string (*i, X_("visible")); + create_automation_child (parameter, string_is_affirmative (visible)); } } } @@ -297,6 +358,8 @@ MidiTimeAxisView::first_idle () MidiTimeAxisView::~MidiTimeAxisView () { + delete _channel_selector; + delete _piano_roll_header; _piano_roll_header = 0; @@ -304,59 +367,68 @@ MidiTimeAxisView::~MidiTimeAxisView () _range_scroomer = 0; delete controller_menu; - delete _step_editor; + delete _step_editor; } void MidiTimeAxisView::enter_internal_edit_mode () { - if (midi_view()) { - midi_view()->enter_internal_edit_mode (); - } + if (midi_view()) { + midi_view()->enter_internal_edit_mode (); + } } void MidiTimeAxisView::leave_internal_edit_mode () { - if (midi_view()) { - midi_view()->leave_internal_edit_mode (); - } + if (midi_view()) { + midi_view()->leave_internal_edit_mode (); + } } void MidiTimeAxisView::check_step_edit () { ensure_step_editor (); - _step_editor->check_step_edit (); + _step_editor->check_step_edit (); } void MidiTimeAxisView::model_changed() { - string model = _midnam_model_selector.get_active_text(); + const Glib::ustring model = _midnam_model_selector.get_active_text(); set_gui_property (X_("midnam-model-name"), model); - std::list device_modes = MIDI::Name::MidiPatchManager::instance() + const std::list device_modes = MIDI::Name::MidiPatchManager::instance() .custom_device_mode_names_by_model(model); _midnam_custom_device_mode_selector.clear_items(); for (std::list::const_iterator i = device_modes.begin(); - i != device_modes.end(); ++i) { + i != device_modes.end(); ++i) { _midnam_custom_device_mode_selector.append_text(*i); } _midnam_custom_device_mode_selector.set_active(0); - _route->instrument_info().set_external_instrument (_midnam_model_selector.get_active_text(), _midnam_custom_device_mode_selector.get_active_text()); + _route->instrument_info().set_external_instrument ( + _midnam_model_selector.get_active_text(), + _midnam_custom_device_mode_selector.get_active_text()); + + // Rebuild controller menu + _controller_menu_map.clear (); + delete controller_menu; + controller_menu = 0; + build_automation_action_menu(false); } void MidiTimeAxisView::custom_device_mode_changed() { - string mode = _midnam_custom_device_mode_selector.get_active_text(); + const Glib::ustring mode = _midnam_custom_device_mode_selector.get_active_text(); set_gui_property (X_("midnam-custom-device-mode"), mode); - _route->instrument_info().set_external_instrument (_midnam_model_selector.get_active_text(), mode); + _route->instrument_info().set_external_instrument ( + _midnam_model_selector.get_active_text(), mode); } MidiStreamView* @@ -369,7 +441,7 @@ void MidiTimeAxisView::set_height (uint32_t h) { if (h >= MIDI_CONTROLS_BOX_MIN_HEIGHT) { - _midi_controls_box.show_all (); + _midi_controls_box.show (); } else { _midi_controls_box.hide(); } @@ -410,20 +482,47 @@ MidiTimeAxisView::append_extra_display_menu_items () MenuList& range_items = range_menu->items(); range_menu->set_name ("ArdourContextMenu"); - range_items.push_back (MenuElem (_("Show Full Range"), sigc::bind ( - sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), - MidiStreamView::FullRange, true))); + range_items.push_back ( + MenuElem (_("Show Full Range"), + sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), + MidiStreamView::FullRange, true))); - range_items.push_back (MenuElem (_("Fit Contents"), sigc::bind ( - sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), - MidiStreamView::ContentsRange, true))); + range_items.push_back ( + MenuElem (_("Fit Contents"), + sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), + MidiStreamView::ContentsRange, true))); items.push_back (MenuElem (_("Note Range"), *range_menu)); items.push_back (MenuElem (_("Note Mode"), *build_note_mode_menu())); + items.push_back (MenuElem (_("Channel Selector"), + sigc::mem_fun(*this, &MidiTimeAxisView::toggle_channel_selector))); + color_mode_menu = build_color_mode_menu(); + if (color_mode_menu) { + items.push_back (MenuElem (_("Color Mode"), *color_mode_menu)); + } + items.push_back (SeparatorElem ()); } +void +MidiTimeAxisView::toggle_channel_selector () +{ + if (!_channel_selector) { + _channel_selector = new MidiChannelSelectorWindow (midi_track()); + + if (_color_mode == ChannelColors) { + _channel_selector->set_channel_colors(CanvasNoteEvent::midi_channel_colors); + } else { + _channel_selector->set_default_channel_color (); + } + + _channel_selector->show_all (); + } else { + _channel_selector->cycle_visibility (); + } +} + void MidiTimeAxisView::build_automation_action_menu (bool for_selection) { @@ -445,44 +544,51 @@ MidiTimeAxisView::build_automation_action_menu (bool for_selection) MenuList& automation_items = automation_action_menu->items(); - uint16_t selected_channels = _channel_selector.get_selected_channels(); + uint16_t selected_channels = midi_track()->get_playback_channel_mask(); if (selected_channels != 0) { automation_items.push_back (SeparatorElem()); - /* these 2 MIDI "command" types are semantically more like automation than note data, - but they are not MIDI controllers. We give them special status in this menu, since - they will not show up in the controller list and anyone who actually knows - something about MIDI (!) would not expect to find them there. + /* these 2 MIDI "command" types are semantically more like automation + than note data, but they are not MIDI controllers. We give them + special status in this menu, since they will not show up in the + controller list and anyone who actually knows something about MIDI + (!) would not expect to find them there. */ - add_channel_command_menu_item (automation_items, _("Bender"), MidiPitchBenderAutomation, 0); - automation_items.back().set_sensitive (!for_selection || _editor.get_selection().tracks.size() == 1); - add_channel_command_menu_item (automation_items, _("Pressure"), MidiChannelPressureAutomation, 0); - automation_items.back().set_sensitive (!for_selection || _editor.get_selection().tracks.size() == 1); - - /* now all MIDI controllers. Always offer the possibility that we will rebuild the controllers menu - since it might need to be updated after a channel mode change or other change. Also detach it - first in case it has been used anywhere else. + add_channel_command_menu_item ( + automation_items, _("Bender"), MidiPitchBenderAutomation, 0); + automation_items.back().set_sensitive ( + !for_selection || _editor.get_selection().tracks.size() == 1); + add_channel_command_menu_item ( + automation_items, _("Pressure"), MidiChannelPressureAutomation, 0); + automation_items.back().set_sensitive ( + !for_selection || _editor.get_selection().tracks.size() == 1); + + /* now all MIDI controllers. Always offer the possibility that we will + rebuild the controllers menu since it might need to be updated after + a channel mode change or other change. Also detach it first in case + it has been used anywhere else. */ build_controller_menu (); automation_items.push_back (SeparatorElem()); automation_items.push_back (MenuElem (_("Controllers"), *controller_menu)); - automation_items.back().set_sensitive (!for_selection || _editor.get_selection().tracks.size() == 1); + automation_items.back().set_sensitive ( + !for_selection || _editor.get_selection().tracks.size() == 1); } else { - automation_items.push_back (MenuElem (string_compose ("%1", _("No MIDI Channels selected")))); + automation_items.push_back ( + MenuElem (string_compose ("%1", _("No MIDI Channels selected")))); dynamic_cast (automation_items.back().get_child())->set_use_markup (true); } - } void MidiTimeAxisView::change_all_channel_tracks_visibility (bool yn, Evoral::Parameter param) { - uint16_t selected_channels = _channel_selector.get_selected_channels(); + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); for (uint8_t chn = 0; chn < 16; chn++) { if (selected_channels & (0x0001 << chn)) { @@ -498,14 +604,18 @@ MidiTimeAxisView::change_all_channel_tracks_visibility (bool yn, Evoral::Paramet } void -MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items, const string& label, AutomationType auto_type, uint8_t cmd) +MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items, + const string& label, + AutomationType auto_type, + uint8_t cmd) { using namespace Menu_Helpers; - /* count the number of selected channels because we will build a different menu structure if there is more than 1 selected. + /* count the number of selected channels because we will build a different menu + structure if there is more than 1 selected. */ - uint16_t selected_channels = _channel_selector.get_selected_channels(); + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); int chn_cnt = 0; for (uint8_t chn = 0; chn < 16; chn++) { @@ -526,12 +636,14 @@ MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items, /* add a couple of items to hide/show all of them */ - chn_items.push_back (MenuElem (_("Hide all channels"), - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility), - false, param_without_channel))); - chn_items.push_back (MenuElem (_("Show all channels"), - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility), - true, param_without_channel))); + chn_items.push_back ( + MenuElem (_("Hide all channels"), + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility), + false, param_without_channel))); + chn_items.push_back ( + MenuElem (_("Show all channels"), + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility), + true, param_without_channel))); for (uint8_t chn = 0; chn < 16; chn++) { if (selected_channels & (0x0001 << chn)) { @@ -539,9 +651,10 @@ MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items, /* for each selected channel, add a menu item for this controller */ Evoral::Parameter fully_qualified_param (auto_type, chn, cmd); - chn_items.push_back (CheckMenuElem (string_compose (_("Channel %1"), chn+1), - sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), - fully_qualified_param))); + chn_items.push_back ( + CheckMenuElem (string_compose (_("Channel %1"), chn+1), + sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), + fully_qualified_param))); boost::shared_ptr track = automation_child (fully_qualified_param); bool visible = false; @@ -570,9 +683,10 @@ MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items, if (selected_channels & (0x0001 << chn)) { Evoral::Parameter fully_qualified_param (auto_type, chn, cmd); - items.push_back (CheckMenuElem (label, - sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), - fully_qualified_param))); + items.push_back ( + CheckMenuElem (label, + sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), + fully_qualified_param))); boost::shared_ptr track = automation_child (fully_qualified_param); bool visible = false; @@ -594,176 +708,240 @@ MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items, } } +/** Add a single menu item for a controller on one channel. */ void -MidiTimeAxisView::build_controller_menu () +MidiTimeAxisView::add_single_channel_controller_item(Menu_Helpers::MenuList& ctl_items, + int ctl, + const std::string& name) { using namespace Menu_Helpers; - if (controller_menu) { - /* it exists and has not been invalidated by a channel mode change, so just return it */ - return; - } - - controller_menu = new Menu; // explicitly managed by us - MenuList& items (controller_menu->items()); - - /* create several "top level" menu items for sets of controllers (16 at a time), and populate each one with a submenu - for each controller+channel combination covering the currently selected channels for this track - */ - - uint16_t selected_channels = _channel_selector.get_selected_channels(); - - /* count the number of selected channels because we will build a different menu structure if there is more than 1 selected. - */ - - int chn_cnt = 0; - + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); for (uint8_t chn = 0; chn < 16; chn++) { if (selected_channels & (0x0001 << chn)) { - if (++chn_cnt > 1) { - break; + + Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl); + ctl_items.push_back ( + CheckMenuElem ( + string_compose ("%1: %2 [%3]", ctl, name, int (chn)), + sigc::bind ( + sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), + fully_qualified_param))); + dynamic_cast (ctl_items.back().get_child())->set_use_markup (true); + + boost::shared_ptr track = automation_child ( + fully_qualified_param); + + bool visible = false; + if (track) { + if (track->marked_for_display()) { + visible = true; + } } - } - } - using namespace MIDI::Name; - const string& model = _midnam_model_selector.get_active_text(); - boost::shared_ptr midnam = MidiPatchManager::instance() - .document_by_model(model); - boost::shared_ptr device_names; - if (midnam && !midnam->master_device_names_by_model().empty()) { - device_names = boost::shared_ptr( - midnam->master_device_names_by_model().begin()->second); - } + CheckMenuItem* cmi = static_cast(&ctl_items.back()); + _controller_menu_map[fully_qualified_param] = cmi; + cmi->set_active (visible); - if (device_names && !device_names->controls().empty()) { - /* Controllers names available from the midnam file, generate a custom controller menu */ - for (MasterDeviceNames::ControlNameLists::const_iterator l = device_names->controls().begin(); - l != device_names->controls().end(); ++l) { - boost::shared_ptr name_list = *l; - - int chn = 0; // TODO - Menu* group_menu = manage(new Menu()); - MenuList& group_items(group_menu->items()); - - for (ControlNameList::Controls::const_iterator c = (*l)->controls().begin(); - c != (*l)->controls().end(); ++c) { - Evoral::Parameter fully_qualified_param(MidiCCAutomation, chn, atoi((*c)->number().c_str())); - group_items.push_back( - CheckMenuElem(string_compose("%1: %2 [%3]", - (*c)->number(), (*c)->name(), int(chn)), - sigc::bind(sigc::mem_fun(*this, &RouteTimeAxisView::toggle_automation_track), - fully_qualified_param))); - dynamic_cast (group_items.back().get_child())->set_use_markup (true); - } - items.push_back(MenuElem(name_list->name(), *group_menu)); + /* one channel only */ + break; } - return; } +} - /* loop over all 127 MIDI controllers, in groups of 16; except don't offer - bank select controllers, as they are handled by the `patch' code */ - - for (int i = 0; i < 127; i += 16) { +/** Add a submenu with 1 item per channel for a controller on many channels. */ +void +MidiTimeAxisView::add_multi_channel_controller_item(Menu_Helpers::MenuList& ctl_items, + int ctl, + const std::string& name) +{ + using namespace Menu_Helpers; - Menu* ctl_menu = manage (new Menu); - MenuList& ctl_items (ctl_menu->items()); + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); + Menu* chn_menu = manage (new Menu); + MenuList& chn_items (chn_menu->items()); - /* for each controller, consider whether to create a submenu or a single item */ + /* add a couple of items to hide/show this controller on all channels */ - for (int ctl = i; ctl < i+16; ++ctl) { + Evoral::Parameter param_without_channel (MidiCCAutomation, 0, ctl); + chn_items.push_back ( + MenuElem (_("Hide all channels"), + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility), + false, param_without_channel))); + chn_items.push_back ( + MenuElem (_("Show all channels"), + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility), + true, param_without_channel))); - if (ctl == MIDI_CTL_MSB_BANK || ctl == MIDI_CTL_LSB_BANK) { - continue; - } + for (uint8_t chn = 0; chn < 16; chn++) { + if (selected_channels & (0x0001 << chn)) { - if (chn_cnt > 1) { + /* for each selected channel, add a menu item for this controller */ - /* multiple channels - create a submenu, with 1 item per channel */ + Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl); + chn_items.push_back ( + CheckMenuElem (string_compose (_("Channel %1"), chn+1), + sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), + fully_qualified_param))); + + boost::shared_ptr track = automation_child ( + fully_qualified_param); + bool visible = false; + + if (track) { + if (track->marked_for_display()) { + visible = true; + } + } - Menu* chn_menu = manage (new Menu); - MenuList& chn_items (chn_menu->items()); + CheckMenuItem* cmi = static_cast(&chn_items.back()); + _controller_menu_map[fully_qualified_param] = cmi; + cmi->set_active (visible); + } + } - /* add a couple of items to hide/show this controller on all channels */ + /* add the per-channel menu to the list of controllers, with the name of the controller */ + ctl_items.push_back (MenuElem (string_compose ("%1: %2", ctl, name), + *chn_menu)); + dynamic_cast (ctl_items.back().get_child())->set_use_markup (true); +} - Evoral::Parameter param_without_channel (MidiCCAutomation, 0, ctl); - chn_items.push_back (MenuElem (_("Hide all channels"), - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility), - false, param_without_channel))); - chn_items.push_back (MenuElem (_("Show all channels"), - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility), - true, param_without_channel))); +boost::shared_ptr +MidiTimeAxisView::get_device_mode() +{ + using namespace MIDI::Name; - for (uint8_t chn = 0; chn < 16; chn++) { - if (selected_channels & (0x0001 << chn)) { + boost::shared_ptr device_names = get_device_names(); + if (!device_names) { + return boost::shared_ptr(); + } - /* for each selected channel, add a menu item for this controller */ + return device_names->custom_device_mode_by_name( + gui_property (X_("midnam-custom-device-mode"))); +} - Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl); - chn_items.push_back (CheckMenuElem (string_compose (_("Channel %1"), chn+1), - sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), - fully_qualified_param))); +boost::shared_ptr +MidiTimeAxisView::get_device_names() +{ + using namespace MIDI::Name; - boost::shared_ptr track = automation_child (fully_qualified_param); - bool visible = false; + const std::string model = gui_property (X_("midnam-model-name")); - if (track) { - if (track->marked_for_display()) { - visible = true; - } - } + boost::shared_ptr midnam = MidiPatchManager::instance() + .document_by_model(model); + if (midnam) { + return midnam->master_device_names(model); + } else { + return boost::shared_ptr(); + } +} - CheckMenuItem* cmi = static_cast(&chn_items.back()); - _controller_menu_map[fully_qualified_param] = cmi; - cmi->set_active (visible); - } - } +void +MidiTimeAxisView::build_controller_menu () +{ + using namespace Menu_Helpers; - /* add the per-channel menu to the list of controllers, with the name of the controller */ - ctl_items.push_back (MenuElem (string_compose ("%1: %2", ctl, midi_name (ctl)), *chn_menu)); - dynamic_cast (ctl_items.back().get_child())->set_use_markup (true); + if (controller_menu) { + /* it exists and has not been invalidated by a channel mode change */ + return; + } - } else { + controller_menu = new Menu; // explicitly managed by us + MenuList& items (controller_menu->items()); - /* just one channel - create a single menu item for this ctl+channel combination*/ + /* create several "top level" menu items for sets of controllers (16 at a + time), and populate each one with a submenu for each controller+channel + combination covering the currently selected channels for this track + */ - for (uint8_t chn = 0; chn < 16; chn++) { - if (selected_channels & (0x0001 << chn)) { + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); - Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl); - ctl_items.push_back ( - CheckMenuElem ( - string_compose ("%1: %2 [%3]", ctl, midi_name (ctl), int (chn)), - sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), - fully_qualified_param) - ) - ); - dynamic_cast (ctl_items.back().get_child())->set_use_markup (true); + /* count the number of selected channels because we will build a different menu + structure if there is more than 1 selected. + */ - boost::shared_ptr track = automation_child (fully_qualified_param); - bool visible = false; + int chn_cnt = 0; + for (uint8_t chn = 0; chn < 16; chn++) { + if (selected_channels & (0x0001 << chn)) { + if (++chn_cnt > 1) { + break; + } + } + } - if (track) { - if (track->marked_for_display()) { - visible = true; - } - } + using namespace MIDI::Name; + boost::shared_ptr device_names = get_device_names(); - CheckMenuItem* cmi = static_cast(&ctl_items.back()); - _controller_menu_map[fully_qualified_param] = cmi; - cmi->set_active (visible); + if (device_names && !device_names->controls().empty()) { + /* Controllers names available in midnam file, generate fancy menu */ + unsigned n_items = 0; + unsigned n_groups = 0; - /* one channel only */ - break; + /* TODO: This is not correct, should look up the currently applicable ControlNameList + and only build a menu for that one. */ + for (MasterDeviceNames::ControlNameLists::const_iterator l = device_names->controls().begin(); + l != device_names->controls().end(); ++l) { + boost::shared_ptr name_list = l->second; + Menu* ctl_menu = NULL; + + for (ControlNameList::Controls::const_iterator c = name_list->controls().begin(); + c != name_list->controls().end();) { + const uint16_t ctl = c->second->number(); + if (ctl != MIDI_CTL_MSB_BANK && ctl != MIDI_CTL_LSB_BANK) { + /* Skip bank select controllers since they're handled specially */ + if (n_items == 0) { + /* Create a new submenu */ + ctl_menu = manage (new Menu); + } + + MenuList& ctl_items (ctl_menu->items()); + if (chn_cnt > 1) { + add_multi_channel_controller_item(ctl_items, ctl, c->second->name()); + } else { + add_single_channel_controller_item(ctl_items, ctl, c->second->name()); } } + + ++c; + if (ctl_menu && (++n_items == 16 || c == name_list->controls().end())) { + /* Submenu has 16 items or we're done, add it to controller menu and reset */ + items.push_back( + MenuElem(string_compose(_("Controllers %1-%2"), + (16 * n_groups), (16 * n_groups) + n_items - 1), + *ctl_menu)); + ctl_menu = NULL; + n_items = 0; + ++n_groups; + } } } + } else { + /* No controllers names, generate generic numeric menu */ + for (int i = 0; i < 127; i += 16) { + Menu* ctl_menu = manage (new Menu); + MenuList& ctl_items (ctl_menu->items()); + + for (int ctl = i; ctl < i+16; ++ctl) { + if (ctl == MIDI_CTL_MSB_BANK || ctl == MIDI_CTL_LSB_BANK) { + /* Skip bank select controllers since they're handled specially */ + continue; + } - /* add the menu for this block of controllers to the overall controller menu */ + if (chn_cnt > 1) { + add_multi_channel_controller_item( + ctl_items, ctl, string_compose(_("Controller %1"), ctl)); + } else { + add_single_channel_controller_item( + ctl_items, ctl, string_compose(_("Controller %1"), ctl)); + } + } - items.push_back (MenuElem (string_compose (_("Controllers %1-%2"), i, i+15), *ctl_menu)); + /* Add submenu for this block of controllers to controller menu */ + items.push_back ( + MenuElem (string_compose (_("Controllers %1-%2"), i, i + 15), + *ctl_menu)); + } } } @@ -777,13 +955,17 @@ MidiTimeAxisView::build_note_mode_menu() mode_menu->set_name ("ArdourContextMenu"); RadioMenuItem::Group mode_group; - items.push_back (RadioMenuElem (mode_group,_("Sustained"), - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_mode), Sustained, true))); + items.push_back ( + RadioMenuElem (mode_group,_("Sustained"), + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_mode), + Sustained, true))); _note_mode_item = dynamic_cast(&items.back()); _note_mode_item->set_active(_note_mode == Sustained); - items.push_back (RadioMenuElem (mode_group, _("Percussive"), - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_mode), Percussive, true))); + items.push_back ( + RadioMenuElem (mode_group, _("Percussive"), + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_mode), + Percussive, true))); _percussion_mode_item = dynamic_cast(&items.back()); _percussion_mode_item->set_active(_note_mode == Percussive); @@ -800,21 +982,24 @@ MidiTimeAxisView::build_color_mode_menu() mode_menu->set_name ("ArdourContextMenu"); RadioMenuItem::Group mode_group; - items.push_back (RadioMenuElem (mode_group, _("Meter Colors"), - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode), - MeterColors, false, true, true))); + items.push_back ( + RadioMenuElem (mode_group, _("Meter Colors"), + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode), + MeterColors, false, true, true))); _meter_color_mode_item = dynamic_cast(&items.back()); _meter_color_mode_item->set_active(_color_mode == MeterColors); - items.push_back (RadioMenuElem (mode_group, _("Channel Colors"), - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode), - ChannelColors, false, true, true))); + items.push_back ( + RadioMenuElem (mode_group, _("Channel Colors"), + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode), + ChannelColors, false, true, true))); _channel_color_mode_item = dynamic_cast(&items.back()); _channel_color_mode_item->set_active(_color_mode == ChannelColors); - items.push_back (RadioMenuElem (mode_group, _("Track Color"), - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode), - TrackColor, false, true, true))); + items.push_back ( + RadioMenuElem (mode_group, _("Track Color"), + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode), + TrackColor, false, true, true))); _channel_color_mode_item = dynamic_cast(&items.back()); _channel_color_mode_item->set_active(_color_mode == TrackColor); @@ -825,7 +1010,8 @@ void MidiTimeAxisView::set_note_mode(NoteMode mode, bool apply_to_selection) { if (apply_to_selection) { - _editor.get_selection().tracks.foreach_midi_time_axis (boost::bind (&MidiTimeAxisView::set_note_mode, _1, mode, false)); + _editor.get_selection().tracks.foreach_midi_time_axis ( + boost::bind (&MidiTimeAxisView::set_note_mode, _1, mode, false)); } else { if (_note_mode != mode || midi_track()->note_mode() != mode) { _note_mode = mode; @@ -841,18 +1027,18 @@ MidiTimeAxisView::set_color_mode (ColorMode mode, bool force, bool redisplay, bo { if (apply_to_selection) { _editor.get_selection().tracks.foreach_midi_time_axis ( - boost::bind (&MidiTimeAxisView::set_color_mode, _1, mode, force, redisplay, false) - ); + boost::bind (&MidiTimeAxisView::set_color_mode, _1, mode, force, redisplay, false)); } else { - if (_color_mode == mode && !force) { return; } - if (mode == ChannelColors) { - _channel_selector.set_channel_colors(CanvasNoteEvent::midi_channel_colors); - } else { - _channel_selector.set_default_channel_color(); + if (_channel_selector) { + if (mode == ChannelColors) { + _channel_selector->set_channel_colors(CanvasNoteEvent::midi_channel_colors); + } else { + _channel_selector->set_default_channel_color(); + } } _color_mode = mode; @@ -868,8 +1054,7 @@ MidiTimeAxisView::set_note_range (MidiStreamView::VisibleNoteRange range, bool a { if (apply_to_selection) { _editor.get_selection().tracks.foreach_midi_time_axis ( - boost::bind (&MidiTimeAxisView::set_note_range, _1, range, false) - ); + boost::bind (&MidiTimeAxisView::set_note_range, _1, range, false)); } else { if (!_ignore_signals) { midi_view()->set_note_range(range); @@ -882,7 +1067,7 @@ MidiTimeAxisView::update_range() { MidiGhostRegion* mgr; - for(list::iterator i = ghosts.begin(); i != ghosts.end(); ++i) { + for (list::iterator i = ghosts.begin(); i != ghosts.end(); ++i) { if ((mgr = dynamic_cast(*i)) != 0) { mgr->update_range(); } @@ -893,7 +1078,8 @@ void MidiTimeAxisView::show_all_automation (bool apply_to_selection) { if (apply_to_selection) { - _editor.get_selection().tracks.foreach_midi_time_axis (boost::bind (&MidiTimeAxisView::show_all_automation, _1, false)); + _editor.get_selection().tracks.foreach_midi_time_axis ( + boost::bind (&MidiTimeAxisView::show_all_automation, _1, false)); } else { if (midi_track()) { const set params = midi_track()->midi_playlist()->contained_automation(); @@ -911,7 +1097,8 @@ void MidiTimeAxisView::show_existing_automation (bool apply_to_selection) { if (apply_to_selection) { - _editor.get_selection().tracks.foreach_midi_time_axis (boost::bind (&MidiTimeAxisView::show_existing_automation, _1, false)); + _editor.get_selection().tracks.foreach_midi_time_axis ( + boost::bind (&MidiTimeAxisView::show_existing_automation, _1, false)); } else { if (midi_track()) { const set params = midi_track()->midi_playlist()->contained_automation(); @@ -974,27 +1161,28 @@ MidiTimeAxisView::create_automation_child (const Evoral::Parameter& param, bool */ track.reset (new AutomationTimeAxisView ( - _session, - _route, - boost::shared_ptr (), - boost::shared_ptr (), - param, - _editor, - *this, - true, - parent_canvas, - _route->describe_parameter(param) - )); + _session, + _route, + boost::shared_ptr (), + boost::shared_ptr (), + param, + _editor, + *this, + true, + parent_canvas, + _route->describe_parameter(param))); if (_view) { - _view->foreach_regionview (sigc::mem_fun (*track.get(), &TimeAxisView::add_ghost)); + _view->foreach_regionview ( + sigc::mem_fun (*track.get(), &TimeAxisView::add_ghost)); } add_automation_child (param, track, show); break; default: - error << "MidiTimeAxisView: unknown automation child " << EventTypeMap::instance().to_symbol(param) << endmsg; + error << "MidiTimeAxisView: unknown automation child " + << EventTypeMap::instance().to_symbol(param) << endmsg; } } @@ -1014,9 +1202,6 @@ MidiTimeAxisView::route_active_changed () controls_base_unselected_name = "MidiTrackControlsBaseInactiveUnselected"; } } else { - - throw; // wha? - if (_route->active()) { controls_ebox.set_name ("BusControlsBaseUnselected"); controls_base_selected_name = "BusControlsBaseSelected"; @@ -1036,12 +1221,16 @@ MidiTimeAxisView::set_note_selection (uint8_t note) return; } - uint16_t chn_mask = _channel_selector.get_selected_channels(); + uint16_t chn_mask = midi_track()->get_playback_channel_mask(); if (_view->num_selected_regionviews() == 0) { - _view->foreach_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection_region_view), note, chn_mask)); + _view->foreach_regionview ( + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection_region_view), + note, chn_mask)); } else { - _view->foreach_selected_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection_region_view), note, chn_mask)); + _view->foreach_selected_regionview ( + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection_region_view), + note, chn_mask)); } } @@ -1052,12 +1241,16 @@ MidiTimeAxisView::add_note_selection (uint8_t note) return; } - uint16_t chn_mask = _channel_selector.get_selected_channels(); + const uint16_t chn_mask = midi_track()->get_playback_channel_mask(); if (_view->num_selected_regionviews() == 0) { - _view->foreach_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection_region_view), note, chn_mask)); + _view->foreach_regionview ( + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection_region_view), + note, chn_mask)); } else { - _view->foreach_selected_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection_region_view), note, chn_mask)); + _view->foreach_selected_regionview ( + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection_region_view), + note, chn_mask)); } } @@ -1068,12 +1261,16 @@ MidiTimeAxisView::extend_note_selection (uint8_t note) return; } - uint16_t chn_mask = _channel_selector.get_selected_channels(); + const uint16_t chn_mask = midi_track()->get_playback_channel_mask(); if (_view->num_selected_regionviews() == 0) { - _view->foreach_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection_region_view), note, chn_mask)); + _view->foreach_regionview ( + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection_region_view), + note, chn_mask)); } else { - _view->foreach_selected_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection_region_view), note, chn_mask)); + _view->foreach_selected_regionview ( + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection_region_view), + note, chn_mask)); } } @@ -1084,12 +1281,16 @@ MidiTimeAxisView::toggle_note_selection (uint8_t note) return; } - uint16_t chn_mask = _channel_selector.get_selected_channels(); + const uint16_t chn_mask = midi_track()->get_playback_channel_mask(); if (_view->num_selected_regionviews() == 0) { - _view->foreach_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection_region_view), note, chn_mask)); + _view->foreach_regionview ( + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection_region_view), + note, chn_mask)); } else { - _view->foreach_selected_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection_region_view), note, chn_mask)); + _view->foreach_selected_regionview ( + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection_region_view), + note, chn_mask)); } } @@ -1124,7 +1325,7 @@ MidiTimeAxisView::set_channel_mode (ChannelMode, uint16_t) the right ones. */ - uint16_t selected_channels = _channel_selector.get_selected_channels(); + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); bool changed = false; no_redraw = true; @@ -1142,7 +1343,7 @@ MidiTimeAxisView::set_channel_mode (ChannelMode, uint16_t) if ((selected_channels & (0x0001 << chn)) == 0) { /* channel not in use. hiding it will trigger RouteTimeAxisView::automation_track_hidden() which will cause a redraw. We don't want one per channel, so block that with no_redraw. - */ + */ changed = track->set_marked_for_display (false) || changed; } else { changed = track->set_marked_for_display (true) || changed; @@ -1191,12 +1392,12 @@ MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit) Editor* real_editor = dynamic_cast (&_editor); real_editor->begin_reversible_command (Operations::create_region); - playlist()->clear_changes (); + playlist()->clear_changes (); real_editor->snap_to (pos, 0); - boost::shared_ptr src = _session->create_midi_source_for_session (view()->trackview().track().get(), - view()->trackview().track()->name()); + boost::shared_ptr src = _session->create_midi_source_for_session ( + view()->trackview().track().get(), view()->trackview().track()->name()); PropertyList plist; plist.add (ARDOUR::Properties::start, 0); @@ -1227,25 +1428,24 @@ void MidiTimeAxisView::start_step_editing () { ensure_step_editor (); - _step_editor->start_step_editing (); + _step_editor->start_step_editing (); } void MidiTimeAxisView::stop_step_editing () { - if (_step_editor) { - _step_editor->stop_step_editing (); - } + if (_step_editor) { + _step_editor->stop_step_editing (); + } } - /** @return channel (counted from 0) to add an event to, based on the current setting * of the channel selector. */ uint8_t MidiTimeAxisView::get_channel_for_add () const { - uint16_t const chn_mask = _channel_selector.get_selected_channels (); + uint16_t const chn_mask = midi_track()->get_playback_channel_mask(); int chn_cnt = 0; uint8_t channel = 0; @@ -1279,3 +1479,35 @@ MidiTimeAxisView::contents_height_changed () { _range_scroomer->set_size_request (-1, _view->child_height ()); } + +void +MidiTimeAxisView::playback_channel_mode_changed () +{ + switch (midi_track()->get_playback_channel_mode()) { + case AllChannels: + _playback_channel_status.set_markup (string_compose ("%1: %2", _("Play"), _("all"))); + break; + case FilterChannels: + _playback_channel_status.set_markup (string_compose ("%1: %2", _("Play"), _("some"))); + break; + case ForceChannel: + _playback_channel_status.set_markup (string_compose ("%1: %2>%3", _("Play"), _("all"), ffs (midi_track()->get_playback_channel_mask()))); + break; + } +} + +void +MidiTimeAxisView::capture_channel_mode_changed () +{ + switch (midi_track()->get_capture_channel_mode()) { + case AllChannels: + _capture_channel_status.set_markup (string_compose ("%1: %2", _("Rec"), _("all"))); + break; + case FilterChannels: + _capture_channel_status.set_markup (string_compose ("%1: %2", _("Rec"), _("some"))); + break; + case ForceChannel: + _capture_channel_status.set_markup (string_compose ("%1: %2>%3", _("Rec"), _("all"), ffs (midi_track()->get_capture_channel_mask()))); + break; + } +}