X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fmidi_time_axis.cc;h=57cde4af0dd43f57ae6e6dc8cb41fe7e6b7f0b99;hb=cf52d6e4b40111eb04b244ec054055a4ec15dbe0;hp=c37916dbf0c95b7056b1c8f7668e8a7ec57570d3;hpb=23e7cf10191270d70357ccf0ed9294f020c7b7ab;p=ardour.git diff --git a/gtk2_ardour/midi_time_axis.cc b/gtk2_ardour/midi_time_axis.cc index c37916dbf0..57cde4af0d 100644 --- a/gtk2_ardour/midi_time_axis.cc +++ b/gtk2_ardour/midi_time_axis.cc @@ -50,6 +50,7 @@ #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" @@ -59,7 +60,6 @@ #include "ardour/track.h" #include "ardour/types.h" -#include "ardour_ui.h" #include "ardour_button.h" #include "automation_line.h" #include "automation_time_axis.h" @@ -83,12 +83,13 @@ #include "rgb_macros.h" #include "selection.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; @@ -96,14 +97,15 @@ 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 = 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, ArdourCanvas::Canvas& canvas) - : AxisView(sess) // virtually inherited - , RouteTimeAxisView(ed, sess, canvas) + : SessionHandlePtr (sess) + , RouteTimeAxisView (ed, sess, canvas) , _ignore_signals(false) , _range_scroomer(0) , _piano_roll_header(0) @@ -119,13 +121,20 @@ MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session* sess, ArdourCanva , controller_menu (0) , _step_editor (0) { + _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); if (is_track ()) { @@ -142,7 +151,7 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) */ RouteTimeAxisView::set_route (rt); - _view->apply_color (_color, StreamView::RegionColor); + _view->apply_color (gdk_color_to_rgba (color()), StreamView::RegionColor); subplugin_menu.set_name ("ArdourContextMenu"); @@ -160,10 +169,7 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) 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"); } /* if set_state above didn't create a gain automation child, we need to make one */ @@ -171,13 +177,18 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) create_automation_child (GainAutomation, false); } + /* 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); + } + if (_route->panner_shell()) { _route->panner_shell()->Changed.connect (*this, invalidator (*this), boost::bind (&MidiTimeAxisView::ensure_pan_views, this, false), gui_context()); } /* map current state of the route */ ensure_pan_views (false); - + update_control_names(); processors_changed (RouteProcessorChange ()); _route->processors_changed.connect (*this, invalidator (*this), @@ -204,19 +215,23 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) label so that they can be reduced in height for stacked-view tracks. */ + + 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_start (*_range_scroomer); - h->pack_start (*_piano_roll_header); - v->pack_start (*h, false, false); - v->pack_start (*manage (new Label ("")), true, true); + 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 (); - controls_hbox.pack_start(*v, false, false); - - controls_ebox.set_name ("MidiTrackControlsBaseUnselected"); - controls_base_selected_name = "MidiTrackControlsBaseSelected"; - controls_base_unselected_name = "MidiTrackControlsBaseUnselected"; + 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)); @@ -225,18 +240,22 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) _view->RegionViewAdded.connect ( sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added)); - midi_track()->PlaybackChannelModeChanged.connect (*this, invalidator (*this), - boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this), - gui_context()); - midi_track()->PlaybackChannelMaskChanged.connect (*this, invalidator (*this), - boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this), - gui_context()); - midi_track()->CaptureChannelModeChanged.connect (*this, invalidator (*this), - boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this), - gui_context()); - midi_track()->CaptureChannelMaskChanged.connect (*this, invalidator (*this), - boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this), - gui_context()); + 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 (); @@ -248,11 +267,28 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) } } - MIDI::Name::MidiPatchManager& patch_manager = MIDI::Name::MidiPatchManager::instance(); + typedef MIDI::Name::MidiPatchManager PatchManager; - MIDI::Name::MasterDeviceNames::Models::const_iterator m = patch_manager.all_models().begin(); - for (; m != patch_manager.all_models().end(); ++m) { - _midnam_model_selector.append_text(m->c_str()); + PatchManager& patch_manager = PatchManager::instance(); + + 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(); + + // 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())); + + items.push_back(elem); + } + + // Add manufacturer submenu to selector + _midnam_model_selector.AddMenuElem(Menu_Helpers::MenuElem(m->first, *menu)); } if (gui_property (X_("midnam-model-name")).empty()) { @@ -267,58 +303,43 @@ MidiTimeAxisView::set_route (boost::shared_ptr rt) } } - _midnam_model_selector.set_active_text (gui_property (X_("midnam-model-name"))); - _midnam_custom_device_mode_selector.set_active_text (gui_property (X_("midnam-custom-device-mode"))); - - ARDOUR_UI::instance()->set_tip (_midnam_model_selector, _("External MIDI Device")); - ARDOUR_UI::instance()->set_tip (_midnam_custom_device_mode_selector, _("External Device Mode")); + 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 (10); + _midi_controls_box.set_border_width (2); _channel_status_box.set_homogeneous (false); - _channel_status_box.set_spacing (6); - - _channel_selector_button.set_label (_("Chns")); - ARDOUR_UI::instance()->set_tip (_channel_selector_button, _("Click to edit channel settings")); - - /* fixed sized labels to prevent silly nonsense (though obviously, - * they cause their own too) - */ - - _playback_channel_status.set_size_request (65, -1); - _capture_channel_status.set_size_request (60, -1); - - _channel_status_box.pack_start (_playback_channel_status, false, false); - _channel_status_box.pack_start (_capture_channel_status, false, false); - _channel_status_box.pack_start (_channel_selector_button, false, false); + _channel_status_box.set_spacing (4); + + 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)); - + channel_selector_button->signal_clicked.connect (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_channel_selector)); + _midi_controls_box.pack_start (_channel_status_box, false, false, 10); if (!patch_manager.all_models().empty()) { - _midnam_model_selector.set_size_request(22, 30); - _midnam_model_selector.set_border_width(2); _midnam_model_selector.show (); - _midi_controls_box.pack_start (_midnam_model_selector); + _midi_controls_box.pack_start (_midnam_model_selector, false, false, 2); - _midnam_custom_device_mode_selector.set_size_request(10, 30); - _midnam_custom_device_mode_selector.set_border_width(2); _midnam_custom_device_mode_selector.show (); - _midi_controls_box.pack_start (_midnam_custom_device_mode_selector); - } - - model_changed(); - custom_device_mode_changed(); + _midi_controls_box.pack_start (_midnam_custom_device_mode_selector, false, false, 2); + } - _midnam_model_selector.signal_changed().connect( - sigc::mem_fun(*this, &MidiTimeAxisView::model_changed)); - _midnam_custom_device_mode_selector.signal_changed().connect( - sigc::mem_fun(*this, &MidiTimeAxisView::custom_device_mode_changed)); + 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); @@ -381,22 +402,6 @@ MidiTimeAxisView::~MidiTimeAxisView () 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 () { @@ -405,26 +410,39 @@ MidiTimeAxisView::check_step_edit () } void -MidiTimeAxisView::model_changed() +MidiTimeAxisView::model_changed(const std::string& model) { - const Glib::ustring model = _midnam_model_selector.get_active_text(); set_gui_property (X_("midnam-model-name"), model); 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) { - _midnam_custom_device_mode_selector.append_text(*i); + _midnam_custom_device_mode_selector.AddMenuElem( + Gtk::Menu_Helpers::MenuElem( + *i, sigc::bind(sigc::mem_fun(*this, &MidiTimeAxisView::custom_device_mode_changed), + *i))); } - _midnam_custom_device_mode_selector.set_active(0); - - _route->instrument_info().set_external_instrument ( - _midnam_model_selector.get_active_text(), - _midnam_custom_device_mode_selector.get_active_text()); + if (!device_modes.empty()) { + custom_device_mode_changed(device_modes.front()); + } + + if (device_modes.size() > 1) { + _midnam_custom_device_mode_selector.show(); + } else { + _midnam_custom_device_mode_selector.hide(); + } + + 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 (); @@ -434,12 +452,13 @@ MidiTimeAxisView::model_changed() } void -MidiTimeAxisView::custom_device_mode_changed() +MidiTimeAxisView::custom_device_mode_changed(const std::string& mode) { - const Glib::ustring mode = _midnam_custom_device_mode_selector.get_active_text(); + const std::string model = gui_property (X_("midnam-model-name")); + set_gui_property (X_("midnam-custom-device-mode"), mode); - _route->instrument_info().set_external_instrument ( - _midnam_model_selector.get_active_text(), mode); + _midnam_custom_device_mode_selector.set_text(mode); + _route->instrument_info().set_external_instrument (model, mode); } MidiStreamView* @@ -449,14 +468,14 @@ MidiTimeAxisView::midi_view() } void -MidiTimeAxisView::set_height (uint32_t h) +MidiTimeAxisView::set_height (uint32_t h, TrackHeightMode m) { if (h >= MIDI_CONTROLS_BOX_MIN_HEIGHT) { _midi_controls_box.show (); } else { _midi_controls_box.hide(); } - + if (h >= KEYBOARD_MIN_HEIGHT) { if (is_track() && _range_scroomer) { _range_scroomer->show(); @@ -478,7 +497,7 @@ MidiTimeAxisView::set_height (uint32_t h) which needs to know if we have just shown or hidden a scroomer / piano roll. */ - RouteTimeAxisView::set_height (h); + RouteTimeAxisView::set_height (h, m); } void @@ -495,7 +514,7 @@ MidiTimeAxisView::append_extra_display_menu_items () range_items.push_back ( MenuElem (_("Show Full Range"), - sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), + sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), MidiStreamView::FullRange, true))); range_items.push_back ( @@ -512,7 +531,7 @@ MidiTimeAxisView::append_extra_display_menu_items () if (color_mode_menu) { items.push_back (MenuElem (_("Color Mode"), *color_mode_menu)); } - + items.push_back (SeparatorElem ()); } @@ -585,7 +604,6 @@ MidiTimeAxisView::build_automation_action_menu (bool for_selection) build_controller_menu (); - automation_items.push_back (SeparatorElem()); automation_items.push_back (MenuElem (_("Controllers"), *controller_menu)); automation_items.back().set_sensitive ( !for_selection || _editor.get_selection().tracks.size() == 1); @@ -594,27 +612,6 @@ MidiTimeAxisView::build_automation_action_menu (bool for_selection) MenuElem (string_compose ("%1", _("No MIDI Channels selected")))); dynamic_cast (automation_items.back().get_child())->set_use_markup (true); } - - automation_items.push_back (SeparatorElem()); - automation_items.push_back (CheckMenuElem (_("Fader"), sigc::mem_fun (*this, &MidiTimeAxisView::update_gain_track_visibility))); - gain_automation_item = dynamic_cast (&automation_items.back ()); - gain_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) && - (gain_track && string_is_affirmative (gain_track->gui_property ("visible")))); - - _main_automation_menu_map[Evoral::Parameter(GainAutomation)] = gain_automation_item; - - if (!pan_tracks.empty()) { - automation_items.push_back (CheckMenuElem (_("Pan"), sigc::mem_fun (*this, &MidiTimeAxisView::update_pan_track_visibility))); - pan_automation_item = dynamic_cast (&automation_items.back ()); - pan_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) && - (!pan_tracks.empty() && string_is_affirmative (pan_tracks.front()->gui_property ("visible")))); - - set const & params = _route->pannable()->what_can_be_automated (); - for (set::const_iterator p = params.begin(); p != params.end(); ++p) { - _main_automation_menu_map[*p] = pan_automation_item; - } - } - } void @@ -755,7 +752,7 @@ MidiTimeAxisView::add_single_channel_controller_item(Menu_Helpers::MenuList& ctl Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl); ctl_items.push_back ( CheckMenuElem ( - string_compose ("%1: %2 [%3]", ctl, name, int (chn)), + string_compose ("%1: %2 [%3]", ctl, name, int (chn + 1)), sigc::bind ( sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track), fully_qualified_param))); @@ -916,7 +913,7 @@ MidiTimeAxisView::build_controller_menu () 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(); @@ -926,7 +923,7 @@ MidiTimeAxisView::build_controller_menu () /* Create a new submenu */ ctl_menu = manage (new Menu); } - + MenuList& ctl_items (ctl_menu->items()); if (chn_cnt > 1) { add_multi_channel_controller_item(ctl_items, ctl, c->second->name()); @@ -1064,7 +1061,7 @@ MidiTimeAxisView::set_color_mode (ColorMode mode, bool force, bool redisplay, bo if (_color_mode == mode && !force) { return; } - + if (_channel_selector) { if (mode == ChannelColors) { _channel_selector->set_channel_colors(NoteBase::midi_channel_colors); @@ -1072,7 +1069,7 @@ MidiTimeAxisView::set_color_mode (ColorMode mode, bool force, bool redisplay, bo _channel_selector->set_default_channel_color(); } } - + _color_mode = mode; set_gui_property ("color-mode", enum_2_string(_color_mode)); if (redisplay) { @@ -1106,107 +1103,59 @@ MidiTimeAxisView::update_range() } } -void -MidiTimeAxisView::ensure_pan_views (bool show) -{ - bool changed = false; - for (list >::iterator i = pan_tracks.begin(); i != pan_tracks.end(); ++i) { - changed = true; - (*i)->set_marked_for_display (false); - } - if (changed) { - _route->gui_changed (X_("visible_tracks"), (void *) 0); /* EMIT_SIGNAL */ - } - pan_tracks.clear(); - - if (!_route->panner()) { - return; - } - - set params = _route->panner()->what_can_be_automated(); - set::iterator p; - - for (p = params.begin(); p != params.end(); ++p) { - boost::shared_ptr pan_control = _route->pannable()->automation_control(*p); - - if (pan_control->parameter().type() == NullAutomation) { - error << "Pan control has NULL automation type!" << endmsg; - continue; - } - - if (automation_child (pan_control->parameter ()).get () == 0) { - - /* we don't already have an AutomationTimeAxisView for this parameter */ - - std::string const name = _route->panner()->describe_parameter (pan_control->parameter ()); - - boost::shared_ptr t ( - new AutomationTimeAxisView (_session, - _route, - _route->pannable(), - pan_control, - pan_control->parameter (), - _editor, - *this, - false, - parent_canvas, - name) - ); - - pan_tracks.push_back (t); - add_automation_child (*p, t, show); - } else { - pan_tracks.push_back (automation_child (pan_control->parameter ())); - } - } -} - -void -MidiTimeAxisView::update_gain_track_visibility () -{ - bool const showit = gain_automation_item->get_active(); - - if (showit != string_is_affirmative (gain_track->gui_property ("visible"))) { - gain_track->set_marked_for_display (showit); - - /* now trigger a redisplay */ - - if (!no_redraw) { - _route->gui_changed (X_("visible_tracks"), (void *) 0); /* EMIT_SIGNAL */ - } - } -} - -void -MidiTimeAxisView::update_pan_track_visibility () -{ - bool const showit = pan_automation_item->get_active(); - bool changed = false; - - for (list >::iterator i = pan_tracks.begin(); i != pan_tracks.end(); ++i) { - if ((*i)->set_marked_for_display (showit)) { - changed = true; - } - } - - if (changed) { - _route->gui_changed (X_("visible_tracks"), (void *) 0); /* EMIT_SIGNAL */ - } -} - void MidiTimeAxisView::show_all_automation (bool apply_to_selection) { + 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); } + + // 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 (); @@ -1250,7 +1199,9 @@ MidiTimeAxisView::create_automation_child (const Evoral::Parameter& param, bool * since it will have been set visible by default. */ - if (existing->second->set_marked_for_display (show) && !no_redraw) { + existing->second->set_marked_for_display (show); + + if (!no_redraw) { request_redraw (); } @@ -1258,6 +1209,8 @@ MidiTimeAxisView::create_automation_child (const Evoral::Parameter& param, bool } boost::shared_ptr track; + boost::shared_ptr control; + switch (param.type()) { @@ -1265,6 +1218,10 @@ MidiTimeAxisView::create_automation_child (const Evoral::Parameter& param, bool create_gain_automation_child (param, show); break; + case MuteAutomation: + create_mute_automation_child (param, show); + break; + case PluginAutomation: /* handled elsewhere */ break; @@ -1276,15 +1233,19 @@ MidiTimeAxisView::create_automation_child (const Evoral::Parameter& param, bool case MidiSystemExclusiveAutomation: /* These controllers are region "automation" - they are owned * by regions (and their MidiModels), not by the track. As a - * result we do not create an AutomationList/Line for the track - * ... except here we are doing something!! XXX + * 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, - boost::shared_ptr (), - boost::shared_ptr (), + control ? _route : boost::shared_ptr (), + control, param, _editor, *this, @@ -1316,39 +1277,46 @@ 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 { + } 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"; } } + + if (selected()) { + controls_ebox.set_name (controls_base_selected_name); + time_axis_frame.set_name (controls_base_selected_name); + } else { + controls_ebox.set_name (controls_base_unselected_name); + time_axis_frame.set_name (controls_base_unselected_name); + } } void MidiTimeAxisView::set_note_selection (uint8_t note) { - if (!_editor.internal_editing()) { - return; - } - uint16_t chn_mask = midi_track()->get_playback_channel_mask(); + _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), @@ -1358,17 +1326,17 @@ MidiTimeAxisView::set_note_selection (uint8_t note) sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection_region_view), note, chn_mask)); } + + _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(); + _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), @@ -1378,17 +1346,17 @@ MidiTimeAxisView::add_note_selection (uint8_t note) 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(); + _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), @@ -1398,17 +1366,17 @@ MidiTimeAxisView::extend_note_selection (uint8_t note) 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(); + _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), @@ -1418,6 +1386,15 @@ MidiTimeAxisView::toggle_note_selection (uint8_t note) sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection_region_view), note, chn_mask)); } + + _editor.commit_reversible_selection_op(); +} + +void +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 @@ -1444,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) { @@ -1513,14 +1508,15 @@ MidiTimeAxisView::automation_child_menu_item (Evoral::Parameter param) } boost::shared_ptr -MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit) +MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit, const int32_t sub_num) { Editor* real_editor = dynamic_cast (&_editor); - - real_editor->begin_reversible_command (Operations::create_region); + if (commit) { + real_editor->begin_reversible_command (Operations::create_region); + } playlist()->clear_changes (); - real_editor->snap_to (pos, 0); + real_editor->snap_to (pos, RoundNearest); boost::shared_ptr src = _session->create_midi_source_by_stealing_name (view()->trackview().track()); PropertyList plist; @@ -1530,8 +1526,9 @@ MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit) plist.add (ARDOUR::Properties::name, PBD::basename_nosuffix(src->name())); boost::shared_ptr region = (RegionFactory::create (src, plist)); - - playlist()->add_region (region, pos); + /* 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) { @@ -1602,7 +1599,7 @@ MidiTimeAxisView::note_range_changed () void MidiTimeAxisView::contents_height_changed () { - _range_scroomer->set_size_request (-1, _view->child_height ()); + _range_scroomer->queue_resize (); } void @@ -1636,3 +1633,14 @@ MidiTimeAxisView::capture_channel_mode_changed () 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); +}