#include <sigc++/bind.h>
+#include <gtkmm/separator.h>
+#include <gtkmm/stock.h>
+
#include "pbd/error.h"
#include "pbd/ffs.h"
#include "pbd/stl_delete.h"
#include "pbd/stateful_diff_command.h"
#include "gtkmm2ext/gtk_ui.h"
-#include "gtkmm2ext/selector.h"
-#include "gtkmm2ext/bindable_button.h"
#include "gtkmm2ext/utils.h"
+#include "widgets/tooltips.h"
+
#include "ardour/event_type_map.h"
#include "ardour/midi_patch_manager.h"
#include "ardour/midi_playlist.h"
#include "ardour/panner.h"
#include "ardour/panner_shell.h"
#include "ardour/playlist.h"
+#include "ardour/plugin_insert.h"
+#include "ardour/profile.h"
#include "ardour/region.h"
#include "ardour/region_factory.h"
#include "ardour/route.h"
#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"
#include "editor.h"
#include "midi_streamview.h"
#include "midi_region_view.h"
#include "midi_time_axis.h"
+#include "patch_change_dialog.h"
#include "piano_roll_header.h"
#include "playlist_selector.h"
#include "plugin_selector.h"
#include "plugin_ui.h"
#include "point_selection.h"
-#include "prompter.h"
#include "region_view.h"
#include "rgb_macros.h"
#include "selection.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 = 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)
, _channel_selector (0)
, _step_edit_item (0)
, controller_menu (0)
+ , poly_pressure_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<Route> rt)
{
_route = rt;
-
+
_view = new MidiStreamView (*this);
if (is_track ()) {
*/
RouteTimeAxisView::set_route (rt);
- _view->apply_color (_color, StreamView::RegionColor);
+ _view->apply_color (ARDOUR_UI_UTILS::gdk_color_to_rgba (color()), StreamView::RegionColor);
subplugin_menu.set_name ("ArdourContextMenu");
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");
}
/* if set_state above didn't create a gain automation child, we need to make one */
/* map current state of the route */
ensure_pan_views (false);
-
+ update_control_names();
processors_changed (RouteProcessorChange ());
_route->processors_changed.connect (*this, invalidator (*this),
_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 */
+ /* Update StreamView during scroomer drags.*/
+
_range_scroomer->DragStarting.connect (
- sigc::mem_fun (*midi_view(), &MidiStreamView::suspend_updates));
+ sigc::mem_fun (*this, &MidiTimeAxisView::start_scroomer_update));
_range_scroomer->DragFinishing.connect (
- sigc::mem_fun (*midi_view(), &MidiStreamView::resume_updates));
+ sigc::mem_fun (*this, &MidiTimeAxisView::stop_scroomer_update));
/* 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.
*/
+
+ 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));
_view->RegionViewAdded.connect (
sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added));
- midi_track()->PlaybackChannelModeChanged.connect (*this, invalidator (*this),
- boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this),
- gui_context());
- midi_track()->PlaybackChannelMaskChanged.connect (*this, invalidator (*this),
- boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this),
- gui_context());
- midi_track()->CaptureChannelModeChanged.connect (*this, invalidator (*this),
- boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this),
- gui_context());
- midi_track()->CaptureChannelMaskChanged.connect (*this, invalidator (*this),
- boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this),
- gui_context());
-
- playback_channel_mode_changed ();
- capture_channel_mode_changed ();
-
if (!_editor.have_idled()) {
/* first idle will do what we need */
} else {
}
}
- MIDI::Name::MidiPatchManager& patch_manager = MIDI::Name::MidiPatchManager::instance();
-
- 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());
- }
-
if (gui_property (X_("midnam-model-name")).empty()) {
set_gui_property (X_("midnam-model-name"), "Generic");
}
}
}
- _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")));
+ ArdourWidgets::set_tooltip (_midnam_model_selector, _("External MIDI Device"));
+ ArdourWidgets::set_tooltip (_midnam_custom_device_mode_selector, _("External 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"));
+ _midi_controls_box.pack_start (_midnam_model_selector, false, false, 2);
+ _midi_controls_box.pack_start (_midnam_custom_device_mode_selector, false, false, 2);
_midi_controls_box.set_homogeneous(false);
- _midi_controls_box.set_border_width (10);
-
- _channel_status_box.set_homogeneous (false);
- _channel_status_box.set_spacing (6);
-
- _channel_selector_button.set_label (_("Chns"));
- ARDOUR_UI::instance()->set_tip (_channel_selector_button, _("Click to edit channel settings"));
-
- /* fixed sized labels to prevent silly nonsense (though obviously,
- * they cause their own too)
- */
-
- _playback_channel_status.set_size_request (65, -1);
- _capture_channel_status.set_size_request (60, -1);
-
- _channel_status_box.pack_start (_playback_channel_status, false, false);
- _channel_status_box.pack_start (_capture_channel_status, false, false);
- _channel_status_box.pack_start (_channel_selector_button, false, false);
- _channel_status_box.show_all ();
-
- _channel_selector_button.signal_clicked().connect (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_channel_selector));
-
- _midi_controls_box.pack_start (_channel_status_box, false, false, 10);
+ _midi_controls_box.set_border_width (2);
- if (!patch_manager.all_models().empty()) {
+ MIDI::Name::MidiPatchManager::instance().PatchesChanged.connect (*this, invalidator (*this),
+ boost::bind (&MidiTimeAxisView::setup_midnam_patches, this),
+ gui_context());
- _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);
-
- _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);
- }
+ setup_midnam_patches ();
+ update_patch_selector ();
- model_changed();
- custom_device_mode_changed();
-
- _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);
*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));
+ create_automation_child (parameter, string_to<bool> (visible));
}
}
}
+void
+MidiTimeAxisView::processors_changed (RouteProcessorChange c)
+{
+ RouteTimeAxisView::processors_changed (c);
+ update_patch_selector ();
+}
+
void
MidiTimeAxisView::first_idle ()
{
}
void
-MidiTimeAxisView::enter_internal_edit_mode ()
+MidiTimeAxisView::check_step_edit ()
{
- if (midi_view()) {
- midi_view()->enter_internal_edit_mode ();
- }
+ ensure_step_editor ();
+ _step_editor->check_step_edit ();
}
void
-MidiTimeAxisView::leave_internal_edit_mode ()
+MidiTimeAxisView::setup_midnam_patches ()
{
- if (midi_view()) {
- midi_view()->leave_internal_edit_mode ();
+ typedef MIDI::Name::MidiPatchManager PatchManager;
+ PatchManager& patch_manager = PatchManager::instance();
+
+ _midnam_model_selector.clear_items ();
+ 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 (!get_device_names()) {
+ model_changed ("Generic");
}
}
void
-MidiTimeAxisView::check_step_edit ()
+MidiTimeAxisView::drop_instrument_ref ()
{
- ensure_step_editor ();
- _step_editor->check_step_edit ();
+ midnam_connection.drop_connections ();
+}
+void
+MidiTimeAxisView::start_scroomer_update ()
+{
+ _note_range_changed_connection.disconnect();
+ _note_range_changed_connection = midi_view()->NoteRangeChanged.connect (
+ sigc::mem_fun (*this, &MidiTimeAxisView::note_range_changed));
+}
+void
+MidiTimeAxisView::stop_scroomer_update ()
+{
+ _note_range_changed_connection.disconnect();
}
void
-MidiTimeAxisView::model_changed()
+MidiTimeAxisView::update_patch_selector ()
+{
+ typedef MIDI::Name::MidiPatchManager PatchManager;
+ PatchManager& patch_manager = PatchManager::instance();
+
+ bool pluginprovided = false;
+ if (_route) {
+ boost::shared_ptr<Processor> the_instrument (_route->the_instrument());
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(the_instrument);
+ if (pi && pi->plugin ()->has_midnam ()) {
+ midnam_connection.drop_connections ();
+ the_instrument->DropReferences.connect (midnam_connection, invalidator (*this),
+ boost::bind (&MidiTimeAxisView::drop_instrument_ref, this),
+ gui_context());
+ pi->plugin()->UpdateMidnam.connect (midnam_connection, invalidator (*this),
+ boost::bind (&Plugin::read_midnam, pi->plugin ()),
+ gui_context());
+
+ pluginprovided = true;
+ std::string model_name = pi->plugin ()->midnam_model ();
+ if (gui_property (X_("midnam-model-name")) != model_name) {
+ model_changed (model_name);
+ }
+ }
+ }
+
+ if (patch_manager.all_models().empty() || pluginprovided) {
+ _midnam_model_selector.hide ();
+ _midnam_custom_device_mode_selector.hide ();
+ } else {
+ _midnam_model_selector.show ();
+ _midnam_custom_device_mode_selector.show ();
+ }
+}
+
+void
+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<std::string> 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<std::string>::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)));
+ }
+
+ if (!device_modes.empty()) {
+ custom_device_mode_changed(device_modes.front());
}
- _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.size() > 1) {
+ _midnam_custom_device_mode_selector.show();
+ } else {
+ _midnam_custom_device_mode_selector.hide();
+ }
+
+ // now this is a real bad hack
+ 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 ();
}
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*
}
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();
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
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 (
items.push_back (MenuElem (_("Channel Selector"),
sigc::mem_fun(*this, &MidiTimeAxisView::toggle_channel_selector)));
+ items.push_back (MenuElem (_("Select Patch..."),
+ sigc::mem_fun(*this, &MidiTimeAxisView::send_patch_change)));
+
color_mode_menu = build_color_mode_menu();
if (color_mode_menu) {
items.push_back (MenuElem (_("Color Mode"), *color_mode_menu));
}
-
+
items.push_back (SeparatorElem ());
}
build_controller_menu ();
- automation_items.push_back (SeparatorElem());
automation_items.push_back (MenuElem (_("Controllers"), *controller_menu));
+
+ if (!poly_pressure_menu) {
+ poly_pressure_menu = new Gtk::Menu;
+ }
+
+ automation_items.push_back (MenuElem (_("Polyphonic Pressure"), *poly_pressure_menu));
+
automation_items.back().set_sensitive (
!for_selection || _editor.get_selection().tracks.size() == 1);
} else {
MenuElem (string_compose ("<i>%1</i>", _("No MIDI Channels selected"))));
dynamic_cast<Label*> (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<Gtk::CheckMenuItem*> (&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<Gtk::CheckMenuItem*> (&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<Evoral::Parameter> const & params = _route->pannable()->what_can_be_automated ();
- for (set<Evoral::Parameter>::const_iterator p = params.begin(); p != params.end(); ++p) {
- _main_automation_menu_map[*p] = pan_automation_item;
- }
- }
-
}
void
l != device_names->controls().end(); ++l) {
boost::shared_ptr<ControlNameList> 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();
/* 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());
return mode_menu;
}
+void
+MidiTimeAxisView::send_patch_change ()
+{
+ if (!_route) {
+ return;
+ }
+
+ Evoral::PatchChange<Evoral::Beats> empty (Evoral::Beats(), 0, 0, 0);
+ PatchChangeDialog d (0, 0, empty, _route->instrument_info(), Gtk::Stock::OK);
+
+ if (d.run() == RESPONSE_CANCEL) {
+ return;
+ }
+ Evoral::PatchChange<Evoral::Beats> p (d.patch ());
+
+ uint8_t chn = p.channel();
+
+ boost::shared_ptr<AutomationControl> bank_msb = _route->automation_control(Evoral::Parameter (MidiCCAutomation, chn, MIDI_CTL_MSB_BANK), true);
+ boost::shared_ptr<AutomationControl> bank_lsb = _route->automation_control(Evoral::Parameter (MidiCCAutomation, chn, MIDI_CTL_LSB_BANK), true);
+ boost::shared_ptr<AutomationControl> program = _route->automation_control(Evoral::Parameter (MidiPgmChangeAutomation, chn), true);
+
+ if (!bank_msb || ! bank_lsb || !program) {
+ return;
+ }
+
+ bank_msb->set_value (p.bank_msb (), Controllable::NoGroup);
+ bank_lsb->set_value (p.bank_lsb (), Controllable::NoGroup);
+ program->set_value (p.program () , Controllable::NoGroup);
+}
+
void
MidiTimeAxisView::set_note_mode(NoteMode mode, bool apply_to_selection)
{
if (_color_mode == mode && !force) {
return;
}
-
+
if (_channel_selector) {
if (mode == ChannelColors) {
_channel_selector->set_channel_colors(NoteBase::midi_channel_colors);
_channel_selector->set_default_channel_color();
}
}
-
+
_color_mode = mode;
set_gui_property ("color-mode", enum_2_string(_color_mode));
if (redisplay) {
void
MidiTimeAxisView::update_range()
{
- MidiGhostRegion* mgr;
-
- for (list<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
- if ((mgr = dynamic_cast<MidiGhostRegion*>(*i)) != 0) {
- mgr->update_range();
- }
- }
-}
-
-void
-MidiTimeAxisView::ensure_pan_views (bool show)
-{
- bool changed = false;
- for (list<boost::shared_ptr<AutomationTimeAxisView> >::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<Evoral::Parameter> params = _route->panner()->what_can_be_automated();
- set<Evoral::Parameter>::iterator p;
-
- for (p = params.begin(); p != params.end(); ++p) {
- boost::shared_ptr<ARDOUR::AutomationControl> 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<AutomationTimeAxisView> 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<boost::shared_ptr<AutomationTimeAxisView> >::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
boost::shared_ptr<MasterDeviceNames> device_names = get_device_names();
if (gui_property (X_("midnam-model-name")) != "Generic" &&
device_names && !device_names->controls().empty()) {
- const std::string device_mode = _midnam_custom_device_mode_selector.get_active_text();
+ 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) {
* 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 ();
}
}
boost::shared_ptr<AutomationTimeAxisView> track;
+ boost::shared_ptr<AutomationControl> control;
+
switch (param.type()) {
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<Automatable> (),
- boost::shared_ptr<AutomationControl> (),
+ control ? _route : boost::shared_ptr<Automatable> (),
+ control,
param,
_editor,
*this,
}
add_automation_child (param, track, show);
+ if (selected ()) {
+ reshow_selection (_editor.get_selection().time);
+ }
+
break;
case PanWidthAutomation:
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),
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),
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),
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),
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<pair<PBD::ID, set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >& selection)
+{
+ _view->foreach_regionview (
+ sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::get_per_region_note_selection_region_view), sigc::ref(selection)));
}
void
dynamic_cast<MidiRegionView*>(rv)->toggle_matching_notes (note, chn_mask);
}
+void
+MidiTimeAxisView::get_per_region_note_selection_region_view (RegionView* rv, list<pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > > &selection)
+{
+ Evoral::Sequence<Evoral::Beats>::Notes selected;
+ dynamic_cast<MidiRegionView*>(rv)->selection_as_notelist (selected, false);
+
+ std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > notes;
+
+ Evoral::Sequence<Evoral::Beats>::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)
{
}
boost::shared_ptr<MidiRegion>
-MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit)
+MidiTimeAxisView::add_region (framepos_t f, framecnt_t length, bool commit)
{
Editor* real_editor = dynamic_cast<Editor*> (&_editor);
+ MusicFrame pos (f, 0);
- 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<Source> src = _session->create_midi_source_by_stealing_name (view()->trackview().track());
PropertyList plist;
plist.add (ARDOUR::Properties::name, PBD::basename_nosuffix(src->name()));
boost::shared_ptr<Region> region = (RegionFactory::create (src, plist));
-
- playlist()->add_region (region, pos);
+ /* sets beat position */
+ region->set_position (pos.frame, pos.division);
+ playlist()->add_region (region, pos.frame, 1.0, false, pos.division);
_session->add_command (new StatefulDiffCommand (playlist()));
if (commit) {
void
MidiTimeAxisView::contents_height_changed ()
{
- _range_scroomer->set_size_request (-1, _view->child_height ());
+ _range_scroomer->queue_resize ();
}
-void
-MidiTimeAxisView::playback_channel_mode_changed ()
+bool
+MidiTimeAxisView::paste (framepos_t pos, const Selection& selection, PasteContext& ctx, const int32_t sub_num)
{
- switch (midi_track()->get_playback_channel_mode()) {
- case AllChannels:
- _playback_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2</i>", _("Play"), _("all")));
- break;
- case FilterChannels:
- _playback_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2</i>", _("Play"), _("some")));
- break;
- case ForceChannel:
- _playback_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2>%3</i>", _("Play"), _("all"), PBD::ffs (midi_track()->get_playback_channel_mask())));
- break;
+ if (!_editor.internal_editing()) {
+ // Non-internal paste, paste regions like any other route
+ return RouteTimeAxisView::paste(pos, selection, ctx, sub_num);
}
-}
-void
-MidiTimeAxisView::capture_channel_mode_changed ()
-{
- switch (midi_track()->get_capture_channel_mode()) {
- case AllChannels:
- _capture_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2</i>", _("Rec"), _("all")));
- break;
- case FilterChannels:
- _capture_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2</i>", _("Rec"), _("some")));
- break;
- case ForceChannel:
- _capture_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2>%3</i>", _("Rec"), _("all"), PBD::ffs (midi_track()->get_capture_channel_mask())));
- break;
- }
+ return midi_view()->paste(pos, selection, ctx, sub_num);
}