2006-07-23 08:03:19 -04:00
|
|
|
/*
|
2009-10-14 12:10:01 -04:00
|
|
|
Copyright (C) 2000 Paul Davis
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <cmath>
|
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
#include <sigc++/bind.h>
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/error.h"
|
|
|
|
#include "pbd/stl_delete.h"
|
|
|
|
#include "pbd/whitespace.h"
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "pbd/basename.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/enumwriter.h"
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "pbd/memento_command.h"
|
2010-03-02 13:05:26 -05:00
|
|
|
#include "pbd/stateful_diff_command.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-07-16 10:55:11 -04:00
|
|
|
#include "gtkmm2ext/gtk_ui.h"
|
|
|
|
#include "gtkmm2ext/selector.h"
|
|
|
|
#include "gtkmm2ext/bindable_button.h"
|
|
|
|
#include "gtkmm2ext/utils.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-07-16 10:55:11 -04:00
|
|
|
#include "ardour/file_source.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/midi_playlist.h"
|
|
|
|
#include "ardour/midi_diskstream.h"
|
|
|
|
#include "ardour/midi_patch_manager.h"
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "ardour/midi_source.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/processor.h"
|
|
|
|
#include "ardour/ladspa_plugin.h"
|
|
|
|
#include "ardour/location.h"
|
|
|
|
#include "ardour/playlist.h"
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "ardour/region_factory.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/session.h"
|
|
|
|
#include "ardour/session_playlist.h"
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "ardour/tempo.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/utils.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-01-07 14:15:33 -05:00
|
|
|
#include "midi++/names.h"
|
|
|
|
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "add_midi_cc_track_dialog.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "ardour_ui.h"
|
2007-06-30 14:41:50 -04:00
|
|
|
#include "automation_line.h"
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "automation_time_axis.h"
|
|
|
|
#include "canvas-note-event.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "canvas_impl.h"
|
|
|
|
#include "crossfade_view.h"
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "editor.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "enums.h"
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "ghostregion.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "gui_thread.h"
|
|
|
|
#include "keyboard.h"
|
2009-09-03 08:39:50 -04:00
|
|
|
#include "midi_scroomer.h"
|
|
|
|
#include "midi_streamview.h"
|
|
|
|
#include "midi_region_view.h"
|
|
|
|
#include "midi_time_axis.h"
|
|
|
|
#include "piano_roll_header.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "playlist_selector.h"
|
|
|
|
#include "plugin_selector.h"
|
|
|
|
#include "plugin_ui.h"
|
|
|
|
#include "point_selection.h"
|
|
|
|
#include "prompter.h"
|
2006-08-01 13:19:38 -04:00
|
|
|
#include "region_view.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "rgb_macros.h"
|
|
|
|
#include "selection.h"
|
2010-08-15 12:39:51 -04:00
|
|
|
#include "step_editor.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "simplerect.h"
|
|
|
|
#include "utils.h"
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/midi_track.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
#include "i18n.h"
|
|
|
|
|
|
|
|
using namespace ARDOUR;
|
|
|
|
using namespace PBD;
|
|
|
|
using namespace Gtk;
|
2010-01-08 21:36:47 -05:00
|
|
|
using namespace Gtkmm2ext;
|
2006-07-23 08:03:19 -04:00
|
|
|
using namespace Editing;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-10-04 22:32:05 -04:00
|
|
|
// Minimum height at which a control is displayed
|
2008-12-09 03:35:02 -05:00
|
|
|
static const uint32_t MIDI_CONTROLS_BOX_MIN_HEIGHT = 162;
|
2008-10-04 22:32:05 -04:00
|
|
|
static const uint32_t KEYBOARD_MIN_HEIGHT = 140;
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session* sess,
|
2009-07-09 13:58:13 -04:00
|
|
|
boost::shared_ptr<Route> rt, Canvas& canvas)
|
2008-09-22 22:40:29 -04:00
|
|
|
: AxisView(sess) // virtually inherited
|
2007-07-06 23:19:04 -04:00
|
|
|
, RouteTimeAxisView(ed, sess, rt, canvas)
|
2009-10-14 12:10:01 -04:00
|
|
|
, _ignore_signals(false)
|
2008-01-13 12:45:17 -05:00
|
|
|
, _range_scroomer(0)
|
|
|
|
, _piano_roll_header(0)
|
2007-08-17 13:25:20 -04:00
|
|
|
, _note_mode(Sustained)
|
2008-12-23 20:24:49 -05:00
|
|
|
, _note_mode_item(0)
|
|
|
|
, _percussion_mode_item(0)
|
|
|
|
, _color_mode(MeterColors)
|
|
|
|
, _meter_color_mode_item(0)
|
|
|
|
, _channel_color_mode_item(0)
|
|
|
|
, _track_color_mode_item(0)
|
2009-09-25 15:00:34 -04:00
|
|
|
, _step_edit_item (0)
|
|
|
|
, _midi_thru_item (0)
|
|
|
|
, default_channel_menu (0)
|
2010-01-08 21:36:47 -05:00
|
|
|
, controller_menu (0)
|
2010-08-17 10:45:59 -04:00
|
|
|
, _step_editor (0)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
|
|
|
subplugin_menu.set_name ("ArdourContextMenu");
|
|
|
|
|
2009-07-09 13:58:13 -04:00
|
|
|
_view = new MidiStreamView (*this);
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
ignore_toggle = false;
|
2010-01-06 16:56:23 -05:00
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
mute_button->set_active (false);
|
|
|
|
solo_button->set_active (false);
|
2009-09-10 18:20:37 -04:00
|
|
|
|
2007-07-06 23:19:04 -04:00
|
|
|
if (is_midi_track()) {
|
2006-07-23 08:03:19 -04:00
|
|
|
controls_ebox.set_name ("MidiTimeAxisViewControlsBaseUnselected");
|
2007-07-06 23:19:04 -04:00
|
|
|
_note_mode = midi_track()->note_mode();
|
|
|
|
} else { // MIDI bus (which doesn't exist yet..)
|
2006-07-23 08:03:19 -04:00
|
|
|
controls_ebox.set_name ("MidiBusControlsBaseUnselected");
|
2007-07-06 23:19:04 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
/* map current state of the route */
|
|
|
|
|
2009-11-30 18:16:28 -05:00
|
|
|
processors_changed (RouteProcessorChange ());
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
ensure_xml_node ();
|
|
|
|
|
2009-10-15 14:56:11 -04:00
|
|
|
set_state (*xml_node, Stateful::loading_state_version);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-03-30 11:18:43 -04:00
|
|
|
_route->processors_changed.connect (*this, invalidator (*this), ui_bind (&MidiTimeAxisView::processors_changed, this, _1), gui_context());
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2006-08-14 04:44:14 -04:00
|
|
|
if (is_track()) {
|
2008-01-13 12:45:17 -05:00
|
|
|
_piano_roll_header = new PianoRollHeader(*midi_view());
|
2010-01-07 14:15:33 -05:00
|
|
|
|
|
|
|
_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));
|
|
|
|
|
2008-01-13 12:45:17 -05:00
|
|
|
_range_scroomer = new MidiScroomer(midi_view()->note_range_adjustment);
|
|
|
|
|
|
|
|
controls_hbox.pack_start(*_range_scroomer);
|
|
|
|
controls_hbox.pack_start(*_piano_roll_header);
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
controls_ebox.set_name ("MidiTrackControlsBaseUnselected");
|
|
|
|
controls_base_selected_name = "MidiTrackControlsBaseSelected";
|
|
|
|
controls_base_unselected_name = "MidiTrackControlsBaseUnselected";
|
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
midi_view()->NoteRangeChanged.connect (sigc::mem_fun(*this, &MidiTimeAxisView::update_range));
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
/* ask for notifications of any new RegionViews */
|
2009-12-11 18:29:48 -05:00
|
|
|
_view->RegionViewAdded.connect (sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added));
|
2006-08-14 04:44:14 -04:00
|
|
|
_view->attach ();
|
2010-07-27 11:42:14 -04:00
|
|
|
|
2007-09-05 22:30:39 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-09 03:35:02 -05:00
|
|
|
HBox* midi_controls_hbox = manage(new HBox());
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-09 02:42:19 -05:00
|
|
|
MIDI::Name::MidiPatchManager& patch_manager = MIDI::Name::MidiPatchManager::instance();
|
|
|
|
|
2009-02-16 00:13:05 -05:00
|
|
|
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());
|
2008-12-09 02:42:19 -05:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
_model_selector.signal_changed().connect(sigc::mem_fun(*this, &MidiTimeAxisView::model_changed));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-11 03:06:27 -05:00
|
|
|
_custom_device_mode_selector.signal_changed().connect(
|
2009-12-11 18:29:48 -05:00
|
|
|
sigc::mem_fun(*this, &MidiTimeAxisView::custom_device_mode_changed));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-10 05:54:45 -05:00
|
|
|
// TODO: persist the choice
|
2008-12-11 03:06:27 -05:00
|
|
|
// this initializes the comboboxes and sends out the signal
|
|
|
|
_model_selector.set_active(0);
|
|
|
|
|
2008-12-09 03:35:02 -05:00
|
|
|
midi_controls_hbox->pack_start(_channel_selector, true, false);
|
2008-12-10 05:54:45 -05:00
|
|
|
if (!patch_manager.all_models().empty()) {
|
2008-12-11 03:06:27 -05:00
|
|
|
_midi_controls_box.pack_start(_model_selector, true, false);
|
|
|
|
_midi_controls_box.pack_start(_custom_device_mode_selector, true, false);
|
2008-12-10 05:54:45 -05:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-09 03:35:02 -05:00
|
|
|
_midi_controls_box.pack_start(*midi_controls_hbox, true, true);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-09 03:35:02 -05:00
|
|
|
controls_vbox.pack_start(_midi_controls_box, false, false);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-04-21 11:10:13 -04:00
|
|
|
// restore channel selector settings
|
2010-04-21 17:29:15 -04:00
|
|
|
_channel_selector.set_channel_mode(midi_track()->get_channel_mode(), midi_track()->get_channel_mask());
|
2008-05-11 22:40:48 -04:00
|
|
|
_channel_selector.mode_changed.connect(
|
2010-04-21 17:29:15 -04:00
|
|
|
sigc::mem_fun(*midi_track(), &MidiTrack::set_channel_mode));
|
2010-01-08 21:36:47 -05:00
|
|
|
_channel_selector.mode_changed.connect(
|
|
|
|
sigc::mem_fun(*this, &MidiTimeAxisView::set_channel_mode));
|
2008-04-21 05:39:05 -04:00
|
|
|
|
2008-12-28 20:02:41 -05:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
2009-10-07 11:41:12 -04:00
|
|
|
|
|
|
|
if ((prop = xml_node->property ("note-mode")) != 0) {
|
|
|
|
_note_mode = NoteMode (string_2_enum(prop->value(), _note_mode));
|
2009-10-22 12:10:21 -04:00
|
|
|
if (_percussion_mode_item) {
|
2009-10-07 11:41:12 -04:00
|
|
|
_percussion_mode_item->set_active (_note_mode == Percussive);
|
|
|
|
}
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
MidiTimeAxisView::~MidiTimeAxisView ()
|
|
|
|
{
|
2008-02-21 20:45:29 -05:00
|
|
|
delete _piano_roll_header;
|
|
|
|
_piano_roll_header = 0;
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2008-02-21 20:45:29 -05:00
|
|
|
delete _range_scroomer;
|
|
|
|
_range_scroomer = 0;
|
2010-01-07 14:15:33 -05:00
|
|
|
|
|
|
|
delete controller_menu;
|
2010-08-15 12:39:51 -04:00
|
|
|
delete _step_editor;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2010-07-27 11:42:14 -04:00
|
|
|
void
|
2010-08-15 12:39:51 -04:00
|
|
|
MidiTimeAxisView::check_step_edit ()
|
2010-07-27 11:42:14 -04:00
|
|
|
{
|
2010-08-15 12:39:51 -04:00
|
|
|
_step_editor->check_step_edit ();
|
2010-07-27 11:42:14 -04:00
|
|
|
}
|
|
|
|
|
2010-08-15 12:39:51 -04:00
|
|
|
void
|
|
|
|
MidiTimeAxisView::model_changed()
|
2008-12-11 03:06:27 -05:00
|
|
|
{
|
|
|
|
std::list<std::string> device_modes = MIDI::Name::MidiPatchManager::instance()
|
|
|
|
.custom_device_mode_names_by_model(_model_selector.get_active_text());
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-11 03:06:27 -05:00
|
|
|
_custom_device_mode_selector.clear_items();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-02-16 00:13:05 -05:00
|
|
|
for (std::list<std::string>::const_iterator i = device_modes.begin();
|
|
|
|
i != device_modes.end(); ++i) {
|
2008-12-12 01:57:38 -05:00
|
|
|
cerr << "found custom device mode " << *i << " thread_id: " << pthread_self() << endl;
|
2008-12-11 03:06:27 -05:00
|
|
|
_custom_device_mode_selector.append_text(*i);
|
|
|
|
}
|
|
|
|
|
|
|
|
_custom_device_mode_selector.set_active(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MidiTimeAxisView::custom_device_mode_changed()
|
|
|
|
{
|
2009-02-16 00:13:05 -05:00
|
|
|
_midi_patch_settings_changed.emit(_model_selector.get_active_text(),
|
2009-10-14 12:10:01 -04:00
|
|
|
_custom_device_mode_selector.get_active_text());
|
2008-12-11 03:06:27 -05:00
|
|
|
}
|
|
|
|
|
2007-07-05 03:02:24 -04:00
|
|
|
MidiStreamView*
|
|
|
|
MidiTimeAxisView::midi_view()
|
|
|
|
{
|
|
|
|
return dynamic_cast<MidiStreamView*>(_view);
|
|
|
|
}
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
guint32
|
|
|
|
MidiTimeAxisView::show_at (double y, int& nth, Gtk::VBox *parent)
|
|
|
|
{
|
|
|
|
ensure_xml_node ();
|
2008-10-05 19:14:48 -04:00
|
|
|
xml_node->add_property ("shown-editor", "yes");
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-01-13 16:34:04 -05:00
|
|
|
guint32 ret = TimeAxisView::show_at (y, nth, parent);
|
|
|
|
return ret;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::hide ()
|
|
|
|
{
|
|
|
|
ensure_xml_node ();
|
2008-10-05 19:14:48 -04:00
|
|
|
xml_node->add_property ("shown-editor", "no");
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
TimeAxisView::hide ();
|
|
|
|
}
|
|
|
|
|
2008-09-27 14:07:37 -04:00
|
|
|
void
|
|
|
|
MidiTimeAxisView::set_height (uint32_t h)
|
|
|
|
{
|
|
|
|
RouteTimeAxisView::set_height (h);
|
|
|
|
|
2008-12-09 03:35:02 -05:00
|
|
|
if (height >= MIDI_CONTROLS_BOX_MIN_HEIGHT) {
|
2010-05-22 22:41:08 -04:00
|
|
|
_midi_controls_box.show_all ();
|
2008-10-04 22:32:05 -04:00
|
|
|
} else {
|
2008-12-09 03:35:02 -05:00
|
|
|
_midi_controls_box.hide();
|
2008-10-04 22:32:05 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-10-04 22:32:05 -04:00
|
|
|
if (height >= KEYBOARD_MIN_HEIGHT) {
|
2008-09-27 14:07:37 -04:00
|
|
|
if (is_track() && _range_scroomer)
|
|
|
|
_range_scroomer->show();
|
|
|
|
if (is_track() && _piano_roll_header)
|
|
|
|
_piano_roll_header->show();
|
|
|
|
} else {
|
|
|
|
if (is_track() && _range_scroomer)
|
|
|
|
_range_scroomer->hide();
|
|
|
|
if (is_track() && _piano_roll_header)
|
|
|
|
_piano_roll_header->hide();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-14 21:56:11 -04:00
|
|
|
void
|
|
|
|
MidiTimeAxisView::append_extra_display_menu_items ()
|
|
|
|
{
|
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
|
|
|
MenuList& items = display_menu->items();
|
|
|
|
|
|
|
|
// Note range
|
|
|
|
Menu *range_menu = manage(new Menu);
|
|
|
|
MenuList& range_items = range_menu->items();
|
|
|
|
range_menu->set_name ("ArdourContextMenu");
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
range_items.push_back (MenuElem (_("Show Full Range"), sigc::bind (
|
|
|
|
sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range),
|
2007-07-14 21:56:11 -04:00
|
|
|
MidiStreamView::FullRange)));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
range_items.push_back (MenuElem (_("Fit Contents"), sigc::bind (
|
|
|
|
sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range),
|
2007-07-14 21:56:11 -04:00
|
|
|
MidiStreamView::ContentsRange)));
|
|
|
|
|
|
|
|
items.push_back (MenuElem (_("Note range"), *range_menu));
|
2009-02-15 16:19:01 -05:00
|
|
|
items.push_back (MenuElem (_("Note mode"), *build_note_mode_menu()));
|
2009-09-25 15:00:34 -04:00
|
|
|
items.push_back (MenuElem (_("Default Channel"), *build_def_channel_menu()));
|
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
items.push_back (CheckMenuElem (_("MIDI Thru"), sigc::mem_fun(*this, &MidiTimeAxisView::toggle_midi_thru)));
|
2009-09-25 15:00:34 -04:00
|
|
|
_midi_thru_item = dynamic_cast<CheckMenuItem*>(&items.back());
|
|
|
|
}
|
|
|
|
|
|
|
|
Gtk::Menu*
|
|
|
|
MidiTimeAxisView::build_def_channel_menu ()
|
|
|
|
{
|
|
|
|
using namespace Menu_Helpers;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-01-05 09:57:01 -05:00
|
|
|
default_channel_menu = manage (new Menu ());
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-09-25 15:00:34 -04:00
|
|
|
uint8_t defchn = midi_track()->default_channel();
|
|
|
|
MenuList& def_channel_items = default_channel_menu->items();
|
|
|
|
RadioMenuItem* item;
|
|
|
|
RadioMenuItem::Group dc_group;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-09-25 15:00:34 -04:00
|
|
|
for (int i = 0; i < 16; ++i) {
|
|
|
|
char buf[4];
|
|
|
|
snprintf (buf, sizeof (buf), "%d", i+1);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-09-25 15:00:34 -04:00
|
|
|
def_channel_items.push_back (RadioMenuElem (dc_group, buf,
|
2009-12-11 18:29:48 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_default_channel), i)));
|
2009-09-25 15:00:34 -04:00
|
|
|
item = dynamic_cast<RadioMenuItem*>(&def_channel_items.back());
|
|
|
|
item->set_active ((i == defchn));
|
|
|
|
}
|
|
|
|
|
|
|
|
return default_channel_menu;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::set_default_channel (int chn)
|
|
|
|
{
|
|
|
|
midi_track()->set_default_channel (chn);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::toggle_midi_thru ()
|
|
|
|
{
|
|
|
|
if (!_midi_thru_item) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool view_yn = _midi_thru_item->get_active();
|
|
|
|
if (view_yn != midi_track()->midi_thru()) {
|
|
|
|
midi_track()->set_midi_thru (view_yn);
|
|
|
|
}
|
2007-07-14 21:56:11 -04:00
|
|
|
}
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
void
|
2007-06-27 11:51:50 -04:00
|
|
|
MidiTimeAxisView::build_automation_action_menu ()
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2007-06-27 11:51:50 -04:00
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
2010-05-16 14:04:47 -04:00
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
|
2010-06-08 17:48:38 -04:00
|
|
|
_channel_command_menu_map.clear ();
|
2007-06-27 11:51:50 -04:00
|
|
|
RouteTimeAxisView::build_automation_action_menu ();
|
|
|
|
|
|
|
|
MenuList& automation_items = automation_action_menu->items();
|
2010-01-08 21:36:47 -05:00
|
|
|
|
|
|
|
uint16_t selected_channels = _channel_selector.get_selected_channels();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2010-06-08 17:48:38 -04:00
|
|
|
add_channel_command_menu_item (automation_items, _("Program Change"), MidiPgmChangeAutomation, 0);
|
|
|
|
add_channel_command_menu_item (automation_items, _("Bender"), MidiPitchBenderAutomation, 0);
|
|
|
|
add_channel_command_menu_item (automation_items, _("Pressure"), MidiChannelPressureAutomation, 0);
|
2010-01-08 21:36:47 -05:00
|
|
|
|
|
|
|
/* now all MIDI controllers. Always offer the possibility that we will rebuild the controllers menu
|
|
|
|
since it might need to be updated after a channel mode change or other change. Also detach it
|
|
|
|
first in case it has been used anywhere else.
|
|
|
|
*/
|
|
|
|
|
|
|
|
build_controller_menu ();
|
|
|
|
|
|
|
|
automation_items.push_back (SeparatorElem());
|
|
|
|
automation_items.push_back (MenuElem (_("Controllers"), *controller_menu));
|
|
|
|
} else {
|
|
|
|
automation_items.push_back (MenuElem (string_compose ("<i>%1</i>", _("No MIDI Channels selected"))));
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2010-01-06 16:56:23 -05:00
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
void
|
|
|
|
MidiTimeAxisView::change_all_channel_tracks_visibility (bool yn, Evoral::Parameter param)
|
|
|
|
{
|
|
|
|
uint16_t selected_channels = _channel_selector.get_selected_channels();
|
|
|
|
|
|
|
|
for (uint8_t chn = 0; chn < 16; chn++) {
|
|
|
|
if (selected_channels & (0x0001 << chn)) {
|
|
|
|
|
|
|
|
Evoral::Parameter fully_qualified_param (param.type(), chn, param.id());
|
2010-05-25 10:50:45 -04:00
|
|
|
Gtk::CheckMenuItem* menu = automation_child_menu_item (fully_qualified_param);
|
2010-01-07 14:15:33 -05:00
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
if (menu) {
|
|
|
|
menu->set_active (yn);
|
2010-01-08 21:36:47 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items, const string& label, AutomationType auto_type, uint8_t cmd)
|
|
|
|
{
|
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
|
|
|
/* count the number of selected channels because we will build a different menu structure if there is more than 1 selected.
|
|
|
|
*/
|
2010-01-07 14:15:33 -05:00
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
uint16_t selected_channels = _channel_selector.get_selected_channels();
|
|
|
|
int chn_cnt = 0;
|
|
|
|
|
|
|
|
for (uint8_t chn = 0; chn < 16; chn++) {
|
|
|
|
if (selected_channels & (0x0001 << chn)) {
|
|
|
|
if (++chn_cnt > 1) {
|
|
|
|
break;
|
2010-01-07 14:15:33 -05:00
|
|
|
}
|
|
|
|
}
|
2010-01-08 21:36:47 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if (chn_cnt > 1) {
|
|
|
|
|
|
|
|
/* multiple channels - create a submenu, with 1 item per channel */
|
|
|
|
|
|
|
|
Menu* chn_menu = manage (new Menu);
|
|
|
|
MenuList& chn_items (chn_menu->items());
|
|
|
|
Evoral::Parameter param_without_channel (auto_type, 0, cmd);
|
|
|
|
|
|
|
|
/* add a couple of items to hide/show all of them */
|
|
|
|
|
|
|
|
chn_items.push_back (MenuElem (_("Hide all channels"),
|
|
|
|
sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility),
|
|
|
|
false, param_without_channel)));
|
|
|
|
chn_items.push_back (MenuElem (_("Show all channels"),
|
|
|
|
sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility),
|
|
|
|
true, param_without_channel)));
|
|
|
|
|
|
|
|
for (uint8_t chn = 0; chn < 16; chn++) {
|
|
|
|
if (selected_channels & (0x0001 << chn)) {
|
|
|
|
|
|
|
|
/* for each selected channel, add a menu item for this controller */
|
|
|
|
|
|
|
|
Evoral::Parameter fully_qualified_param (auto_type, chn, cmd);
|
|
|
|
chn_items.push_back (CheckMenuElem (string_compose (_("Channel %1"), chn+1),
|
|
|
|
sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
|
|
|
|
fully_qualified_param)));
|
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
boost::shared_ptr<AutomationTimeAxisView> track = automation_child (fully_qualified_param);
|
2010-01-08 21:36:47 -05:00
|
|
|
bool visible = false;
|
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
if (track) {
|
|
|
|
if (track->marked_for_display()) {
|
2010-01-08 21:36:47 -05:00
|
|
|
visible = true;
|
|
|
|
}
|
|
|
|
}
|
2010-06-08 17:48:38 -04:00
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
CheckMenuItem* cmi = static_cast<CheckMenuItem*>(&chn_items.back());
|
2010-06-08 17:48:38 -04:00
|
|
|
_channel_command_menu_map[fully_qualified_param] = cmi;
|
2010-01-08 21:36:47 -05:00
|
|
|
cmi->set_active (visible);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now create an item in the parent menu that has the per-channel list as a submenu */
|
|
|
|
|
|
|
|
items.push_back (MenuElem (label, *chn_menu));
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* just one channel - create a single menu item for this command+channel combination*/
|
|
|
|
|
|
|
|
for (uint8_t chn = 0; chn < 16; chn++) {
|
|
|
|
if (selected_channels & (0x0001 << chn)) {
|
|
|
|
|
|
|
|
Evoral::Parameter fully_qualified_param (auto_type, chn, cmd);
|
|
|
|
items.push_back (CheckMenuElem (label,
|
|
|
|
sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
|
|
|
|
fully_qualified_param)));
|
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
boost::shared_ptr<AutomationTimeAxisView> track = automation_child (fully_qualified_param);
|
2010-01-08 21:36:47 -05:00
|
|
|
bool visible = false;
|
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
if (track) {
|
|
|
|
if (track->marked_for_display()) {
|
2010-01-08 21:36:47 -05:00
|
|
|
visible = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CheckMenuItem* cmi = static_cast<CheckMenuItem*>(&items.back());
|
2010-06-08 17:48:38 -04:00
|
|
|
_channel_command_menu_map[fully_qualified_param] = cmi;
|
2010-01-08 21:36:47 -05:00
|
|
|
cmi->set_active (visible);
|
|
|
|
|
|
|
|
/* one channel only */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-01-07 14:15:33 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::build_controller_menu ()
|
|
|
|
{
|
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
if (controller_menu) {
|
|
|
|
/* it exists and has not been invalidated by a channel mode change, so just return it */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
controller_menu = new Menu; // explicitly managed by us
|
2010-01-07 14:15:33 -05:00
|
|
|
MenuList& items (controller_menu->items());
|
|
|
|
|
|
|
|
/* create several "top level" menu items for sets of controllers (16 at a time), and populate each one with a submenu
|
|
|
|
for each controller+channel combination covering the currently selected channels for this track
|
|
|
|
*/
|
|
|
|
|
|
|
|
uint16_t selected_channels = _channel_selector.get_selected_channels();
|
|
|
|
|
|
|
|
/* count the number of selected channels because we will build a different menu structure if there is more than 1 selected.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int chn_cnt = 0;
|
|
|
|
|
|
|
|
for (uint8_t chn = 0; chn < 16; chn++) {
|
|
|
|
if (selected_channels & (0x0001 << chn)) {
|
|
|
|
if (++chn_cnt > 1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
/* loop over all 127 MIDI controllers, in groups of 16 */
|
|
|
|
|
2010-01-07 14:15:33 -05:00
|
|
|
for (int i = 0; i < 127; i += 16) {
|
|
|
|
|
|
|
|
Menu* ctl_menu = manage (new Menu);
|
|
|
|
MenuList& ctl_items (ctl_menu->items());
|
|
|
|
|
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
/* for each controller, consider whether to create a submenu or a single item */
|
|
|
|
|
|
|
|
for (int ctl = i; ctl < i+16; ++ctl) {
|
2010-01-07 14:15:33 -05:00
|
|
|
|
|
|
|
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());
|
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
/* 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)));
|
|
|
|
|
2010-01-07 14:15:33 -05:00
|
|
|
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),
|
2010-01-08 21:36:47 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
|
2010-01-07 14:15:33 -05:00
|
|
|
fully_qualified_param)));
|
2010-01-08 21:36:47 -05:00
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
boost::shared_ptr<AutomationTimeAxisView> track = automation_child (fully_qualified_param);
|
2010-01-07 14:15:33 -05:00
|
|
|
bool visible = false;
|
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
if (track) {
|
|
|
|
if (track->marked_for_display()) {
|
2010-01-07 14:15:33 -05:00
|
|
|
visible = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CheckMenuItem* cmi = static_cast<CheckMenuItem*>(&chn_items.back());
|
2010-06-08 17:48:38 -04:00
|
|
|
_controller_menu_map[fully_qualified_param] = cmi;
|
2010-01-07 14:15:33 -05:00
|
|
|
cmi->set_active (visible);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add the per-channel menu to the list of controllers, with the name of the controller */
|
2010-05-17 08:01:53 -04:00
|
|
|
ctl_items.push_back (MenuElem (string_compose ("<b>%1</b>: %2", ctl, midi_name (ctl)), *chn_menu));
|
|
|
|
dynamic_cast<Label*> (ctl_items.back().get_child())->set_use_markup (true);
|
|
|
|
|
2010-01-07 14:15:33 -05:00
|
|
|
} 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),
|
2010-01-08 21:36:47 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
|
2010-01-07 14:15:33 -05:00
|
|
|
fully_qualified_param)));
|
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
boost::shared_ptr<AutomationTimeAxisView> track = automation_child (fully_qualified_param);
|
2010-01-07 14:15:33 -05:00
|
|
|
bool visible = false;
|
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
if (track) {
|
|
|
|
if (track->marked_for_display()) {
|
2010-01-07 14:15:33 -05:00
|
|
|
visible = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CheckMenuItem* cmi = static_cast<CheckMenuItem*>(&ctl_items.back());
|
2010-06-08 17:48:38 -04:00
|
|
|
_controller_menu_map[fully_qualified_param] = cmi;
|
2010-01-07 14:15:33 -05:00
|
|
|
cmi->set_active (visible);
|
|
|
|
|
|
|
|
/* one channel only */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add the menu for this block of controllers to the overall controller menu */
|
|
|
|
|
2010-05-17 08:01:53 -04:00
|
|
|
items.push_back (MenuElem (string_compose (_("Controllers %1-%2"), i, i+15), *ctl_menu));
|
2010-01-07 14:15:33 -05:00
|
|
|
}
|
2010-01-06 16:56:23 -05:00
|
|
|
}
|
|
|
|
|
2007-07-06 23:19:04 -04:00
|
|
|
Gtk::Menu*
|
2008-12-28 20:02:41 -05:00
|
|
|
MidiTimeAxisView::build_note_mode_menu()
|
2007-07-06 23:19:04 -04:00
|
|
|
{
|
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
|
|
|
Menu* mode_menu = manage (new Menu);
|
|
|
|
MenuList& items = mode_menu->items();
|
|
|
|
mode_menu->set_name ("ArdourContextMenu");
|
|
|
|
|
|
|
|
RadioMenuItem::Group mode_group;
|
2007-07-28 03:09:21 -04:00
|
|
|
items.push_back (RadioMenuElem (mode_group, _("Sustained"),
|
2009-12-11 18:29:48 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_mode), Sustained)));
|
2007-07-06 23:19:04 -04:00
|
|
|
_note_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
|
2007-07-28 03:09:21 -04:00
|
|
|
_note_mode_item->set_active(_note_mode == Sustained);
|
2007-07-06 23:19:04 -04:00
|
|
|
|
2007-07-28 03:09:21 -04:00
|
|
|
items.push_back (RadioMenuElem (mode_group, _("Percussive"),
|
2009-12-11 18:29:48 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_mode), Percussive)));
|
2007-07-06 23:19:04 -04:00
|
|
|
_percussion_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
|
2007-07-28 03:09:21 -04:00
|
|
|
_percussion_mode_item->set_active(_note_mode == Percussive);
|
2007-07-06 23:19:04 -04:00
|
|
|
|
|
|
|
return mode_menu;
|
|
|
|
}
|
2008-12-23 20:24:49 -05:00
|
|
|
|
|
|
|
Gtk::Menu*
|
|
|
|
MidiTimeAxisView::build_color_mode_menu()
|
|
|
|
{
|
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
|
|
|
Menu* mode_menu = manage (new Menu);
|
|
|
|
MenuList& items = mode_menu->items();
|
|
|
|
mode_menu->set_name ("ArdourContextMenu");
|
|
|
|
|
|
|
|
RadioMenuItem::Group mode_group;
|
|
|
|
items.push_back (RadioMenuElem (mode_group, _("Meter Colors"),
|
2009-12-11 18:29:48 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode), MeterColors)));
|
2008-12-23 20:24:49 -05:00
|
|
|
_meter_color_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
|
|
|
|
_meter_color_mode_item->set_active(_color_mode == MeterColors);
|
|
|
|
|
|
|
|
items.push_back (RadioMenuElem (mode_group, _("Channel Colors"),
|
2009-12-11 18:29:48 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode), ChannelColors)));
|
2008-12-23 20:24:49 -05:00
|
|
|
_channel_color_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
|
|
|
|
_channel_color_mode_item->set_active(_color_mode == ChannelColors);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-23 20:24:49 -05:00
|
|
|
items.push_back (RadioMenuElem (mode_group, _("Track Color"),
|
2009-12-11 18:29:48 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode), TrackColor)));
|
2008-12-23 20:24:49 -05:00
|
|
|
_channel_color_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
|
|
|
|
_channel_color_mode_item->set_active(_color_mode == TrackColor);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-23 20:24:49 -05:00
|
|
|
return mode_menu;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-07-06 23:19:04 -04:00
|
|
|
void
|
|
|
|
MidiTimeAxisView::set_note_mode(NoteMode mode)
|
|
|
|
{
|
2008-01-14 22:32:51 -05:00
|
|
|
if (_note_mode != mode || midi_track()->note_mode() != mode) {
|
2007-07-06 23:19:04 -04:00
|
|
|
_note_mode = mode;
|
|
|
|
midi_track()->set_note_mode(mode);
|
2009-10-07 11:41:12 -04:00
|
|
|
xml_node->add_property ("note-mode", enum_2_string(_note_mode));
|
2010-04-21 16:42:22 -04:00
|
|
|
_view->redisplay_track();
|
2007-07-06 23:19:04 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-23 20:24:49 -05:00
|
|
|
void
|
|
|
|
MidiTimeAxisView::set_color_mode(ColorMode mode)
|
|
|
|
{
|
|
|
|
if (_color_mode != mode) {
|
2008-12-25 04:28:57 -05:00
|
|
|
if (mode == ChannelColors) {
|
|
|
|
_channel_selector.set_channel_colors(CanvasNoteEvent::midi_channel_colors);
|
|
|
|
} else {
|
|
|
|
_channel_selector.set_default_channel_color();
|
|
|
|
}
|
|
|
|
|
2008-12-23 20:24:49 -05:00
|
|
|
_color_mode = mode;
|
2008-12-28 20:02:41 -05:00
|
|
|
xml_node->add_property ("color-mode", enum_2_string(_color_mode));
|
2010-04-21 16:42:22 -04:00
|
|
|
_view->redisplay_track();
|
2008-12-23 20:24:49 -05:00
|
|
|
}
|
|
|
|
}
|
2007-07-14 21:56:11 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::set_note_range(MidiStreamView::VisibleNoteRange range)
|
|
|
|
{
|
2008-09-22 22:40:29 -04:00
|
|
|
if (!_ignore_signals)
|
2007-07-14 21:56:11 -04:00
|
|
|
midi_view()->set_note_range(range);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-10 13:16:25 -05:00
|
|
|
void
|
2008-02-18 22:24:44 -05:00
|
|
|
MidiTimeAxisView::update_range()
|
|
|
|
{
|
2008-02-10 13:16:25 -05:00
|
|
|
MidiGhostRegion* mgr;
|
|
|
|
|
|
|
|
for(list<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
|
2008-02-21 20:45:29 -05:00
|
|
|
if ((mgr = dynamic_cast<MidiGhostRegion*>(*i)) != 0) {
|
2008-02-10 13:16:25 -05:00
|
|
|
mgr->update_range();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-19 13:24:52 -04:00
|
|
|
void
|
|
|
|
MidiTimeAxisView::show_all_automation ()
|
|
|
|
{
|
|
|
|
if (midi_track()) {
|
2010-04-21 17:29:15 -04:00
|
|
|
const set<Evoral::Parameter> params = midi_track()->midi_playlist()->contained_automation();
|
2008-09-19 13:24:52 -04:00
|
|
|
|
2008-09-29 18:47:40 -04:00
|
|
|
for (set<Evoral::Parameter>::const_iterator i = params.begin(); i != params.end(); ++i) {
|
2008-09-19 13:24:52 -04:00
|
|
|
create_automation_child(*i, true);
|
2008-09-21 12:17:02 -04:00
|
|
|
}
|
2008-09-19 13:24:52 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RouteTimeAxisView::show_all_automation ();
|
|
|
|
}
|
|
|
|
|
2008-02-18 22:24:44 -05:00
|
|
|
void
|
|
|
|
MidiTimeAxisView::show_existing_automation ()
|
|
|
|
{
|
|
|
|
if (midi_track()) {
|
2010-04-21 17:29:15 -04:00
|
|
|
const set<Evoral::Parameter> params = midi_track()->midi_playlist()->contained_automation();
|
2008-02-18 22:24:44 -05:00
|
|
|
|
2008-09-29 18:47:40 -04:00
|
|
|
for (set<Evoral::Parameter>::const_iterator i = params.begin(); i != params.end(); ++i) {
|
2008-02-18 22:24:44 -05:00
|
|
|
create_automation_child(*i, true);
|
2008-09-21 12:17:02 -04:00
|
|
|
}
|
2008-02-18 22:24:44 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
RouteTimeAxisView::show_existing_automation ();
|
|
|
|
}
|
|
|
|
|
2010-06-08 17:48:38 -04:00
|
|
|
/** Create an automation track for the given parameter (pitch bend, channel pressure).
|
2010-01-06 16:56:23 -05:00
|
|
|
*/
|
2007-06-27 11:51:50 -04:00
|
|
|
void
|
2008-09-29 18:47:40 -04:00
|
|
|
MidiTimeAxisView::create_automation_child (const Evoral::Parameter& param, bool show)
|
2007-06-27 11:51:50 -04:00
|
|
|
{
|
2009-01-21 03:32:23 -05:00
|
|
|
/* These controllers are region "automation", so we do not create
|
|
|
|
* an AutomationList/Line for the track */
|
2008-09-21 12:17:02 -04:00
|
|
|
|
2009-02-15 23:53:01 -05:00
|
|
|
if (param.type() == NullAutomation) {
|
|
|
|
cerr << "WARNING: Attempt to create NullAutomation child, ignoring" << endl;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
AutomationTracks::iterator existing = _automation_tracks.find (param);
|
|
|
|
if (existing != _automation_tracks.end()) {
|
2009-01-21 03:32:23 -05:00
|
|
|
return;
|
2010-01-08 21:36:47 -05:00
|
|
|
}
|
2007-06-27 11:51:50 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<AutomationControl> c = _route->get_control (param);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-01-27 23:55:31 -05:00
|
|
|
assert(c);
|
2009-01-21 03:32:23 -05:00
|
|
|
|
2009-07-09 13:58:13 -04:00
|
|
|
boost::shared_ptr<AutomationTimeAxisView> track(new AutomationTimeAxisView (_session,
|
2009-01-21 03:32:23 -05:00
|
|
|
_route, boost::shared_ptr<ARDOUR::Automatable>(), c,
|
|
|
|
_editor,
|
2009-07-09 13:58:13 -04:00
|
|
|
*this,
|
2009-01-21 03:32:23 -05:00
|
|
|
true,
|
|
|
|
parent_canvas,
|
2009-07-09 13:58:13 -04:00
|
|
|
_route->describe_parameter(param)));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
add_automation_child (param, track, show);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2009-01-21 03:32:23 -05:00
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
void
|
|
|
|
MidiTimeAxisView::route_active_changed ()
|
|
|
|
{
|
|
|
|
RouteUI::route_active_changed ();
|
|
|
|
|
2006-08-14 04:44:14 -04:00
|
|
|
if (is_track()) {
|
2006-07-27 21:08:57 -04:00
|
|
|
if (_route->active()) {
|
2006-07-23 08:03:19 -04:00
|
|
|
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 {
|
2006-08-14 04:44:14 -04:00
|
|
|
|
|
|
|
throw; // wha?
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2006-07-27 21:08:57 -04:00
|
|
|
if (_route->active()) {
|
2006-07-23 08:03:19 -04:00
|
|
|
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";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-04-19 06:30:38 -04:00
|
|
|
|
2009-09-03 08:39:50 -04:00
|
|
|
|
2010-01-07 14:15:33 -05:00
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::add_note_selection (uint8_t note)
|
|
|
|
{
|
|
|
|
if (!_editor.internal_editing()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint16_t chn_mask = _channel_selector.get_selected_channels();
|
|
|
|
|
|
|
|
if (_view->num_selected_regionviews() == 0) {
|
|
|
|
_view->foreach_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::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));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::extend_note_selection (uint8_t note)
|
|
|
|
{
|
|
|
|
if (!_editor.internal_editing()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint16_t chn_mask = _channel_selector.get_selected_channels();
|
|
|
|
|
|
|
|
if (_view->num_selected_regionviews() == 0) {
|
|
|
|
_view->foreach_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection_region_view), note, chn_mask));
|
|
|
|
} else {
|
|
|
|
_view->foreach_selected_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection_region_view), note, chn_mask));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::toggle_note_selection (uint8_t note)
|
|
|
|
{
|
|
|
|
if (!_editor.internal_editing()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint16_t chn_mask = _channel_selector.get_selected_channels();
|
|
|
|
|
|
|
|
if (_view->num_selected_regionviews() == 0) {
|
|
|
|
_view->foreach_regionview (sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::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));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::add_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask)
|
|
|
|
{
|
|
|
|
dynamic_cast<MidiRegionView*>(rv)->select_matching_notes (note, chn_mask, false, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::extend_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask)
|
|
|
|
{
|
|
|
|
dynamic_cast<MidiRegionView*>(rv)->select_matching_notes (note, chn_mask, true, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::toggle_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask)
|
|
|
|
{
|
|
|
|
dynamic_cast<MidiRegionView*>(rv)->toggle_matching_notes (note, chn_mask);
|
|
|
|
}
|
2010-01-08 21:36:47 -05:00
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::set_channel_mode (ChannelMode, uint16_t)
|
|
|
|
{
|
2010-01-10 13:11:02 -05:00
|
|
|
/* hide all automation tracks that use the wrong channel(s) and show all those that use
|
|
|
|
the right ones.
|
|
|
|
*/
|
|
|
|
|
|
|
|
uint16_t selected_channels = _channel_selector.get_selected_channels();
|
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
no_redraw = true;
|
|
|
|
|
|
|
|
for (uint32_t ctl = 0; ctl < 127; ++ctl) {
|
|
|
|
|
|
|
|
for (uint32_t chn = 0; chn < 16; ++chn) {
|
|
|
|
Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl);
|
2010-05-25 10:50:45 -04:00
|
|
|
boost::shared_ptr<AutomationTimeAxisView> track = automation_child (fully_qualified_param);
|
2010-01-10 13:11:02 -05:00
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
if (!track) {
|
2010-01-10 13:11:02 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((selected_channels & (0x0001 << chn)) == 0) {
|
|
|
|
/* channel not in use. hiding it will trigger RouteTimeAxisView::automation_track_hidden()
|
|
|
|
which will cause a redraw. We don't want one per channel, so block that with no_redraw.
|
|
|
|
*/
|
2010-05-25 10:50:45 -04:00
|
|
|
changed = track->set_visibility (false) || changed;
|
2010-01-10 13:11:02 -05:00
|
|
|
} else {
|
2010-05-25 10:50:45 -04:00
|
|
|
changed = track->set_visibility (true) || changed;
|
2010-01-10 13:11:02 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
no_redraw = false;
|
|
|
|
|
|
|
|
/* TODO: Bender, PgmChange, Pressure */
|
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
/* invalidate the controller menu, so that we rebuilt it next time */
|
2010-06-08 17:48:38 -04:00
|
|
|
_controller_menu_map.clear ();
|
2010-01-08 21:36:47 -05:00
|
|
|
delete controller_menu;
|
|
|
|
controller_menu = 0;
|
2010-01-10 13:11:02 -05:00
|
|
|
|
|
|
|
if (changed) {
|
|
|
|
_route->gui_changed ("track_height", this);
|
|
|
|
}
|
2010-01-08 21:36:47 -05:00
|
|
|
}
|
2010-06-08 17:48:38 -04:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2010-08-15 12:39:51 -04:00
|
|
|
|
|
|
|
boost::shared_ptr<MidiRegion>
|
2010-08-20 08:01:13 -04:00
|
|
|
MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit)
|
2010-08-15 12:39:51 -04:00
|
|
|
{
|
|
|
|
Editor* real_editor = dynamic_cast<Editor*> (&_editor);
|
|
|
|
|
|
|
|
real_editor->begin_reversible_command (_("create region"));
|
|
|
|
playlist()->clear_history ();
|
|
|
|
|
|
|
|
real_editor->snap_to (pos, 0);
|
2010-08-20 08:01:13 -04:00
|
|
|
|
2010-08-15 12:39:51 -04:00
|
|
|
boost::shared_ptr<Source> src = _session->create_midi_source_for_session (view()->trackview().track().get(),
|
|
|
|
view()->trackview().track()->name());
|
|
|
|
PropertyList plist;
|
|
|
|
|
|
|
|
plist.add (ARDOUR::Properties::start, 0);
|
|
|
|
plist.add (ARDOUR::Properties::length, length);
|
|
|
|
plist.add (ARDOUR::Properties::name, PBD::basename_nosuffix(src->name()));
|
|
|
|
|
|
|
|
boost::shared_ptr<Region> region = (RegionFactory::create (src, plist));
|
|
|
|
|
|
|
|
playlist()->add_region (region, pos);
|
|
|
|
_session->add_command (new StatefulDiffCommand (playlist()));
|
|
|
|
|
2010-08-20 08:01:13 -04:00
|
|
|
if (commit) {
|
|
|
|
real_editor->commit_reversible_command ();
|
|
|
|
}
|
2010-08-15 12:39:51 -04:00
|
|
|
|
|
|
|
return boost::dynamic_pointer_cast<MidiRegion>(region);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::start_step_editing ()
|
|
|
|
{
|
|
|
|
if (!_step_editor) {
|
|
|
|
_step_editor = new StepEditor (_editor, midi_track(), *this);
|
|
|
|
}
|
|
|
|
|
|
|
|
_step_editor->start_step_editing ();
|
|
|
|
|
|
|
|
}
|
|
|
|
void
|
|
|
|
MidiTimeAxisView::stop_step_editing ()
|
|
|
|
{
|
|
|
|
if (_step_editor) {
|
|
|
|
_step_editor->stop_step_editing ();
|
|
|
|
}
|
|
|
|
}
|