X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fmidi_time_axis.cc;h=57cde4af0dd43f57ae6e6dc8cb41fe7e6b7f0b99;hb=cf4b4dea3e38bbddb9a1960fcfd4205bb58c1837;hp=51c4f3b0ede5a46666dca05fba7c6dc24e61017c;hpb=0e0beef90f345d0f65b234bf212612ac45e4a928;p=ardour.git diff --git a/gtk2_ardour/midi_time_axis.cc b/gtk2_ardour/midi_time_axis.cc index 51c4f3b0ed..57cde4af0d 100644 --- a/gtk2_ardour/midi_time_axis.cc +++ b/gtk2_ardour/midi_time_axis.cc @@ -26,6 +26,7 @@ #include #include "pbd/error.h" +#include "pbd/ffs.h" #include "pbd/stl_delete.h" #include "pbd/whitespace.h" #include "pbd/basename.h" @@ -33,40 +34,41 @@ #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/midi_playlist.h" -#include "ardour/midi_diskstream.h" +#include "ardour/event_type_map.h" #include "ardour/midi_patch_manager.h" +#include "ardour/midi_playlist.h" +#include "ardour/midi_region.h" #include "ardour/midi_source.h" -#include "ardour/processor.h" -#include "ardour/ladspa_plugin.h" -#include "ardour/location.h" +#include "ardour/midi_track.h" +#include "ardour/operations.h" +#include "ardour/pannable.h" +#include "ardour/panner.h" +#include "ardour/panner_shell.h" #include "ardour/playlist.h" +#include "ardour/profile.h" +#include "ardour/region.h" #include "ardour/region_factory.h" +#include "ardour/route.h" #include "ardour/session.h" -#include "ardour/session_playlist.h" -#include "ardour/tempo.h" -#include "ardour/utils.h" - -#include "midi++/names.h" +#include "ardour/session_object.h" +#include "ardour/source.h" +#include "ardour/track.h" +#include "ardour/types.h" -#include "add_midi_cc_track_dialog.h" -#include "ardour_ui.h" +#include "ardour_button.h" #include "automation_line.h" #include "automation_time_axis.h" -#include "canvas-note-event.h" -#include "canvas_impl.h" -#include "crossfade_view.h" #include "editor.h" #include "enums.h" #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" @@ -80,27 +82,30 @@ #include "region_view.h" #include "rgb_macros.h" #include "selection.h" -#include "simplerect.h" +#include "step_editor.h" +#include "tooltips.h" #include "utils.h" +#include "note_base.h" #include "ardour/midi_track.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace ARDOUR; +using namespace ARDOUR_UI_UTILS; using namespace PBD; using namespace Gtk; using namespace Gtkmm2ext; using namespace Editing; +using namespace std; // 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 = 160; +static const uint32_t KEYBOARD_MIN_HEIGHT = 130; -MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session* sess, - boost::shared_ptr rt, Canvas& canvas) - : AxisView(sess) // virtually inherited - , RouteTimeAxisView(ed, sess, rt, canvas) +MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session* sess, ArdourCanvas::Canvas& canvas) + : SessionHandlePtr (sess) + , RouteTimeAxisView (ed, sess, canvas) , _ignore_signals(false) , _range_scroomer(0) , _piano_roll_header(0) @@ -111,115 +116,282 @@ MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session* sess, , _meter_color_mode_item(0) , _channel_color_mode_item(0) , _track_color_mode_item(0) + , _channel_selector (0) , _step_edit_item (0) - , _midi_thru_item (0) - , default_channel_menu (0) , controller_menu (0) + , _step_editor (0) { - subplugin_menu.set_name ("ArdourContextMenu"); + _midnam_model_selector.disable_scrolling(); + _midnam_custom_device_mode_selector.disable_scrolling(); +} + +void +MidiTimeAxisView::set_note_highlight (uint8_t note) { + _piano_roll_header->set_note_highlight (note); +} + +void +MidiTimeAxisView::set_route (boost::shared_ptr rt) +{ + _route = rt; _view = new MidiStreamView (*this); - ignore_toggle = false; - - mute_button->set_active (false); - solo_button->set_active (false); + 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)); + } + + /* This next call will result in our height being set up, so it must come after + the creation of the piano roll / range scroomer as their visibility is set up + when our height is. + */ + RouteTimeAxisView::set_route (rt); + + _view->apply_color (gdk_color_to_rgba (color()), StreamView::RegionColor); + + subplugin_menu.set_name ("ArdourContextMenu"); - step_edit_insert_position = 0; + 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()->NoteRangeChanged.connect ( + sigc::mem_fun (*this, &MidiTimeAxisView::note_range_changed)); + _view->ContentsHeightChanged.connect ( + sigc::mem_fun (*this, &MidiTimeAxisView::contents_height_changed)); + + ignore_toggle = false; if (is_midi_track()) { - controls_ebox.set_name ("MidiTimeAxisViewControlsBaseUnselected"); _note_mode = midi_track()->note_mode(); - } else { // MIDI bus (which doesn't exist yet..) - controls_ebox.set_name ("MidiBusControlsBaseUnselected"); } - /* map current state of the route */ + /* if set_state above didn't create a gain automation child, we need to make one */ + if (automation_child (GainAutomation) == 0) { + create_automation_child (GainAutomation, false); + } - processors_changed (RouteProcessorChange ()); + /* if set_state above didn't create a mute automation child, we need to make one */ + if (automation_child (MuteAutomation) == 0) { + create_automation_child (MuteAutomation, false); + } - ensure_xml_node (); + if (_route->panner_shell()) { + _route->panner_shell()->Changed.connect (*this, invalidator (*this), boost::bind (&MidiTimeAxisView::ensure_pan_views, this, false), gui_context()); + } - set_state (*xml_node, Stateful::loading_state_version); + /* map current state of the route */ + ensure_pan_views (false); + update_control_names(); + processors_changed (RouteProcessorChange ()); - _route->processors_changed.connect (*this, invalidator (*this), ui_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 = new PianoRollHeader(*midi_view()); + _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)); + + /* Put the scroomer and the keyboard in a VBox with a padding + label so that they can be reduced in height for stacked-view + tracks. + */ - _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)); + HSeparator* separator = manage (new HSeparator()); + separator->set_name("TrackSeparator"); + separator->set_size_request(-1, 1); + separator->show(); + + VBox* v = manage (new VBox); + HBox* h = manage (new HBox); + h->pack_end (*_piano_roll_header); + h->pack_end (*_range_scroomer); + v->pack_start (*separator, false, false); + v->pack_start (*h, true, true); + v->show (); + h->show (); + top_hbox.remove(scroomer_placeholder); + time_axis_hbox.pack_end(*v, false, false, 0); + midi_scroomer_size_group->add_widget (*v); + + midi_view()->NoteRangeChanged.connect ( + sigc::mem_fun(*this, &MidiTimeAxisView::update_range)); - _range_scroomer = new MidiScroomer(midi_view()->note_range_adjustment); + /* ask for notifications of any new RegionViews */ + _view->RegionViewAdded.connect ( + sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added)); + + midi_track()->playback_filter().ChannelModeChanged.connect ( + *this, invalidator (*this), + boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this), + gui_context()); + midi_track()->playback_filter().ChannelMaskChanged.connect ( + *this, invalidator (*this), + boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this), + gui_context()); + midi_track()->capture_filter().ChannelModeChanged.connect ( + *this, invalidator (*this), + boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this), + gui_context()); + midi_track()->capture_filter().ChannelMaskChanged.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 */ + } else { + first_idle (); + } + } - controls_hbox.pack_start(*_range_scroomer); - controls_hbox.pack_start(*_piano_roll_header); + typedef MIDI::Name::MidiPatchManager PatchManager; - controls_ebox.set_name ("MidiTrackControlsBaseUnselected"); - controls_base_selected_name = "MidiTrackControlsBaseSelected"; - controls_base_unselected_name = "MidiTrackControlsBaseUnselected"; + PatchManager& patch_manager = PatchManager::instance(); - midi_view()->NoteRangeChanged.connect (sigc::mem_fun(*this, &MidiTimeAxisView::update_range)); + for (PatchManager::DeviceNamesByMaker::const_iterator m = patch_manager.devices_by_manufacturer().begin(); + m != patch_manager.devices_by_manufacturer().end(); ++m) { + Menu* menu = Gtk::manage(new Menu); + Menu_Helpers::MenuList& items = menu->items(); - /* ask for notifications of any new RegionViews */ - _view->RegionViewAdded.connect (sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added)); - _view->attach (); - } + // Build manufacturer submenu + for (MIDI::Name::MIDINameDocument::MasterDeviceNamesList::const_iterator n = m->second.begin(); + n != m->second.end(); ++n) { + Menu_Helpers::MenuElem elem = Gtk::Menu_Helpers::MenuElem( + n->first.c_str(), + sigc::bind(sigc::mem_fun(*this, &MidiTimeAxisView::model_changed), + n->first.c_str())); - HBox* midi_controls_hbox = manage(new HBox()); + items.push_back(elem); + } - MIDI::Name::MidiPatchManager& patch_manager = MIDI::Name::MidiPatchManager::instance(); + // Add manufacturer submenu to selector + _midnam_model_selector.AddMenuElem(Menu_Helpers::MenuElem(m->first, *menu)); + } - MIDI::Name::MasterDeviceNames::Models::const_iterator m = patch_manager.all_models().begin(); - for (; m != patch_manager.all_models().end(); ++m) { - _model_selector.append_text(m->c_str()); + if (gui_property (X_("midnam-model-name")).empty()) { + set_gui_property (X_("midnam-model-name"), "Generic"); } - _model_selector.signal_changed().connect(sigc::mem_fun(*this, &MidiTimeAxisView::model_changed)); + 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()); + } + } + + set_tooltip (_midnam_model_selector, _("External MIDI Device")); + set_tooltip (_midnam_custom_device_mode_selector, _("External Device Mode")); + + _midi_controls_box.set_homogeneous(false); + _midi_controls_box.set_border_width (2); - _custom_device_mode_selector.signal_changed().connect( - sigc::mem_fun(*this, &MidiTimeAxisView::custom_device_mode_changed)); + _channel_status_box.set_homogeneous (false); + _channel_status_box.set_spacing (4); - // TODO: persist the choice - // this initializes the comboboxes and sends out the signal - _model_selector.set_active(0); + ArdourButton *channel_selector_button = manage (new ArdourButton(_("Chns"))); + channel_selector_button->set_name ("route button"); + set_tooltip (channel_selector_button, _("Click to edit channel settings")); + + // Insert expanding space labels to get full width justification + _channel_status_box.pack_start (_playback_channel_status, false, false, 2); + _channel_status_box.pack_start (*Gtk::manage(new Gtk::Label(" ")), true, true); + _channel_status_box.pack_start (_capture_channel_status, false, false, 2); + _channel_status_box.pack_start (*Gtk::manage(new Gtk::Label(" ")), true, true); + _channel_status_box.pack_end (*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); - midi_controls_hbox->pack_start(_channel_selector, true, false); if (!patch_manager.all_models().empty()) { - _midi_controls_box.pack_start(_model_selector, true, false); - _midi_controls_box.pack_start(_custom_device_mode_selector, true, false); + + _midnam_model_selector.show (); + _midi_controls_box.pack_start (_midnam_model_selector, false, false, 2); + + _midnam_custom_device_mode_selector.show (); + + _midi_controls_box.pack_start (_midnam_custom_device_mode_selector, false, false, 2); } - _midi_controls_box.pack_start(*midi_controls_hbox, true, true); + model_changed(gui_property(X_("midnam-model-name"))); + custom_device_mode_changed(gui_property(X_("midnam-custom-device-mode"))); controls_vbox.pack_start(_midi_controls_box, false, false); - // 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)); - - XMLProperty *prop; - if ((prop = xml_node->property ("color-mode")) != 0) { - _color_mode = ColorMode (string_2_enum(prop->value(), _color_mode)); - if (_color_mode == ChannelColors) { - _channel_selector.set_channel_colors(CanvasNoteEvent::midi_channel_colors); + 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(NoteBase::midi_channel_colors); } } - if ((prop = xml_node->property ("note-mode")) != 0) { - _note_mode = NoteMode (string_2_enum(prop->value(), _note_mode)); + set_color_mode (_color_mode, true, false); + + 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. + */ + + 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); + if (p && route_id == _route->id () && has_parameter) { + const std::string& visible = gui_object_state().get_string (*i, X_("visible")); + create_automation_child (parameter, string_is_affirmative (visible)); + } + } +} + +void +MidiTimeAxisView::first_idle () +{ + if (is_track ()) { + _view->attach (); + } } MidiTimeAxisView::~MidiTimeAxisView () { + delete _channel_selector; + delete _piano_roll_header; _piano_roll_header = 0; @@ -227,77 +399,105 @@ MidiTimeAxisView::~MidiTimeAxisView () _range_scroomer = 0; delete controller_menu; + delete _step_editor; } -void MidiTimeAxisView::model_changed() +void +MidiTimeAxisView::check_step_edit () +{ + ensure_step_editor (); + _step_editor->check_step_edit (); +} + +void +MidiTimeAxisView::model_changed(const std::string& model) { - std::list device_modes = MIDI::Name::MidiPatchManager::instance() - .custom_device_mode_names_by_model(_model_selector.get_active_text()); + set_gui_property (X_("midnam-model-name"), model); - _custom_device_mode_selector.clear_items(); + const std::list device_modes = MIDI::Name::MidiPatchManager::instance() + .custom_device_mode_names_by_model(model); + + _midnam_model_selector.set_text(model); + _midnam_custom_device_mode_selector.clear_items(); for (std::list::const_iterator i = device_modes.begin(); - i != device_modes.end(); ++i) { - cerr << "found custom device mode " << *i << " thread_id: " << pthread_self() << endl; - _custom_device_mode_selector.append_text(*i); + i != device_modes.end(); ++i) { + _midnam_custom_device_mode_selector.AddMenuElem( + Gtk::Menu_Helpers::MenuElem( + *i, sigc::bind(sigc::mem_fun(*this, &MidiTimeAxisView::custom_device_mode_changed), + *i))); } - _custom_device_mode_selector.set_active(0); -} + if (!device_modes.empty()) { + custom_device_mode_changed(device_modes.front()); + } -void MidiTimeAxisView::custom_device_mode_changed() -{ - _midi_patch_settings_changed.emit(_model_selector.get_active_text(), - _custom_device_mode_selector.get_active_text()); -} + if (device_modes.size() > 1) { + _midnam_custom_device_mode_selector.show(); + } else { + _midnam_custom_device_mode_selector.hide(); + } -MidiStreamView* -MidiTimeAxisView::midi_view() -{ - return dynamic_cast(_view); + if (device_modes.size() > 0) { + _route->instrument_info().set_external_instrument (model, device_modes.front()); + } else { + _route->instrument_info().set_external_instrument (model, ""); + } + + // Rebuild controller menu + _controller_menu_map.clear (); + delete controller_menu; + controller_menu = 0; + build_automation_action_menu(false); } -guint32 -MidiTimeAxisView::show_at (double y, int& nth, Gtk::VBox *parent) +void +MidiTimeAxisView::custom_device_mode_changed(const std::string& mode) { - ensure_xml_node (); - xml_node->add_property ("shown-editor", "yes"); + const std::string model = gui_property (X_("midnam-model-name")); - guint32 ret = TimeAxisView::show_at (y, nth, parent); - return ret; + set_gui_property (X_("midnam-custom-device-mode"), mode); + _midnam_custom_device_mode_selector.set_text(mode); + _route->instrument_info().set_external_instrument (model, mode); } -void -MidiTimeAxisView::hide () +MidiStreamView* +MidiTimeAxisView::midi_view() { - ensure_xml_node (); - xml_node->add_property ("shown-editor", "no"); - - TimeAxisView::hide (); + return dynamic_cast(_view); } void -MidiTimeAxisView::set_height (uint32_t h) +MidiTimeAxisView::set_height (uint32_t h, TrackHeightMode m) { - RouteTimeAxisView::set_height (h); - - if (height >= MIDI_CONTROLS_BOX_MIN_HEIGHT) { - _midi_controls_box.show(); + if (h >= MIDI_CONTROLS_BOX_MIN_HEIGHT) { + _midi_controls_box.show (); } else { _midi_controls_box.hide(); } - if (height >= KEYBOARD_MIN_HEIGHT) { - if (is_track() && _range_scroomer) + if (h >= KEYBOARD_MIN_HEIGHT) { + if (is_track() && _range_scroomer) { _range_scroomer->show(); - if (is_track() && _piano_roll_header) + } + if (is_track() && _piano_roll_header) { _piano_roll_header->show(); + } } else { - if (is_track() && _range_scroomer) + if (is_track() && _range_scroomer) { _range_scroomer->hide(); - if (is_track() && _piano_roll_header) + } + if (is_track() && _piano_roll_header) { _piano_roll_header->hide(); + } } + + /* We need to do this after changing visibility of our stuff, as it will + eventually trigger a call to Editor::reset_controls_layout_width(), + which needs to know if we have just shown or hidden a scroomer / + piano roll. + */ + RouteTimeAxisView::set_height (h, m); } void @@ -312,136 +512,141 @@ 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))); - - range_items.push_back (MenuElem (_("Fit Contents"), sigc::bind ( - sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), - MidiStreamView::ContentsRange))); - - items.push_back (MenuElem (_("Note range"), *range_menu)); - items.push_back (MenuElem (_("Note mode"), *build_note_mode_menu())); - items.push_back (MenuElem (_("Default Channel"), *build_def_channel_menu())); - - items.push_back (CheckMenuElem (_("MIDI Thru"), sigc::mem_fun(*this, &MidiTimeAxisView::toggle_midi_thru))); - _midi_thru_item = dynamic_cast(&items.back()); -} - -Gtk::Menu* -MidiTimeAxisView::build_def_channel_menu () -{ - using namespace Menu_Helpers; - - default_channel_menu = manage (new Menu ()); + range_items.push_back ( + MenuElem (_("Show Full Range"), + sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), + MidiStreamView::FullRange, true))); - uint8_t defchn = midi_track()->default_channel(); - MenuList& def_channel_items = default_channel_menu->items(); - RadioMenuItem* item; - RadioMenuItem::Group dc_group; + range_items.push_back ( + MenuElem (_("Fit Contents"), + sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), + MidiStreamView::ContentsRange, true))); - for (int i = 0; i < 16; ++i) { - char buf[4]; - snprintf (buf, sizeof (buf), "%d", i+1); + 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))); - def_channel_items.push_back (RadioMenuElem (dc_group, buf, - sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_default_channel), i))); - item = dynamic_cast(&def_channel_items.back()); - item->set_active ((i == defchn)); + color_mode_menu = build_color_mode_menu(); + if (color_mode_menu) { + items.push_back (MenuElem (_("Color Mode"), *color_mode_menu)); } - return default_channel_menu; + items.push_back (SeparatorElem ()); } void -MidiTimeAxisView::set_default_channel (int chn) +MidiTimeAxisView::toggle_channel_selector () { - midi_track()->set_default_channel (chn); -} + if (!_channel_selector) { + _channel_selector = new MidiChannelSelectorWindow (midi_track()); -void -MidiTimeAxisView::toggle_midi_thru () -{ - if (!_midi_thru_item) { - return; - } + if (_color_mode == ChannelColors) { + _channel_selector->set_channel_colors(NoteBase::midi_channel_colors); + } else { + _channel_selector->set_default_channel_color (); + } - bool view_yn = _midi_thru_item->get_active(); - if (view_yn != midi_track()->midi_thru()) { - midi_track()->set_midi_thru (view_yn); + _channel_selector->show_all (); + } else { + _channel_selector->cycle_visibility (); } } void -MidiTimeAxisView::build_automation_action_menu () +MidiTimeAxisView::build_automation_action_menu (bool for_selection) { using namespace Menu_Helpers; - RouteTimeAxisView::build_automation_action_menu (); + /* 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 (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 3 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, _("Program Change"), MidiPgmChangeAutomation, MIDI_CMD_PGM_CHANGE); - add_channel_command_menu_item (automation_items, _("Bender"), MidiPitchBenderAutomation, MIDI_CMD_BENDER); - add_channel_command_menu_item (automation_items, _("Pressure"), MidiChannelPressureAutomation, MIDI_CMD_CHANNEL_PRESSURE); - - /* 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 (); - detach_menu (*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); } 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)) { - + Evoral::Parameter fully_qualified_param (param.type(), chn, param.id()); - RouteAutomationNode* node = automation_track (fully_qualified_param); + Gtk::CheckMenuItem* menu = automation_child_menu_item (fully_qualified_param); - if (node && node->menu_item) { - node->menu_item->set_active (yn); + 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) +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++) { if (selected_channels & (0x0001 << chn)) { if (++chn_cnt > 1) { @@ -449,87 +654,81 @@ MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items, } } } - + 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))); - + 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))); - - RouteAutomationNode* node = 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; - - if (node) { - if (node->track->marked_for_display()) { + + if (track) { + if (track->marked_for_display()) { visible = true; } } - - CheckMenuItem* cmi = static_cast(&chn_items.back()); - if (node) { - node->menu_item = cmi; - } + Gtk::CheckMenuItem* cmi = static_cast(&chn_items.back()); + _channel_command_menu_map[fully_qualified_param] = cmi; cmi->set_active (visible); - - parameter_menu_map[fully_qualified_param] = cmi; } } - + /* 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))); - - RouteAutomationNode* node = 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; - - if (node) { - if (node->track->marked_for_display()) { + + if (track) { + if (track->marked_for_display()) { visible = true; } } - - CheckMenuItem* cmi = static_cast(&items.back()); - if (node) { - node->menu_item = cmi; - } + Gtk::CheckMenuItem* cmi = static_cast(&items.back()); + _channel_command_menu_map[fully_qualified_param] = cmi; cmi->set_active (visible); - - parameter_menu_map[fully_qualified_param] = cmi; /* one channel only */ break; @@ -538,30 +737,160 @@ MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items, } } +/** Add a single menu item for a controller on one channel. */ +void +MidiTimeAxisView::add_single_channel_controller_item(Menu_Helpers::MenuList& ctl_items, + int ctl, + const std::string& name) +{ + using namespace Menu_Helpers; + + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); + 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, name, int (chn + 1)), + 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; + } + } + + Gtk::CheckMenuItem* cmi = static_cast(&ctl_items.back()); + _controller_menu_map[fully_qualified_param] = cmi; + cmi->set_active (visible); + + /* one channel only */ + break; + } + } +} + +/** 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; + + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); + + 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; + } + } + + Gtk::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, name), + *chn_menu)); + dynamic_cast (ctl_items.back().get_child())->set_use_markup (true); +} + +boost::shared_ptr +MidiTimeAxisView::get_device_mode() +{ + using namespace MIDI::Name; + + boost::shared_ptr device_names = get_device_names(); + if (!device_names) { + return boost::shared_ptr(); + } + + return device_names->custom_device_mode_by_name( + gui_property (X_("midnam-custom-device-mode"))); +} + +boost::shared_ptr +MidiTimeAxisView::get_device_names() +{ + using namespace MIDI::Name; + + const std::string model = gui_property (X_("midnam-model-name")); + + boost::shared_ptr midnam = MidiPatchManager::instance() + .document_by_model(model); + if (midnam) { + return midnam->master_device_names(model); + } else { + return boost::shared_ptr(); + } +} + 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 */ + /* it exists and has not been invalidated by a channel mode change */ 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 + /* 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(); + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); - /* 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. + */ int chn_cnt = 0; - for (uint8_t chn = 0; chn < 16; chn++) { if (selected_channels & (0x0001 << chn)) { if (++chn_cnt > 1) { @@ -569,111 +898,79 @@ MidiTimeAxisView::build_controller_menu () } } } - - /* loop over all 127 MIDI controllers, in groups of 16 */ - - for (int i = 0; i < 127; i += 16) { - - 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 (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))); - - RouteAutomationNode* node = automation_track (fully_qualified_param); - bool visible = false; - - if (node) { - if (node->track->marked_for_display()) { - visible = true; - } - } - - CheckMenuItem* cmi = static_cast(&chn_items.back()); - if (node) { - node->menu_item = cmi; - } + using namespace MIDI::Name; + boost::shared_ptr device_names = get_device_names(); + + if (device_names && !device_names->controls().empty()) { + /* Controllers names available in midnam file, generate fancy menu */ + unsigned n_items = 0; + unsigned n_groups = 0; + + /* 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); + } - cmi->set_active (visible); - - parameter_menu_map[fully_qualified_param] = cmi; + 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()); } } - - /* add the per-channel menu to the list of controllers, with the name of the controller */ - - ctl_items.push_back (MenuElem (midi_name (ctl), *chn_menu)); - } 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 (_route->describe_parameter (fully_qualified_param), - sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), - fully_qualified_param))); - - RouteAutomationNode* node = automation_track (fully_qualified_param); - bool visible = false; - - if (node) { - if (node->track->marked_for_display()) { - visible = true; - } - } - - CheckMenuItem* cmi = static_cast(&ctl_items.back()); - if (node) { - node->menu_item = cmi; - } - - cmi->set_active (visible); - - - parameter_menu_map[fully_qualified_param] = cmi; - /* one channel only */ - break; - } + ++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; } } } - - /* add the menu for this block of controllers to the overall controller menu */ + } 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; + } - items.push_back (MenuElem (string_compose (_("Controllers %1-%2"), i+1, i+16), *ctl_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)); + } + } + + /* Add submenu for this block of controllers to controller menu */ + items.push_back ( + MenuElem (string_compose (_("Controllers %1-%2"), i, i + 15), + *ctl_menu)); + } } } @@ -687,13 +984,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))); + 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))); + 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); @@ -710,18 +1011,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))); + 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))); + 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))); + 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); @@ -729,46 +1036,67 @@ MidiTimeAxisView::build_color_mode_menu() } void -MidiTimeAxisView::set_note_mode(NoteMode mode) +MidiTimeAxisView::set_note_mode(NoteMode mode, bool apply_to_selection) { - if (_note_mode != mode || midi_track()->note_mode() != mode) { - _note_mode = mode; - midi_track()->set_note_mode(mode); - xml_node->add_property ("note-mode", enum_2_string(_note_mode)); - _view->redisplay_track(); + if (apply_to_selection) { + _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; + midi_track()->set_note_mode(mode); + set_gui_property ("note-mode", enum_2_string(_note_mode)); + _view->redisplay_track(); + } } } void -MidiTimeAxisView::set_color_mode(ColorMode mode) +MidiTimeAxisView::set_color_mode (ColorMode mode, bool force, bool redisplay, bool apply_to_selection) { - if (_color_mode != mode) { - if (mode == ChannelColors) { - _channel_selector.set_channel_colors(CanvasNoteEvent::midi_channel_colors); - } else { - _channel_selector.set_default_channel_color(); + if (apply_to_selection) { + _editor.get_selection().tracks.foreach_midi_time_axis ( + boost::bind (&MidiTimeAxisView::set_color_mode, _1, mode, force, redisplay, false)); + } else { + if (_color_mode == mode && !force) { + return; + } + + if (_channel_selector) { + if (mode == ChannelColors) { + _channel_selector->set_channel_colors(NoteBase::midi_channel_colors); + } else { + _channel_selector->set_default_channel_color(); + } } _color_mode = mode; - xml_node->add_property ("color-mode", enum_2_string(_color_mode)); - _view->redisplay_track(); + set_gui_property ("color-mode", enum_2_string(_color_mode)); + if (redisplay) { + _view->redisplay_track(); + } } } void -MidiTimeAxisView::set_note_range(MidiStreamView::VisibleNoteRange range) +MidiTimeAxisView::set_note_range (MidiStreamView::VisibleNoteRange range, bool apply_to_selection) { - if (!_ignore_signals) - midi_view()->set_note_range(range); + if (apply_to_selection) { + _editor.get_selection().tracks.foreach_midi_time_axis ( + boost::bind (&MidiTimeAxisView::set_note_range, _1, range, false)); + } else { + if (!_ignore_signals) { + midi_view()->set_note_range(range); + } + } } - void 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(); } @@ -776,272 +1104,311 @@ MidiTimeAxisView::update_range() } void -MidiTimeAxisView::show_all_automation () +MidiTimeAxisView::show_all_automation (bool apply_to_selection) { - if (midi_track()) { - const set params = midi_track()->midi_playlist()->contained_automation(); + using namespace MIDI::Name; + + if (apply_to_selection) { + _editor.get_selection().tracks.foreach_midi_time_axis ( + boost::bind (&MidiTimeAxisView::show_all_automation, _1, false)); + } else { + if (midi_track()) { + // Show existing 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); + for (set::const_iterator i = params.begin(); i != params.end(); ++i) { + create_automation_child(*i, true); + } + + // Show automation for all controllers named in midnam file + boost::shared_ptr device_names = get_device_names(); + if (gui_property (X_("midnam-model-name")) != "Generic" && + device_names && !device_names->controls().empty()) { + const std::string device_mode = gui_property (X_("midnam-custom-device-mode")); + const uint16_t selected_channels = midi_track()->get_playback_channel_mask(); + for (uint32_t chn = 0; chn < 16; ++chn) { + if ((selected_channels & (0x0001 << chn)) == 0) { + // Channel not in use + continue; + } + + boost::shared_ptr chan_names = device_names->channel_name_set_by_channel( + device_mode, chn); + if (!chan_names) { + continue; + } + + boost::shared_ptr control_names = device_names->control_name_list( + chan_names->control_list_name()); + if (!control_names) { + continue; + } + + for (ControlNameList::Controls::const_iterator c = control_names->controls().begin(); + c != control_names->controls().end(); + ++c) { + 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 */ + const Evoral::Parameter param(MidiCCAutomation, chn, ctl); + create_automation_child(param, true); + } + } + } + } } - } - RouteTimeAxisView::show_all_automation (); + RouteTimeAxisView::show_all_automation (); + } } void -MidiTimeAxisView::show_existing_automation () +MidiTimeAxisView::show_existing_automation (bool apply_to_selection) { - if (midi_track()) { - const set params = midi_track()->midi_playlist()->contained_automation(); + if (apply_to_selection) { + _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(); - for (set::const_iterator i = params.begin(); i != params.end(); ++i) { - create_automation_child(*i, true); + for (set::const_iterator i = params.begin(); i != params.end(); ++i) { + create_automation_child (*i, true); + } } - } - RouteTimeAxisView::show_existing_automation (); + RouteTimeAxisView::show_existing_automation (); + } } -/** Hide an automation track for the given parameter (pitch bend, channel pressure). +/** Create an automation track for the given parameter (pitch bend, channel pressure). */ 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()) { + + /* automation track created because we had existing data for + * the processor, but visibility may need to be controlled + * since it will have been set visible by default. + */ + + existing->second->set_marked_for_display (show); + + if (!no_redraw) { + request_redraw (); + } + return; } - boost::shared_ptr c = _route->get_control (param); + boost::shared_ptr track; + boost::shared_ptr control; + + + switch (param.type()) { + + case GainAutomation: + create_gain_automation_child (param, show); + break; + + case MuteAutomation: + create_mute_automation_child (param, show); + break; + + case PluginAutomation: + /* handled elsewhere */ + break; + + case MidiCCAutomation: + case MidiPgmChangeAutomation: + case MidiPitchBenderAutomation: + case MidiChannelPressureAutomation: + case MidiSystemExclusiveAutomation: + /* These controllers are region "automation" - they are owned + * by regions (and their MidiModels), not by the track. As a + * result there is no AutomationList/Line for the track, but we create + * a controller for the user to write immediate events, so the editor + * can act as a control surface for the present MIDI controllers. + * + * TODO: Record manipulation of the controller to regions? + */ + + control = _route->automation_control(param, true); + track.reset (new AutomationTimeAxisView ( + _session, + _route, + control ? _route : boost::shared_ptr (), + control, + param, + _editor, + *this, + true, + parent_canvas, + _route->describe_parameter(param))); + + if (_view) { + _view->foreach_regionview ( + sigc::mem_fun (*track.get(), &TimeAxisView::add_ghost)); + } - assert(c); + add_automation_child (param, track, show); + break; - boost::shared_ptr track(new AutomationTimeAxisView (_session, - _route, boost::shared_ptr(), c, - _editor, - *this, - true, - parent_canvas, - _route->describe_parameter(param))); + case PanWidthAutomation: + case PanElevationAutomation: + case PanAzimuthAutomation: + ensure_pan_views (show); + break; - add_automation_child (param, track, show); + default: + error << "MidiTimeAxisView: unknown automation child " + << EventTypeMap::instance().to_symbol(param) << endmsg; + } } - void MidiTimeAxisView::route_active_changed () { RouteUI::route_active_changed (); + update_control_names(); +} +void +MidiTimeAxisView::update_control_names () +{ if (is_track()) { if (_route->active()) { - controls_ebox.set_name ("MidiTrackControlsBaseUnselected"); controls_base_selected_name = "MidiTrackControlsBaseSelected"; controls_base_unselected_name = "MidiTrackControlsBaseUnselected"; } else { - controls_ebox.set_name ("MidiTrackControlsBaseInactiveUnselected"); controls_base_selected_name = "MidiTrackControlsBaseInactiveSelected"; controls_base_unselected_name = "MidiTrackControlsBaseInactiveUnselected"; } - } else { - - throw; // wha? - + } else { // MIDI bus (which doesn't exist yet..) if (_route->active()) { - controls_ebox.set_name ("BusControlsBaseUnselected"); controls_base_selected_name = "BusControlsBaseSelected"; controls_base_unselected_name = "BusControlsBaseUnselected"; } else { - controls_ebox.set_name ("BusControlsBaseInactiveUnselected"); controls_base_selected_name = "BusControlsBaseInactiveSelected"; controls_base_unselected_name = "BusControlsBaseInactiveUnselected"; } } -} -void -MidiTimeAxisView::start_step_editing () -{ - 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 (step_edit_region) { - RegionView* rv = view()->find_view (step_edit_region); - step_edit_region_view = dynamic_cast (rv); + if (selected()) { + controls_ebox.set_name (controls_base_selected_name); + time_axis_frame.set_name (controls_base_selected_name); } else { - step_edit_region_view = 0; + controls_ebox.set_name (controls_base_unselected_name); + time_axis_frame.set_name (controls_base_unselected_name); } - - midi_track()->set_step_editing (true); } void -MidiTimeAxisView::stop_step_editing () +MidiTimeAxisView::set_note_selection (uint8_t note) { - midi_track()->set_step_editing (false); -} - -void -MidiTimeAxisView::check_step_edit () -{ - MidiRingBuffer& incoming (midi_track()->step_edit_ring_buffer()); - Evoral::Note note; - uint8_t* buf; - uint32_t bufsize = 32; - - buf = new uint8_t[bufsize]; + uint16_t chn_mask = midi_track()->get_playback_channel_mask(); - while (incoming.read_space()) { - nframes_t time; - Evoral::EventType type; - uint32_t size; - - incoming.read_prefix (&time, &type, &size); - - if (size > bufsize) { - delete [] buf; - bufsize = size; - buf = new uint8_t[bufsize]; - } - - incoming.read_contents (size, buf); - - if ((buf[0] & 0xf0) == MIDI_CMD_NOTE_ON) { - - if (step_edit_region == 0) { - - step_edit_region = add_region (step_edit_insert_position); - RegionView* rv = view()->find_view (step_edit_region); - - if (rv) { - step_edit_region_view = dynamic_cast(rv); - } else { - fatal << X_("programming error: no view found for new MIDI region") << endmsg; - /*NOTREACHED*/ - } - } - - if (step_edit_region_view) { - - bool success; - Evoral::MusicalTime beats = _editor.get_grid_type_as_beats (success, step_edit_insert_position); - - if (!success) { - continue; - } - - step_edit_region_view->add_note (buf[0] & 0xf, buf[1], buf[2], step_edit_beat_pos, beats); - step_edit_beat_pos += beats; - } - } + _editor.begin_reversible_selection_op (X_("Set Note Selection")); + if (_view->num_selected_regionviews() == 0) { + _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)); } -} -void -MidiTimeAxisView::step_edit_rest () -{ - bool success; - Evoral::MusicalTime beats = _editor.get_grid_type_as_beats (success, step_edit_insert_position); - step_edit_beat_pos += beats; -} - -boost::shared_ptr -MidiTimeAxisView::add_region (nframes64_t pos) -{ - Editor* real_editor = dynamic_cast (&_editor); - - real_editor->begin_reversible_command (_("create region")); - playlist()->clear_history (); - - framepos_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())); - - boost::shared_ptr src = _session->create_midi_source_for_session (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, start); - _session->add_command (new StatefulDiffCommand (playlist())); - - real_editor->commit_reversible_command(); - - return region; + _editor.commit_reversible_selection_op(); } void MidiTimeAxisView::add_note_selection (uint8_t note) { - if (!_editor.internal_editing()) { - return; - } + const uint16_t chn_mask = midi_track()->get_playback_channel_mask(); - uint16_t chn_mask = _channel_selector.get_selected_channels(); + _editor.begin_reversible_selection_op (X_("Add Note Selection")); 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)); } + + _editor.commit_reversible_selection_op(); } void MidiTimeAxisView::extend_note_selection (uint8_t note) { - if (!_editor.internal_editing()) { - return; - } + const uint16_t chn_mask = midi_track()->get_playback_channel_mask(); - uint16_t chn_mask = _channel_selector.get_selected_channels(); + _editor.begin_reversible_selection_op (X_("Extend Note Selection")); 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)); } + + _editor.commit_reversible_selection_op(); } void MidiTimeAxisView::toggle_note_selection (uint8_t note) { - if (!_editor.internal_editing()) { - return; - } + const uint16_t chn_mask = midi_track()->get_playback_channel_mask(); - uint16_t chn_mask = _channel_selector.get_selected_channels(); + _editor.begin_reversible_selection_op (X_("Toggle Note Selection")); 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)); } + + _editor.commit_reversible_selection_op(); } void -MidiTimeAxisView::add_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask) +MidiTimeAxisView::get_per_region_note_selection (list > > > >& selection) +{ + _view->foreach_regionview ( + sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::get_per_region_note_selection_region_view), sigc::ref(selection))); +} + +void +MidiTimeAxisView::set_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask) { dynamic_cast(rv)->select_matching_notes (note, chn_mask, false, false); } +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, true, false); +} + void MidiTimeAxisView::extend_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask) { @@ -1054,6 +1421,24 @@ MidiTimeAxisView::toggle_note_selection_region_view (RegionView* rv, uint8_t not dynamic_cast(rv)->toggle_matching_notes (note, chn_mask); } +void +MidiTimeAxisView::get_per_region_note_selection_region_view (RegionView* rv, list > > > > &selection) +{ + Evoral::Sequence::Notes selected; + dynamic_cast(rv)->selection_as_notelist (selected, false); + + std::set > > notes; + + Evoral::Sequence::Notes::iterator sel_it; + for (sel_it = selected.begin(); sel_it != selected.end(); ++sel_it) { + notes.insert (*sel_it); + } + + if (!notes.empty()) { + selection.push_back (make_pair ((rv)->region()->id(), notes)); + } +} + void MidiTimeAxisView::set_channel_mode (ChannelMode, uint16_t) { @@ -1061,7 +1446,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; @@ -1070,32 +1455,192 @@ MidiTimeAxisView::set_channel_mode (ChannelMode, uint16_t) for (uint32_t chn = 0; chn < 16; ++chn) { Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl); - RouteAutomationNode* node = automation_track (fully_qualified_param); + boost::shared_ptr track = automation_child (fully_qualified_param); - if (!node) { + if (!track) { continue; } - + if ((selected_channels & (0x0001 << chn)) == 0) { - /* channel not in use. hiding it will trigger RouteTimeAxisView::automation_track_hidden() + /* 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 = node->track->set_visibility (false) || changed; + */ + changed = track->set_marked_for_display (false) || changed; } else { - changed = node->track->set_visibility (true) || changed; + changed = track->set_marked_for_display (true) || changed; } } } no_redraw = false; - /* TODO: Bender, PgmChange, Pressure */ + /* TODO: Bender, Pressure */ - /* invalidate the controller menu, so that we rebuilt it next time */ + /* 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); + request_redraw (); + } +} + +Gtk::CheckMenuItem* +MidiTimeAxisView::automation_child_menu_item (Evoral::Parameter param) +{ + Gtk::CheckMenuItem* m = RouteTimeAxisView::automation_child_menu_item (param); + if (m) { + return m; + } + + ParameterMenuMap::iterator i = _controller_menu_map.find (param); + if (i != _controller_menu_map.end()) { + return i->second; + } + + i = _channel_command_menu_map.find (param); + if (i != _channel_command_menu_map.end()) { + return i->second; + } + + return 0; +} + +boost::shared_ptr +MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit, const int32_t sub_num) +{ + Editor* real_editor = dynamic_cast (&_editor); + if (commit) { + real_editor->begin_reversible_command (Operations::create_region); + } + playlist()->clear_changes (); + + real_editor->snap_to (pos, RoundNearest); + + boost::shared_ptr src = _session->create_midi_source_by_stealing_name (view()->trackview().track()); + 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)); + /* sets beat position */ + region->set_position (pos, sub_num); + playlist()->add_region (region, pos, 1.0, false, sub_num); + _session->add_command (new StatefulDiffCommand (playlist())); + + if (commit) { + real_editor->commit_reversible_command (); + } + + return boost::dynamic_pointer_cast(region); +} + +void +MidiTimeAxisView::ensure_step_editor () +{ + if (!_step_editor) { + _step_editor = new StepEditor (_editor, midi_track(), *this); + } +} + +void +MidiTimeAxisView::start_step_editing () +{ + ensure_step_editor (); + _step_editor->start_step_editing (); + +} +void +MidiTimeAxisView::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 = midi_track()->get_playback_channel_mask(); + int chn_cnt = 0; + uint8_t channel = 0; + + /* pick the highest selected channel, unless all channels are selected, + which is interpreted to mean channel 1 (zero) + */ + + for (uint16_t i = 0; i < 16; ++i) { + if (chn_mask & (1<lowest_note ()); + set_gui_property ("note-range-max", (int) midi_view()->highest_note ()); +} + +void +MidiTimeAxisView::contents_height_changed () +{ + _range_scroomer->queue_resize (); +} + +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"), PBD::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"), PBD::ffs (midi_track()->get_capture_channel_mask()))); + break; + } +} + +bool +MidiTimeAxisView::paste (framepos_t pos, const Selection& selection, PasteContext& ctx, const int32_t sub_num) +{ + if (!_editor.internal_editing()) { + // Non-internal paste, paste regions like any other route + return RouteTimeAxisView::paste(pos, selection, ctx, sub_num); + } + + return midi_view()->paste(pos, selection, ctx, sub_num); }