X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fmidi_time_axis.cc;h=b1068e7e3f5ea2353c40b1c27d462c9907da0502;hb=965a9740835a77cc2bf9e6cea237e56ae41150d8;hp=c8c34e436934045f041f0a97035060d53dee4f19;hpb=8687895abba4209a6de8d8a8fc1bda5996f0d875;p=ardour.git diff --git a/gtk2_ardour/midi_time_axis.cc b/gtk2_ardour/midi_time_axis.cc index c8c34e4369..b1068e7e3f 100644 --- a/gtk2_ardour/midi_time_axis.cc +++ b/gtk2_ardour/midi_time_axis.cc @@ -31,13 +31,14 @@ #include "pbd/basename.h" #include "pbd/enumwriter.h" #include "pbd/memento_command.h" +#include "pbd/stateful_diff_command.h" -#include -#include -#include -#include -#include +#include "gtkmm2ext/gtk_ui.h" +#include "gtkmm2ext/selector.h" +#include "gtkmm2ext/bindable_button.h" +#include "gtkmm2ext/utils.h" +#include "ardour/file_source.h" #include "ardour/midi_playlist.h" #include "ardour/midi_diskstream.h" #include "ardour/midi_patch_manager.h" @@ -51,6 +52,9 @@ #include "ardour/session_playlist.h" #include "ardour/tempo.h" #include "ardour/utils.h" +#include "ardour/operations.h" + +#include "midi++/names.h" #include "add_midi_cc_track_dialog.h" #include "ardour_ui.h" @@ -77,6 +81,7 @@ #include "region_view.h" #include "rgb_macros.h" #include "selection.h" +#include "step_editor.h" #include "simplerect.h" #include "utils.h" @@ -87,13 +92,14 @@ using namespace ARDOUR; using namespace PBD; using namespace Gtk; +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; -MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session& sess, +MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session* sess, boost::shared_ptr rt, Canvas& canvas) : AxisView(sess) // virtually inherited , RouteTimeAxisView(ed, sess, rt, canvas) @@ -110,18 +116,18 @@ MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session& sess, , _step_edit_item (0) , _midi_thru_item (0) , default_channel_menu (0) + , controller_menu (0) + , _step_editor (0) { subplugin_menu.set_name ("ArdourContextMenu"); _view = new MidiStreamView (*this); ignore_toggle = false; - + mute_button->set_active (false); solo_button->set_active (false); - step_edit_insert_position = 0; - if (is_midi_track()) { controls_ebox.set_name ("MidiTimeAxisViewControlsBaseUnselected"); _note_mode = midi_track()->note_mode(); @@ -137,10 +143,15 @@ MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session& sess, set_state (*xml_node, Stateful::loading_state_version); - _route->processors_changed.connect (sigc::mem_fun(*this, &MidiTimeAxisView::processors_changed)); + _route->processors_changed.connect (*this, invalidator (*this), ui_bind (&MidiTimeAxisView::processors_changed, this, _1), gui_context()); if (is_track()) { _piano_roll_header = new PianoRollHeader(*midi_view()); + + _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)); + _range_scroomer = new MidiScroomer(midi_view()->note_range_adjustment); controls_hbox.pack_start(*_range_scroomer); @@ -154,7 +165,12 @@ MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session& sess, /* ask for notifications of any new RegionViews */ _view->RegionViewAdded.connect (sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added)); - _view->attach (); + + if (!_editor.have_idled()) { + /* first idle will do what we need */ + } else { + first_idle (); + } } HBox* midi_controls_hbox = manage(new HBox()); @@ -185,13 +201,12 @@ MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session& sess, controls_vbox.pack_start(_midi_controls_box, false, false); - boost::shared_ptr diskstream = midi_track()->midi_diskstream(); - // restore channel selector settings - _channel_selector.set_channel_mode(diskstream->get_channel_mode(), - diskstream->get_channel_mask()); + _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()->midi_diskstream(), &MidiDiskstream::set_channel_mode)); + sigc::mem_fun(*midi_track(), &MidiTrack::set_channel_mode)); + _channel_selector.mode_changed.connect( + sigc::mem_fun(*this, &MidiTimeAxisView::set_channel_mode)); XMLProperty *prop; if ((prop = xml_node->property ("color-mode")) != 0) { @@ -209,6 +224,14 @@ MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session& sess, } } +void +MidiTimeAxisView::first_idle () +{ + if (is_track ()) { + _view->attach (); + } +} + MidiTimeAxisView::~MidiTimeAxisView () { delete _piano_roll_header; @@ -216,9 +239,36 @@ MidiTimeAxisView::~MidiTimeAxisView () delete _range_scroomer; _range_scroomer = 0; + + delete controller_menu; + delete _step_editor; +} + +void +MidiTimeAxisView::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 (); + } +} + +void +MidiTimeAxisView::check_step_edit () +{ + ensure_step_editor (); + _step_editor->check_step_edit (); } -void MidiTimeAxisView::model_changed() +void +MidiTimeAxisView::model_changed() { std::list device_modes = MIDI::Name::MidiPatchManager::instance() .custom_device_mode_names_by_model(_model_selector.get_active_text()); @@ -271,7 +321,7 @@ MidiTimeAxisView::set_height (uint32_t h) RouteTimeAxisView::set_height (h); if (height >= MIDI_CONTROLS_BOX_MIN_HEIGHT) { - _midi_controls_box.show(); + _midi_controls_box.show_all (); } else { _midi_controls_box.hide(); } @@ -315,6 +365,8 @@ MidiTimeAxisView::append_extra_display_menu_items () items.push_back (CheckMenuElem (_("MIDI Thru"), sigc::mem_fun(*this, &MidiTimeAxisView::toggle_midi_thru))); _midi_thru_item = dynamic_cast(&items.back()); + + items.push_back (SeparatorElem ()); } Gtk::Menu* @@ -322,9 +374,7 @@ MidiTimeAxisView::build_def_channel_menu () { using namespace Menu_Helpers; - if (default_channel_menu == 0) { - default_channel_menu = manage (new Menu ()); - } + default_channel_menu = manage (new Menu ()); uint8_t defchn = midi_track()->default_channel(); MenuList& def_channel_items = default_channel_menu->items(); @@ -368,22 +418,304 @@ MidiTimeAxisView::build_automation_action_menu () { using namespace Menu_Helpers; + /* If we have a controller menu, we need to detach it before + RouteTimeAxis::build_automation_action_menu destroys the + menu it is attached to. Otherwise GTK destroys + controller_menu's gobj, meaning that it can't be reattached + below. See bug #3134. + */ + + if (controller_menu) { + detach_menu (*controller_menu); + } + + _channel_command_menu_map.clear (); RouteTimeAxisView::build_automation_action_menu (); MenuList& automation_items = automation_action_menu->items(); + + uint16_t selected_channels = _channel_selector.get_selected_channels(); + + 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. + */ + + add_channel_command_menu_item (automation_items, _("Bender"), MidiPitchBenderAutomation, 0); + add_channel_command_menu_item (automation_items, _("Pressure"), MidiChannelPressureAutomation, 0); + + /* 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)); + } else { + 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(); + + for (uint8_t chn = 0; chn < 16; chn++) { + if (selected_channels & (0x0001 << chn)) { + + Evoral::Parameter fully_qualified_param (param.type(), chn, param.id()); + Gtk::CheckMenuItem* menu = automation_child_menu_item (fully_qualified_param); + + if (menu) { + menu->set_active (yn); + } + } + } +} + +void +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. + */ + + uint16_t selected_channels = _channel_selector.get_selected_channels(); + int chn_cnt = 0; + + for (uint8_t chn = 0; chn < 16; chn++) { + if (selected_channels & (0x0001 << chn)) { + if (++chn_cnt > 1) { + break; + } + } + } + + if (chn_cnt > 1) { + + /* multiple channels - create a submenu, with 1 item per channel */ + + Menu* chn_menu = manage (new Menu); + MenuList& chn_items (chn_menu->items()); + Evoral::Parameter param_without_channel (auto_type, 0, cmd); + + /* 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))); + + for (uint8_t chn = 0; chn < 16; chn++) { + if (selected_channels & (0x0001 << chn)) { + + /* 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))); + + boost::shared_ptr track = automation_child (fully_qualified_param); + bool visible = false; + + if (track) { + if (track->marked_for_display()) { + visible = true; + } + } + + CheckMenuItem* cmi = static_cast(&chn_items.back()); + _channel_command_menu_map[fully_qualified_param] = cmi; + cmi->set_active (visible); + } + } + + /* now create an item in the parent menu that has the per-channel list as a submenu */ + + items.push_back (MenuElem (label, *chn_menu)); + + } else { + + /* just one channel - create a single menu item for this command+channel combination*/ + + for (uint8_t chn = 0; chn < 16; chn++) { + 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))); + + boost::shared_ptr track = automation_child (fully_qualified_param); + bool visible = false; + + if (track) { + if (track->marked_for_display()) { + visible = true; + } + } + + CheckMenuItem* cmi = static_cast(&items.back()); + _channel_command_menu_map[fully_qualified_param] = cmi; + cmi->set_active (visible); + + /* one channel only */ + break; + } + } + } +} + +void +MidiTimeAxisView::build_controller_menu () +{ + 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; + + for (uint8_t chn = 0; chn < 16; chn++) { + if (selected_channels & (0x0001 << chn)) { + if (++chn_cnt > 1) { + break; + } + } + } + + /* 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) { - automation_items.push_back (SeparatorElem()); - automation_items.push_back (MenuElem (_("Controller..."), - sigc::mem_fun(*this, &MidiTimeAxisView::add_cc_track))); - automation_items.push_back (MenuElem (_("Program Change"), - sigc::bind(sigc::mem_fun(*this, &MidiTimeAxisView::add_parameter_track), - Evoral::Parameter(MidiPgmChangeAutomation)))); - automation_items.push_back (MenuElem (_("Bender"), - sigc::bind(sigc::mem_fun(*this, &MidiTimeAxisView::add_parameter_track), - Evoral::Parameter(MidiPitchBenderAutomation)))); - automation_items.push_back (MenuElem (_("Pressure"), - sigc::bind(sigc::mem_fun(*this, &MidiTimeAxisView::add_parameter_track), - Evoral::Parameter(MidiChannelPressureAutomation)))); + Menu* ctl_menu = manage (new Menu); + MenuList& ctl_items (ctl_menu->items()); + + + /* for each controller, consider whether to create a submenu or a single item */ + + for (int ctl = i; ctl < i+16; ++ctl) { + + if (ctl == MIDI_CTL_MSB_BANK || ctl == MIDI_CTL_LSB_BANK) { + continue; + } + + if (chn_cnt > 1) { + + /* multiple channels - create a submenu, with 1 item per channel */ + + Menu* chn_menu = manage (new Menu); + MenuList& chn_items (chn_menu->items()); + + /* add a couple of items to hide/show this controller on all channels */ + + 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))); + + for (uint8_t chn = 0; chn < 16; chn++) { + if (selected_channels & (0x0001 << chn)) { + + /* for each selected channel, add a menu item for this controller */ + + 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; + } + } + + CheckMenuItem* cmi = static_cast(&chn_items.back()); + _controller_menu_map[fully_qualified_param] = cmi; + cmi->set_active (visible); + } + } + + /* 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); + + } else { + + /* just one channel - create a single menu item for this ctl+channel combination*/ + + for (uint8_t chn = 0; chn < 16; chn++) { + if (selected_channels & (0x0001 << chn)) { + + 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); + + boost::shared_ptr track = automation_child (fully_qualified_param); + bool visible = false; + + if (track) { + if (track->marked_for_display()) { + visible = true; + } + } + + CheckMenuItem* cmi = static_cast(&ctl_items.back()); + _controller_menu_map[fully_qualified_param] = cmi; + cmi->set_active (visible); + + /* one channel only */ + break; + } + } + } + } + + /* add the menu for this block of controllers to the overall controller menu */ + + items.push_back (MenuElem (string_compose (_("Controllers %1-%2"), i, i+15), *ctl_menu)); + } } Gtk::Menu* @@ -444,7 +776,7 @@ MidiTimeAxisView::set_note_mode(NoteMode mode) _note_mode = mode; midi_track()->set_note_mode(mode); xml_node->add_property ("note-mode", enum_2_string(_note_mode)); - _view->redisplay_diskstream(); + _view->redisplay_track(); } } @@ -460,7 +792,7 @@ MidiTimeAxisView::set_color_mode(ColorMode mode) _color_mode = mode; xml_node->add_property ("color-mode", enum_2_string(_color_mode)); - _view->redisplay_diskstream(); + _view->redisplay_track(); } } @@ -488,8 +820,7 @@ void MidiTimeAxisView::show_all_automation () { if (midi_track()) { - const set params = midi_track()->midi_diskstream()-> - midi_playlist()->contained_automation(); + const set params = midi_track()->midi_playlist()->contained_automation(); for (set::const_iterator i = params.begin(); i != params.end(); ++i) { create_automation_child(*i, true); @@ -503,8 +834,7 @@ void MidiTimeAxisView::show_existing_automation () { if (midi_track()) { - const set params = midi_track()->midi_diskstream()-> - midi_playlist()->contained_automation(); + const set params = midi_track()->midi_playlist()->contained_automation(); for (set::const_iterator i = params.begin(); i != params.end(); ++i) { create_automation_child(*i, true); @@ -514,78 +844,49 @@ MidiTimeAxisView::show_existing_automation () RouteTimeAxisView::show_existing_automation (); } -/** Prompt for a controller with a dialog and add an automation track for it +/** Create an automation track for the given parameter (pitch bend, channel pressure). */ -void -MidiTimeAxisView::add_cc_track() -{ - int response; - Evoral::Parameter param(0, 0, 0); - - { - AddMidiCCTrackDialog dialog; - dialog.set_transient_for (_editor); - response = dialog.run(); - - if (response == Gtk::RESPONSE_ACCEPT) - param = dialog.parameter(); - } - - if (param.type() != 0 && response == Gtk::RESPONSE_ACCEPT) - create_automation_child(param, true); -} - - -/** Add an automation track for the given parameter (pitch bend, channel pressure). - */ -void -MidiTimeAxisView::add_parameter_track(const Evoral::Parameter& param) -{ - if ( !EventTypeMap::instance().is_midi_parameter(param) ) { - error << "MidiTimeAxisView: unknown automation child " - << ARDOUR::EventTypeMap::instance().to_symbol(param) << endmsg; - return; - } - - // create the parameter lane for each selected channel - uint16_t selected_channels = _channel_selector.get_selected_channels(); - - for (uint8_t i = 0; i < 16; i++) { - if (selected_channels & (0x0001 << i)) { - Evoral::Parameter param_with_channel(param.type(), i, param.id()); - create_automation_child(param_with_channel, true); - } - } -} - void MidiTimeAxisView::create_automation_child (const Evoral::Parameter& param, bool show) { - /* These controllers are region "automation", so we do not create - * an AutomationList/Line for the track */ - if (param.type() == NullAutomation) { cerr << "WARNING: Attempt to create NullAutomation child, ignoring" << endl; return; } - - AutomationTracks::iterator existing = _automation_tracks.find(param); - if (existing != _automation_tracks.end()) + + AutomationTracks::iterator existing = _automation_tracks.find (param); + if (existing != _automation_tracks.end()) { return; - - boost::shared_ptr c = _route->get_control (param); - - assert(c); - - boost::shared_ptr track(new AutomationTimeAxisView (_session, - _route, boost::shared_ptr(), c, - _editor, - *this, - true, - parent_canvas, - _route->describe_parameter(param))); - - add_automation_child(param, track, show); + } + + if (param.type() == GainAutomation) { + create_gain_automation_child (param, show); + } else { + + /* These controllers are region "automation", so we do not create + * an AutomationList/Line for the track */ + + boost::shared_ptr track ( + new AutomationTimeAxisView ( + _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)); + } + + add_automation_child (param, track, show); + } } @@ -620,121 +921,191 @@ MidiTimeAxisView::route_active_changed () } } + + void -MidiTimeAxisView::start_step_editing () +MidiTimeAxisView::add_note_selection (uint8_t note) { - step_edit_insert_position = _editor.get_preferred_edit_position (); - step_edit_beat_pos = 0; - step_edit_region = playlist()->top_region_at (step_edit_insert_position); + if (!_editor.internal_editing()) { + return; + } - if (step_edit_region) { - RegionView* rv = view()->find_view (step_edit_region); - step_edit_region_view = dynamic_cast (rv); + uint16_t chn_mask = _channel_selector.get_selected_channels(); + + if (_view->num_selected_regionviews() == 0) { + _view->foreach_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection_region_view), note, chn_mask)); } else { - step_edit_region_view = 0; + _view->foreach_selected_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection_region_view), note, chn_mask)); } - - midi_track()->set_step_editing (true); } void -MidiTimeAxisView::stop_step_editing () +MidiTimeAxisView::extend_note_selection (uint8_t note) { - midi_track()->set_step_editing (false); + if (!_editor.internal_editing()) { + return; + } + + uint16_t chn_mask = _channel_selector.get_selected_channels(); + + if (_view->num_selected_regionviews() == 0) { + _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)); + } } void -MidiTimeAxisView::check_step_edit () +MidiTimeAxisView::toggle_note_selection (uint8_t note) { - MidiRingBuffer& incoming (midi_track()->step_edit_ring_buffer()); - Evoral::Note note; - uint8_t* buf; - uint32_t bufsize = 32; - - buf = new uint8_t[bufsize]; - - while (incoming.read_space()) { - nframes_t time; - Evoral::EventType type; - uint32_t size; + if (!_editor.internal_editing()) { + return; + } - incoming.read_prefix (&time, &type, &size); + uint16_t chn_mask = _channel_selector.get_selected_channels(); - if (size > bufsize) { - delete [] buf; - bufsize = size; - buf = new uint8_t[bufsize]; - } + if (_view->num_selected_regionviews() == 0) { + _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)); + } +} - incoming.read_contents (size, buf); +void +MidiTimeAxisView::add_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask) +{ + dynamic_cast(rv)->select_matching_notes (note, chn_mask, false, false); +} - if ((buf[0] & 0xf0) == MIDI_CMD_NOTE_ON) { +void +MidiTimeAxisView::extend_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask) +{ + dynamic_cast(rv)->select_matching_notes (note, chn_mask, true, true); +} - if (step_edit_region == 0) { +void +MidiTimeAxisView::toggle_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask) +{ + dynamic_cast(rv)->toggle_matching_notes (note, chn_mask); +} - step_edit_region = add_region (step_edit_insert_position); - RegionView* rv = view()->find_view (step_edit_region); +void +MidiTimeAxisView::set_channel_mode (ChannelMode, uint16_t) +{ + /* hide all automation tracks that use the wrong channel(s) and show all those that use + the right ones. + */ - if (rv) { - step_edit_region_view = dynamic_cast(rv); - } else { - fatal << X_("programming error: no view found for new MIDI region") << endmsg; - /*NOTREACHED*/ - } - } + uint16_t selected_channels = _channel_selector.get_selected_channels(); + bool changed = false; - if (step_edit_region_view) { + no_redraw = true; - bool success; - Evoral::MusicalTime beats = _editor.get_grid_type_as_beats (success, step_edit_insert_position); + for (uint32_t ctl = 0; ctl < 127; ++ctl) { - if (!success) { - continue; - } + for (uint32_t chn = 0; chn < 16; ++chn) { + Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl); + boost::shared_ptr track = automation_child (fully_qualified_param); - step_edit_region_view->add_note (buf[0] & 0xf, buf[1], buf[2], step_edit_beat_pos, beats); - step_edit_beat_pos += beats; + if (!track) { + continue; + } + + 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_visibility (false) || changed; + } else { + changed = track->set_visibility (true) || changed; } } + } + + no_redraw = false; + /* TODO: Bender, Pressure */ + + /* invalidate the controller menu, so that we rebuild it next time */ + _controller_menu_map.clear (); + delete controller_menu; + controller_menu = 0; + + if (changed) { + _route->gui_changed ("track_height", this); } } -void -MidiTimeAxisView::step_edit_rest () +Gtk::CheckMenuItem* +MidiTimeAxisView::automation_child_menu_item (Evoral::Parameter param) { - bool success; - Evoral::MusicalTime beats = _editor.get_grid_type_as_beats (success, step_edit_insert_position); - step_edit_beat_pos += beats; -} + Gtk::CheckMenuItem* m = RouteTimeAxisView::automation_child_menu_item (param); + if (m) { + return m; + } -boost::shared_ptr -MidiTimeAxisView::add_region (nframes64_t pos) -{ - Editor* real_editor = dynamic_cast (&_editor); + ParameterMenuMap::iterator i = _controller_menu_map.find (param); + if (i != _controller_menu_map.end()) { + return i->second; + } - real_editor->begin_reversible_command (_("create region")); - XMLNode &before = playlist()->get_state(); + i = _channel_command_menu_map.find (param); + if (i != _channel_command_menu_map.end()) { + return i->second; + } - nframes64_t start = pos; - real_editor->snap_to (start, -1); - const Meter& m = _session.tempo_map().meter_at(start); - const Tempo& t = _session.tempo_map().tempo_at(start); - double length = floor (m.frames_per_bar(t, _session.frame_rate())); + return 0; +} - const boost::shared_ptr diskstream = - boost::dynamic_pointer_cast(view()->trackview().track()->diskstream()); +boost::shared_ptr +MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit) +{ + Editor* real_editor = dynamic_cast (&_editor); - boost::shared_ptr src = _session.create_midi_source_for_session (*diskstream.get()); + real_editor->begin_reversible_command (Operations::create_region); + 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()); + PropertyList plist; + + plist.add (ARDOUR::Properties::start, 0); + plist.add (ARDOUR::Properties::length, length); + plist.add (ARDOUR::Properties::name, PBD::basename_nosuffix(src->name())); + + boost::shared_ptr region = (RegionFactory::create (src, plist)); + + playlist()->add_region (region, pos); + _session->add_command (new StatefulDiffCommand (playlist())); + + if (commit) { + real_editor->commit_reversible_command (); + } - boost::shared_ptr region = (RegionFactory::create (src, 0, (nframes_t) length, - PBD::basename_nosuffix(src->name()))); + return boost::dynamic_pointer_cast(region); +} - playlist()->add_region (region, start); - XMLNode &after = playlist()->get_state(); - _session.add_command (new MementoCommand (*playlist().get(), &before, &after)); +void +MidiTimeAxisView::ensure_step_editor () +{ + if (!_step_editor) { + _step_editor = new StepEditor (_editor, midi_track(), *this); + } +} - real_editor->commit_reversible_command(); +void +MidiTimeAxisView::start_step_editing () +{ + ensure_step_editor (); + _step_editor->start_step_editing (); - return region; +} +void +MidiTimeAxisView::stop_step_editing () +{ + if (_step_editor) { + _step_editor->stop_step_editing (); + } }