← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ardour3/utopic

« back to all changes in this revision

Viewing changes to gtk2_ardour/midi_time_axis.cc

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler
  • Date: 2013-09-21 19:05:02 UTC
  • Revision ID: package-import@ubuntu.com-20130921190502-8gsftrku6jnzhd7v
Tags: upstream-3.4~dfsg
Import upstream version 3.4~dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk2_ardour/midi_time_axis.cc
 
1
/*
 
2
    Copyright (C) 2000 Paul Davis
 
3
 
 
4
    This program is free software; you can redistribute it and/or modify
 
5
    it under the terms of the GNU General Public License as published by
 
6
    the Free Software Foundation; either version 2 of the License, or
 
7
    (at your option) any later version.
 
8
 
 
9
    This program is distributed in the hope that it will be useful,
 
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
    GNU General Public License for more details.
 
13
 
 
14
    You should have received a copy of the GNU General Public License
 
15
    along with this program; if not, write to the Free Software
 
16
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
17
*/
 
18
 
 
19
#include <cstdlib>
 
20
#include <cmath>
 
21
 
 
22
#include <strings.h> // for ffs(3)
 
23
 
 
24
#include <algorithm>
 
25
#include <string>
 
26
#include <vector>
 
27
 
 
28
#include <sigc++/bind.h>
 
29
 
 
30
#include "pbd/error.h"
 
31
#include "pbd/stl_delete.h"
 
32
#include "pbd/whitespace.h"
 
33
#include "pbd/basename.h"
 
34
#include "pbd/enumwriter.h"
 
35
#include "pbd/memento_command.h"
 
36
#include "pbd/stateful_diff_command.h"
 
37
 
 
38
#include "gtkmm2ext/gtk_ui.h"
 
39
#include "gtkmm2ext/selector.h"
 
40
#include "gtkmm2ext/bindable_button.h"
 
41
#include "gtkmm2ext/utils.h"
 
42
 
 
43
#include "ardour/event_type_map.h"
 
44
#include "ardour/midi_patch_manager.h"
 
45
#include "ardour/midi_playlist.h"
 
46
#include "ardour/midi_region.h"
 
47
#include "ardour/midi_source.h"
 
48
#include "ardour/midi_track.h"
 
49
#include "ardour/operations.h"
 
50
#include "ardour/playlist.h"
 
51
#include "ardour/region.h"
 
52
#include "ardour/region_factory.h"
 
53
#include "ardour/route.h"
 
54
#include "ardour/session.h"
 
55
#include "ardour/session_object.h"
 
56
#include "ardour/source.h"
 
57
#include "ardour/track.h"
 
58
#include "ardour/types.h"
 
59
 
 
60
#include "ardour_ui.h"
 
61
#include "ardour_button.h"
 
62
#include "automation_line.h"
 
63
#include "automation_time_axis.h"
 
64
#include "canvas-note-event.h"
 
65
#include "canvas_impl.h"
 
66
#include "editor.h"
 
67
#include "enums.h"
 
68
#include "ghostregion.h"
 
69
#include "gui_thread.h"
 
70
#include "keyboard.h"
 
71
#include "midi_channel_selector.h"
 
72
#include "midi_scroomer.h"
 
73
#include "midi_streamview.h"
 
74
#include "midi_region_view.h"
 
75
#include "midi_time_axis.h"
 
76
#include "piano_roll_header.h"
 
77
#include "playlist_selector.h"
 
78
#include "plugin_selector.h"
 
79
#include "plugin_ui.h"
 
80
#include "point_selection.h"
 
81
#include "prompter.h"
 
82
#include "region_view.h"
 
83
#include "rgb_macros.h"
 
84
#include "selection.h"
 
85
#include "step_editor.h"
 
86
#include "simplerect.h"
 
87
#include "utils.h"
 
88
 
 
89
#include "ardour/midi_track.h"
 
90
 
 
91
#include "i18n.h"
 
92
 
 
93
using namespace ARDOUR;
 
94
using namespace PBD;
 
95
using namespace Gtk;
 
96
using namespace Gtkmm2ext;
 
97
using namespace Editing;
 
98
 
 
99
// Minimum height at which a control is displayed
 
100
static const uint32_t MIDI_CONTROLS_BOX_MIN_HEIGHT = 140;
 
101
static const uint32_t KEYBOARD_MIN_HEIGHT = 130;
 
102
 
 
103
MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session* sess, Canvas& canvas)
 
104
        : AxisView(sess) // virtually inherited
 
105
        , RouteTimeAxisView(ed, sess, canvas)
 
106
        , _ignore_signals(false)
 
107
        , _range_scroomer(0)
 
108
        , _piano_roll_header(0)
 
109
        , _note_mode(Sustained)
 
110
        , _note_mode_item(0)
 
111
        , _percussion_mode_item(0)
 
112
        , _color_mode(MeterColors)
 
113
        , _meter_color_mode_item(0)
 
114
        , _channel_color_mode_item(0)
 
115
        , _track_color_mode_item(0)
 
116
        , _channel_selector (0)
 
117
        , _step_edit_item (0)
 
118
        , controller_menu (0)
 
119
        , _step_editor (0)
 
120
{
 
121
}
 
122
 
 
123
void
 
124
MidiTimeAxisView::set_route (boost::shared_ptr<Route> rt)
 
125
{
 
126
        _route = rt;
 
127
        
 
128
        _view = new MidiStreamView (*this);
 
129
 
 
130
        if (is_track ()) {
 
131
                _piano_roll_header = new PianoRollHeader(*midi_view());
 
132
                _range_scroomer = new MidiScroomer(midi_view()->note_range_adjustment);
 
133
                _range_scroomer->DoubleClicked.connect (
 
134
                        sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range),
 
135
                                    MidiStreamView::ContentsRange, false));
 
136
        }
 
137
 
 
138
        /* This next call will result in our height being set up, so it must come after
 
139
           the creation of the piano roll / range scroomer as their visibility is set up
 
140
           when our height is.
 
141
        */
 
142
        RouteTimeAxisView::set_route (rt);
 
143
 
 
144
        _view->apply_color (_color, StreamView::RegionColor);
 
145
 
 
146
        subplugin_menu.set_name ("ArdourContextMenu");
 
147
 
 
148
        if (!gui_property ("note-range-min").empty ()) {
 
149
                midi_view()->apply_note_range (atoi (gui_property ("note-range-min").c_str()),
 
150
                                               atoi (gui_property ("note-range-max").c_str()),
 
151
                                               true);
 
152
        }
 
153
 
 
154
        midi_view()->NoteRangeChanged.connect (
 
155
                sigc::mem_fun (*this, &MidiTimeAxisView::note_range_changed));
 
156
        _view->ContentsHeightChanged.connect (
 
157
                sigc::mem_fun (*this, &MidiTimeAxisView::contents_height_changed));
 
158
 
 
159
        ignore_toggle = false;
 
160
 
 
161
        if (is_midi_track()) {
 
162
                controls_ebox.set_name ("MidiTimeAxisViewControlsBaseUnselected");
 
163
                _note_mode = midi_track()->note_mode();
 
164
        } else { // MIDI bus (which doesn't exist yet..)
 
165
                controls_ebox.set_name ("MidiBusControlsBaseUnselected");
 
166
        }
 
167
 
 
168
        /* map current state of the route */
 
169
 
 
170
        processors_changed (RouteProcessorChange ());
 
171
 
 
172
        _route->processors_changed.connect (*this, invalidator (*this),
 
173
                                            boost::bind (&MidiTimeAxisView::processors_changed, this, _1),
 
174
                                            gui_context());
 
175
 
 
176
        if (is_track()) {
 
177
                _piano_roll_header->SetNoteSelection.connect (
 
178
                        sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection));
 
179
                _piano_roll_header->AddNoteSelection.connect (
 
180
                        sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection));
 
181
                _piano_roll_header->ExtendNoteSelection.connect (
 
182
                        sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection));
 
183
                _piano_roll_header->ToggleNoteSelection.connect (
 
184
                        sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection));
 
185
 
 
186
                /* Suspend updates of the StreamView during scroomer drags to speed things up */
 
187
                _range_scroomer->DragStarting.connect (
 
188
                        sigc::mem_fun (*midi_view(), &MidiStreamView::suspend_updates));
 
189
                _range_scroomer->DragFinishing.connect (
 
190
                        sigc::mem_fun (*midi_view(), &MidiStreamView::resume_updates));
 
191
 
 
192
                /* Put the scroomer and the keyboard in a VBox with a padding
 
193
                   label so that they can be reduced in height for stacked-view
 
194
                   tracks.
 
195
                */
 
196
                VBox* v = manage (new VBox);
 
197
                HBox* h = manage (new HBox);
 
198
                h->pack_start (*_range_scroomer);
 
199
                h->pack_start (*_piano_roll_header);
 
200
                v->pack_start (*h, false, false);
 
201
                v->pack_start (*manage (new Label ("")), true, true);
 
202
                v->show ();
 
203
                h->show ();
 
204
                controls_hbox.pack_start(*v, false, false);
 
205
 
 
206
                controls_ebox.set_name ("MidiTrackControlsBaseUnselected");
 
207
                controls_base_selected_name = "MidiTrackControlsBaseSelected";
 
208
                controls_base_unselected_name = "MidiTrackControlsBaseUnselected";
 
209
 
 
210
                midi_view()->NoteRangeChanged.connect (
 
211
                        sigc::mem_fun(*this, &MidiTimeAxisView::update_range));
 
212
 
 
213
                /* ask for notifications of any new RegionViews */
 
214
                _view->RegionViewAdded.connect (
 
215
                        sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added));
 
216
 
 
217
                midi_track()->PlaybackChannelModeChanged.connect (*this, invalidator (*this),
 
218
                                                                  boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this),
 
219
                                                                  gui_context());
 
220
                midi_track()->PlaybackChannelMaskChanged.connect (*this, invalidator (*this),
 
221
                                                                  boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this),
 
222
                                                                  gui_context());
 
223
                midi_track()->CaptureChannelModeChanged.connect (*this, invalidator (*this),
 
224
                                                                  boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this),
 
225
                                                                  gui_context());
 
226
                midi_track()->CaptureChannelMaskChanged.connect (*this, invalidator (*this),
 
227
                                                                  boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this),
 
228
                                                                  gui_context());
 
229
 
 
230
                playback_channel_mode_changed ();
 
231
                capture_channel_mode_changed ();
 
232
 
 
233
                if (!_editor.have_idled()) {
 
234
                        /* first idle will do what we need */
 
235
                } else {
 
236
                        first_idle ();
 
237
                }
 
238
        }
 
239
 
 
240
        MIDI::Name::MidiPatchManager& patch_manager = MIDI::Name::MidiPatchManager::instance();
 
241
 
 
242
        MIDI::Name::MasterDeviceNames::Models::const_iterator m = patch_manager.all_models().begin();
 
243
        for (; m != patch_manager.all_models().end(); ++m) {
 
244
                _midnam_model_selector.append_text(m->c_str());
 
245
        }
 
246
 
 
247
        if (gui_property (X_("midnam-model-name")).empty()) {
 
248
                set_gui_property (X_("midnam-model-name"), "Generic");
 
249
        }
 
250
 
 
251
        if (gui_property (X_("midnam-custom-device-mode")).empty()) {
 
252
                boost::shared_ptr<MIDI::Name::MasterDeviceNames> device_names = get_device_names();
 
253
                if (device_names) {
 
254
                        set_gui_property (X_("midnam-custom-device-mode"),
 
255
                                          *device_names->custom_device_mode_names().begin());
 
256
                }
 
257
        }
 
258
 
 
259
        _midnam_model_selector.set_active_text (gui_property (X_("midnam-model-name")));
 
260
        _midnam_custom_device_mode_selector.set_active_text (gui_property (X_("midnam-custom-device-mode")));
 
261
 
 
262
        ARDOUR_UI::instance()->set_tip (_midnam_model_selector, _("External MIDI Device"));
 
263
        ARDOUR_UI::instance()->set_tip (_midnam_custom_device_mode_selector, _("External Device Mode"));
 
264
 
 
265
        _midi_controls_box.set_homogeneous(false);
 
266
        _midi_controls_box.set_border_width (10);
 
267
 
 
268
        _channel_status_box.set_homogeneous (false);
 
269
        _channel_status_box.set_spacing (6);
 
270
        
 
271
        _channel_selector_button.set_label (_("Chns"));
 
272
        ARDOUR_UI::instance()->set_tip (_channel_selector_button, _("Click to edit channel settings"));
 
273
        
 
274
        /* fixed sized labels to prevent silly nonsense (though obviously,
 
275
         * they cause their own too)
 
276
         */
 
277
 
 
278
        _playback_channel_status.set_size_request (65, -1);
 
279
        _capture_channel_status.set_size_request (60, -1);
 
280
 
 
281
        _channel_status_box.pack_start (_playback_channel_status, false, false);
 
282
        _channel_status_box.pack_start (_capture_channel_status, false, false);
 
283
        _channel_status_box.pack_start (_channel_selector_button, false, false);
 
284
        _channel_status_box.show_all ();
 
285
 
 
286
        _channel_selector_button.signal_clicked().connect (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_channel_selector));
 
287
        
 
288
        _midi_controls_box.pack_start (_channel_status_box, false, false, 10);
 
289
 
 
290
        if (!patch_manager.all_models().empty()) {
 
291
 
 
292
                _midnam_model_selector.set_size_request(22, 30);
 
293
                _midnam_model_selector.set_border_width(2);
 
294
                _midnam_model_selector.show ();
 
295
                _midi_controls_box.pack_start (_midnam_model_selector);
 
296
 
 
297
                _midnam_custom_device_mode_selector.set_size_request(10, 30);
 
298
                _midnam_custom_device_mode_selector.set_border_width(2);
 
299
                _midnam_custom_device_mode_selector.show ();
 
300
 
 
301
                _midi_controls_box.pack_start (_midnam_custom_device_mode_selector);
 
302
        } 
 
303
 
 
304
        model_changed();
 
305
        custom_device_mode_changed();
 
306
 
 
307
        _midnam_model_selector.signal_changed().connect(
 
308
                sigc::mem_fun(*this, &MidiTimeAxisView::model_changed));
 
309
        _midnam_custom_device_mode_selector.signal_changed().connect(
 
310
                sigc::mem_fun(*this, &MidiTimeAxisView::custom_device_mode_changed));
 
311
 
 
312
        controls_vbox.pack_start(_midi_controls_box, false, false);
 
313
 
 
314
        const string color_mode = gui_property ("color-mode");
 
315
        if (!color_mode.empty()) {
 
316
                _color_mode = ColorMode (string_2_enum(color_mode, _color_mode));
 
317
                if (_channel_selector && _color_mode == ChannelColors) {
 
318
                        _channel_selector->set_channel_colors(CanvasNoteEvent::midi_channel_colors);
 
319
                }
 
320
        }
 
321
 
 
322
        set_color_mode (_color_mode, true, false);
 
323
 
 
324
        const string note_mode = gui_property ("note-mode");
 
325
        if (!note_mode.empty()) {
 
326
                _note_mode = NoteMode (string_2_enum (note_mode, _note_mode));
 
327
                if (_percussion_mode_item) {
 
328
                        _percussion_mode_item->set_active (_note_mode == Percussive);
 
329
                }
 
330
        }
 
331
 
 
332
        /* Look for any GUI object state nodes that represent automation children
 
333
         * that should exist, and create the children.
 
334
         */
 
335
 
 
336
        const list<string> gui_ids = gui_object_state().all_ids ();
 
337
        for (list<string>::const_iterator i = gui_ids.begin(); i != gui_ids.end(); ++i) {
 
338
                PBD::ID route_id;
 
339
                bool has_parameter;
 
340
                Evoral::Parameter parameter (0, 0, 0);
 
341
 
 
342
                bool const p = AutomationTimeAxisView::parse_state_id (
 
343
                        *i, route_id, has_parameter, parameter);
 
344
                if (p && route_id == _route->id () && has_parameter) {
 
345
                        const std::string& visible = gui_object_state().get_string (*i, X_("visible"));
 
346
                        create_automation_child (parameter, string_is_affirmative (visible));
 
347
                }
 
348
        }
 
349
}
 
350
 
 
351
void
 
352
MidiTimeAxisView::first_idle ()
 
353
{
 
354
        if (is_track ()) {
 
355
                _view->attach ();
 
356
        }
 
357
}
 
358
 
 
359
MidiTimeAxisView::~MidiTimeAxisView ()
 
360
{
 
361
        delete _channel_selector;
 
362
 
 
363
        delete _piano_roll_header;
 
364
        _piano_roll_header = 0;
 
365
 
 
366
        delete _range_scroomer;
 
367
        _range_scroomer = 0;
 
368
 
 
369
        delete controller_menu;
 
370
        delete _step_editor;
 
371
}
 
372
 
 
373
void
 
374
MidiTimeAxisView::enter_internal_edit_mode ()
 
375
{
 
376
        if (midi_view()) {
 
377
                midi_view()->enter_internal_edit_mode ();
 
378
        }
 
379
}
 
380
 
 
381
void
 
382
MidiTimeAxisView::leave_internal_edit_mode ()
 
383
{
 
384
        if (midi_view()) {
 
385
                midi_view()->leave_internal_edit_mode ();
 
386
        }
 
387
}
 
388
 
 
389
void
 
390
MidiTimeAxisView::check_step_edit ()
 
391
{
 
392
        ensure_step_editor ();
 
393
        _step_editor->check_step_edit ();
 
394
}
 
395
 
 
396
void
 
397
MidiTimeAxisView::model_changed()
 
398
{
 
399
        const Glib::ustring model = _midnam_model_selector.get_active_text();
 
400
        set_gui_property (X_("midnam-model-name"), model);
 
401
 
 
402
        const std::list<std::string> device_modes = MIDI::Name::MidiPatchManager::instance()
 
403
                .custom_device_mode_names_by_model(model);
 
404
 
 
405
        _midnam_custom_device_mode_selector.clear_items();
 
406
 
 
407
        for (std::list<std::string>::const_iterator i = device_modes.begin();
 
408
             i != device_modes.end(); ++i) {
 
409
                _midnam_custom_device_mode_selector.append_text(*i);
 
410
        }
 
411
 
 
412
        _midnam_custom_device_mode_selector.set_active(0);
 
413
        
 
414
        _route->instrument_info().set_external_instrument (
 
415
                _midnam_model_selector.get_active_text(),
 
416
                _midnam_custom_device_mode_selector.get_active_text());
 
417
 
 
418
        // Rebuild controller menu
 
419
        _controller_menu_map.clear ();
 
420
        delete controller_menu;
 
421
        controller_menu = 0;
 
422
        build_automation_action_menu(false);
 
423
}
 
424
 
 
425
void
 
426
MidiTimeAxisView::custom_device_mode_changed()
 
427
{
 
428
        const Glib::ustring mode = _midnam_custom_device_mode_selector.get_active_text();
 
429
        set_gui_property (X_("midnam-custom-device-mode"), mode);
 
430
        _route->instrument_info().set_external_instrument (
 
431
                _midnam_model_selector.get_active_text(), mode);
 
432
}
 
433
 
 
434
MidiStreamView*
 
435
MidiTimeAxisView::midi_view()
 
436
{
 
437
        return dynamic_cast<MidiStreamView*>(_view);
 
438
}
 
439
 
 
440
void
 
441
MidiTimeAxisView::set_height (uint32_t h)
 
442
{
 
443
        if (h >= MIDI_CONTROLS_BOX_MIN_HEIGHT) {
 
444
                _midi_controls_box.show ();
 
445
        } else {
 
446
                _midi_controls_box.hide();
 
447
        }
 
448
        
 
449
        if (h >= KEYBOARD_MIN_HEIGHT) {
 
450
                if (is_track() && _range_scroomer) {
 
451
                        _range_scroomer->show();
 
452
                }
 
453
                if (is_track() && _piano_roll_header) {
 
454
                        _piano_roll_header->show();
 
455
                }
 
456
        } else {
 
457
                if (is_track() && _range_scroomer) {
 
458
                        _range_scroomer->hide();
 
459
                }
 
460
                if (is_track() && _piano_roll_header) {
 
461
                        _piano_roll_header->hide();
 
462
                }
 
463
        }
 
464
 
 
465
        /* We need to do this after changing visibility of our stuff, as it will
 
466
           eventually trigger a call to Editor::reset_controls_layout_width(),
 
467
           which needs to know if we have just shown or hidden a scroomer /
 
468
           piano roll.
 
469
        */
 
470
        RouteTimeAxisView::set_height (h);
 
471
}
 
472
 
 
473
void
 
474
MidiTimeAxisView::append_extra_display_menu_items ()
 
475
{
 
476
        using namespace Menu_Helpers;
 
477
 
 
478
        MenuList& items = display_menu->items();
 
479
 
 
480
        // Note range
 
481
        Menu *range_menu = manage(new Menu);
 
482
        MenuList& range_items = range_menu->items();
 
483
        range_menu->set_name ("ArdourContextMenu");
 
484
 
 
485
        range_items.push_back (
 
486
                MenuElem (_("Show Full Range"),
 
487
                          sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range), 
 
488
                                      MidiStreamView::FullRange, true)));
 
489
 
 
490
        range_items.push_back (
 
491
                MenuElem (_("Fit Contents"),
 
492
                          sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range),
 
493
                                      MidiStreamView::ContentsRange, true)));
 
494
 
 
495
        items.push_back (MenuElem (_("Note Range"), *range_menu));
 
496
        items.push_back (MenuElem (_("Note Mode"), *build_note_mode_menu()));
 
497
        items.push_back (MenuElem (_("Channel Selector"),
 
498
                                   sigc::mem_fun(*this, &MidiTimeAxisView::toggle_channel_selector)));
 
499
 
 
500
        color_mode_menu = build_color_mode_menu();
 
501
        if (color_mode_menu) {
 
502
                items.push_back (MenuElem (_("Color Mode"), *color_mode_menu));
 
503
        }
 
504
        
 
505
        items.push_back (SeparatorElem ());
 
506
}
 
507
 
 
508
void
 
509
MidiTimeAxisView::toggle_channel_selector ()
 
510
{
 
511
        if (!_channel_selector) {
 
512
                _channel_selector = new MidiChannelSelectorWindow (midi_track());
 
513
 
 
514
                if (_color_mode == ChannelColors) {
 
515
                        _channel_selector->set_channel_colors(CanvasNoteEvent::midi_channel_colors);
 
516
                } else {
 
517
                        _channel_selector->set_default_channel_color ();
 
518
                }
 
519
 
 
520
                _channel_selector->show_all ();
 
521
        } else {
 
522
                _channel_selector->cycle_visibility ();
 
523
        }
 
524
}
 
525
 
 
526
void
 
527
MidiTimeAxisView::build_automation_action_menu (bool for_selection)
 
528
{
 
529
        using namespace Menu_Helpers;
 
530
 
 
531
        /* If we have a controller menu, we need to detach it before
 
532
           RouteTimeAxis::build_automation_action_menu destroys the
 
533
           menu it is attached to.  Otherwise GTK destroys
 
534
           controller_menu's gobj, meaning that it can't be reattached
 
535
           below.  See bug #3134.
 
536
        */
 
537
 
 
538
        if (controller_menu) {
 
539
                detach_menu (*controller_menu);
 
540
        }
 
541
 
 
542
        _channel_command_menu_map.clear ();
 
543
        RouteTimeAxisView::build_automation_action_menu (for_selection);
 
544
 
 
545
        MenuList& automation_items = automation_action_menu->items();
 
546
 
 
547
        uint16_t selected_channels = midi_track()->get_playback_channel_mask();
 
548
 
 
549
        if (selected_channels !=  0) {
 
550
 
 
551
                automation_items.push_back (SeparatorElem());
 
552
 
 
553
                /* these 2 MIDI "command" types are semantically more like automation
 
554
                   than note data, but they are not MIDI controllers. We give them
 
555
                   special status in this menu, since they will not show up in the
 
556
                   controller list and anyone who actually knows something about MIDI
 
557
                   (!) would not expect to find them there.
 
558
                */
 
559
 
 
560
                add_channel_command_menu_item (
 
561
                        automation_items, _("Bender"), MidiPitchBenderAutomation, 0);
 
562
                automation_items.back().set_sensitive (
 
563
                        !for_selection || _editor.get_selection().tracks.size() == 1);
 
564
                add_channel_command_menu_item (
 
565
                        automation_items, _("Pressure"), MidiChannelPressureAutomation, 0);
 
566
                automation_items.back().set_sensitive (
 
567
                        !for_selection || _editor.get_selection().tracks.size() == 1);
 
568
 
 
569
                /* now all MIDI controllers. Always offer the possibility that we will
 
570
                   rebuild the controllers menu since it might need to be updated after
 
571
                   a channel mode change or other change. Also detach it first in case
 
572
                   it has been used anywhere else.
 
573
                */
 
574
 
 
575
                build_controller_menu ();
 
576
 
 
577
                automation_items.push_back (SeparatorElem());
 
578
                automation_items.push_back (MenuElem (_("Controllers"), *controller_menu));
 
579
                automation_items.back().set_sensitive (
 
580
                        !for_selection || _editor.get_selection().tracks.size() == 1);
 
581
        } else {
 
582
                automation_items.push_back (
 
583
                        MenuElem (string_compose ("<i>%1</i>", _("No MIDI Channels selected"))));
 
584
                dynamic_cast<Label*> (automation_items.back().get_child())->set_use_markup (true);
 
585
        }
 
586
}
 
587
 
 
588
void
 
589
MidiTimeAxisView::change_all_channel_tracks_visibility (bool yn, Evoral::Parameter param)
 
590
{
 
591
        const uint16_t selected_channels = midi_track()->get_playback_channel_mask();
 
592
 
 
593
        for (uint8_t chn = 0; chn < 16; chn++) {
 
594
                if (selected_channels & (0x0001 << chn)) {
 
595
 
 
596
                        Evoral::Parameter fully_qualified_param (param.type(), chn, param.id());
 
597
                        Gtk::CheckMenuItem* menu = automation_child_menu_item (fully_qualified_param);
 
598
 
 
599
                        if (menu) {
 
600
                                menu->set_active (yn);
 
601
                        }
 
602
                }
 
603
        }
 
604
}
 
605
 
 
606
void
 
607
MidiTimeAxisView::add_channel_command_menu_item (Menu_Helpers::MenuList& items,
 
608
                                                 const string&           label,
 
609
                                                 AutomationType          auto_type,
 
610
                                                 uint8_t                 cmd)
 
611
{
 
612
        using namespace Menu_Helpers;
 
613
 
 
614
        /* count the number of selected channels because we will build a different menu
 
615
           structure if there is more than 1 selected.
 
616
         */
 
617
 
 
618
        const uint16_t selected_channels = midi_track()->get_playback_channel_mask();
 
619
        int chn_cnt = 0;
 
620
 
 
621
        for (uint8_t chn = 0; chn < 16; chn++) {
 
622
                if (selected_channels & (0x0001 << chn)) {
 
623
                        if (++chn_cnt > 1) {
 
624
                                break;
 
625
                        }
 
626
                }
 
627
        }
 
628
 
 
629
        if (chn_cnt > 1) {
 
630
 
 
631
                /* multiple channels - create a submenu, with 1 item per channel */
 
632
 
 
633
                Menu* chn_menu = manage (new Menu);
 
634
                MenuList& chn_items (chn_menu->items());
 
635
                Evoral::Parameter param_without_channel (auto_type, 0, cmd);
 
636
 
 
637
                /* add a couple of items to hide/show all of them */
 
638
 
 
639
                chn_items.push_back (
 
640
                        MenuElem (_("Hide all channels"),
 
641
                                  sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility),
 
642
                                              false, param_without_channel)));
 
643
                chn_items.push_back (
 
644
                        MenuElem (_("Show all channels"),
 
645
                                  sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility),
 
646
                                              true, param_without_channel)));
 
647
 
 
648
                for (uint8_t chn = 0; chn < 16; chn++) {
 
649
                        if (selected_channels & (0x0001 << chn)) {
 
650
 
 
651
                                /* for each selected channel, add a menu item for this controller */
 
652
 
 
653
                                Evoral::Parameter fully_qualified_param (auto_type, chn, cmd);
 
654
                                chn_items.push_back (
 
655
                                        CheckMenuElem (string_compose (_("Channel %1"), chn+1),
 
656
                                                       sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
 
657
                                                                   fully_qualified_param)));
 
658
 
 
659
                                boost::shared_ptr<AutomationTimeAxisView> track = automation_child (fully_qualified_param);
 
660
                                bool visible = false;
 
661
 
 
662
                                if (track) {
 
663
                                        if (track->marked_for_display()) {
 
664
                                                visible = true;
 
665
                                        }
 
666
                                }
 
667
 
 
668
                                CheckMenuItem* cmi = static_cast<CheckMenuItem*>(&chn_items.back());
 
669
                                _channel_command_menu_map[fully_qualified_param] = cmi;
 
670
                                cmi->set_active (visible);
 
671
                        }
 
672
                }
 
673
 
 
674
                /* now create an item in the parent menu that has the per-channel list as a submenu */
 
675
 
 
676
                items.push_back (MenuElem (label, *chn_menu));
 
677
 
 
678
        } else {
 
679
 
 
680
                /* just one channel - create a single menu item for this command+channel combination*/
 
681
 
 
682
                for (uint8_t chn = 0; chn < 16; chn++) {
 
683
                        if (selected_channels & (0x0001 << chn)) {
 
684
 
 
685
                                Evoral::Parameter fully_qualified_param (auto_type, chn, cmd);
 
686
                                items.push_back (
 
687
                                        CheckMenuElem (label,
 
688
                                                       sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
 
689
                                                                   fully_qualified_param)));
 
690
 
 
691
                                boost::shared_ptr<AutomationTimeAxisView> track = automation_child (fully_qualified_param);
 
692
                                bool visible = false;
 
693
 
 
694
                                if (track) {
 
695
                                        if (track->marked_for_display()) {
 
696
                                                visible = true;
 
697
                                        }
 
698
                                }
 
699
 
 
700
                                CheckMenuItem* cmi = static_cast<CheckMenuItem*>(&items.back());
 
701
                                _channel_command_menu_map[fully_qualified_param] = cmi;
 
702
                                cmi->set_active (visible);
 
703
 
 
704
                                /* one channel only */
 
705
                                break;
 
706
                        }
 
707
                }
 
708
        }
 
709
}
 
710
 
 
711
/** Add a single menu item for a controller on one channel. */
 
712
void
 
713
MidiTimeAxisView::add_single_channel_controller_item(Menu_Helpers::MenuList& ctl_items,
 
714
                                                     int                     ctl,
 
715
                                                     const std::string&      name)
 
716
{
 
717
        using namespace Menu_Helpers;
 
718
 
 
719
        const uint16_t selected_channels = midi_track()->get_playback_channel_mask();
 
720
        for (uint8_t chn = 0; chn < 16; chn++) {
 
721
                if (selected_channels & (0x0001 << chn)) {
 
722
 
 
723
                        Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl);
 
724
                        ctl_items.push_back (
 
725
                                CheckMenuElem (
 
726
                                        string_compose ("<b>%1</b>: %2 [%3]", ctl, name, int (chn)),
 
727
                                        sigc::bind (
 
728
                                                sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
 
729
                                                fully_qualified_param)));
 
730
                        dynamic_cast<Label*> (ctl_items.back().get_child())->set_use_markup (true);
 
731
 
 
732
                        boost::shared_ptr<AutomationTimeAxisView> track = automation_child (
 
733
                                fully_qualified_param);
 
734
 
 
735
                        bool visible = false;
 
736
                        if (track) {
 
737
                                if (track->marked_for_display()) {
 
738
                                        visible = true;
 
739
                                }
 
740
                        }
 
741
 
 
742
                        CheckMenuItem* cmi = static_cast<CheckMenuItem*>(&ctl_items.back());
 
743
                        _controller_menu_map[fully_qualified_param] = cmi;
 
744
                        cmi->set_active (visible);
 
745
 
 
746
                        /* one channel only */
 
747
                        break;
 
748
                }
 
749
        }
 
750
}
 
751
 
 
752
/** Add a submenu with 1 item per channel for a controller on many channels. */
 
753
void
 
754
MidiTimeAxisView::add_multi_channel_controller_item(Menu_Helpers::MenuList& ctl_items,
 
755
                                                    int                     ctl,
 
756
                                                    const std::string&      name)
 
757
{
 
758
        using namespace Menu_Helpers;
 
759
 
 
760
        const uint16_t selected_channels = midi_track()->get_playback_channel_mask();
 
761
 
 
762
        Menu* chn_menu = manage (new Menu);
 
763
        MenuList& chn_items (chn_menu->items());
 
764
 
 
765
        /* add a couple of items to hide/show this controller on all channels */
 
766
 
 
767
        Evoral::Parameter param_without_channel (MidiCCAutomation, 0, ctl);
 
768
        chn_items.push_back (
 
769
                MenuElem (_("Hide all channels"),
 
770
                          sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility),
 
771
                                      false, param_without_channel)));
 
772
        chn_items.push_back (
 
773
                MenuElem (_("Show all channels"),
 
774
                          sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::change_all_channel_tracks_visibility),
 
775
                                      true, param_without_channel)));
 
776
 
 
777
        for (uint8_t chn = 0; chn < 16; chn++) {
 
778
                if (selected_channels & (0x0001 << chn)) {
 
779
 
 
780
                        /* for each selected channel, add a menu item for this controller */
 
781
 
 
782
                        Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl);
 
783
                        chn_items.push_back (
 
784
                                CheckMenuElem (string_compose (_("Channel %1"), chn+1),
 
785
                                               sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
 
786
                                                           fully_qualified_param)));
 
787
 
 
788
                        boost::shared_ptr<AutomationTimeAxisView> track = automation_child (
 
789
                                fully_qualified_param);
 
790
                        bool visible = false;
 
791
 
 
792
                        if (track) {
 
793
                                if (track->marked_for_display()) {
 
794
                                        visible = true;
 
795
                                }
 
796
                        }
 
797
 
 
798
                        CheckMenuItem* cmi = static_cast<CheckMenuItem*>(&chn_items.back());
 
799
                        _controller_menu_map[fully_qualified_param] = cmi;
 
800
                        cmi->set_active (visible);
 
801
                }
 
802
        }
 
803
 
 
804
        /* add the per-channel menu to the list of controllers, with the name of the controller */
 
805
        ctl_items.push_back (MenuElem (string_compose ("<b>%1</b>: %2", ctl, name),
 
806
                                       *chn_menu));
 
807
        dynamic_cast<Label*> (ctl_items.back().get_child())->set_use_markup (true);
 
808
}
 
809
 
 
810
boost::shared_ptr<MIDI::Name::CustomDeviceMode>
 
811
MidiTimeAxisView::get_device_mode()
 
812
{
 
813
        using namespace MIDI::Name;
 
814
 
 
815
        boost::shared_ptr<MasterDeviceNames> device_names = get_device_names();
 
816
        if (!device_names) {
 
817
                return boost::shared_ptr<MIDI::Name::CustomDeviceMode>();
 
818
        }
 
819
 
 
820
        return device_names->custom_device_mode_by_name(
 
821
                gui_property (X_("midnam-custom-device-mode")));
 
822
}
 
823
 
 
824
boost::shared_ptr<MIDI::Name::MasterDeviceNames>
 
825
MidiTimeAxisView::get_device_names()
 
826
{
 
827
        using namespace MIDI::Name;
 
828
 
 
829
        const std::string model = gui_property (X_("midnam-model-name"));
 
830
 
 
831
        boost::shared_ptr<MIDINameDocument> midnam = MidiPatchManager::instance()
 
832
                .document_by_model(model);
 
833
        if (midnam) {
 
834
                return midnam->master_device_names(model);
 
835
        } else {
 
836
                return boost::shared_ptr<MasterDeviceNames>();
 
837
        }
 
838
}
 
839
 
 
840
void
 
841
MidiTimeAxisView::build_controller_menu ()
 
842
{
 
843
        using namespace Menu_Helpers;
 
844
 
 
845
        if (controller_menu) {
 
846
                /* it exists and has not been invalidated by a channel mode change */
 
847
                return;
 
848
        }
 
849
 
 
850
        controller_menu = new Menu; // explicitly managed by us
 
851
        MenuList& items (controller_menu->items());
 
852
 
 
853
        /* create several "top level" menu items for sets of controllers (16 at a
 
854
           time), and populate each one with a submenu for each controller+channel
 
855
           combination covering the currently selected channels for this track
 
856
        */
 
857
 
 
858
        const uint16_t selected_channels = midi_track()->get_playback_channel_mask();
 
859
 
 
860
        /* count the number of selected channels because we will build a different menu
 
861
           structure if there is more than 1 selected.
 
862
        */
 
863
 
 
864
        int chn_cnt = 0;
 
865
        for (uint8_t chn = 0; chn < 16; chn++) {
 
866
                if (selected_channels & (0x0001 << chn)) {
 
867
                        if (++chn_cnt > 1) {
 
868
                                break;
 
869
                        }
 
870
                }
 
871
        }
 
872
 
 
873
        using namespace MIDI::Name;
 
874
        boost::shared_ptr<MasterDeviceNames> device_names = get_device_names();
 
875
 
 
876
        if (device_names && !device_names->controls().empty()) {
 
877
                /* Controllers names available in midnam file, generate fancy menu */
 
878
                unsigned n_items  = 0;
 
879
                unsigned n_groups = 0;
 
880
 
 
881
                /* TODO: This is not correct, should look up the currently applicable ControlNameList
 
882
                   and only build a menu for that one. */
 
883
                for (MasterDeviceNames::ControlNameLists::const_iterator l = device_names->controls().begin();
 
884
                     l != device_names->controls().end(); ++l) {
 
885
                        boost::shared_ptr<ControlNameList> name_list = l->second;
 
886
                        Menu*                              ctl_menu  = NULL;
 
887
                        
 
888
                        for (ControlNameList::Controls::const_iterator c = name_list->controls().begin();
 
889
                             c != name_list->controls().end();) {
 
890
                                const uint16_t ctl = c->second->number();
 
891
                                if (ctl != MIDI_CTL_MSB_BANK && ctl != MIDI_CTL_LSB_BANK) {
 
892
                                        /* Skip bank select controllers since they're handled specially */
 
893
                                        if (n_items == 0) {
 
894
                                                /* Create a new submenu */
 
895
                                                ctl_menu = manage (new Menu);
 
896
                                        }
 
897
                                
 
898
                                        MenuList& ctl_items (ctl_menu->items());
 
899
                                        if (chn_cnt > 1) {
 
900
                                                add_multi_channel_controller_item(ctl_items, ctl, c->second->name());
 
901
                                        } else {
 
902
                                                add_single_channel_controller_item(ctl_items, ctl, c->second->name());
 
903
                                        }
 
904
                                }
 
905
 
 
906
                                ++c;
 
907
                                if (ctl_menu && (++n_items == 16 || c == name_list->controls().end())) {
 
908
                                        /* Submenu has 16 items or we're done, add it to controller menu and reset */
 
909
                                        items.push_back(
 
910
                                                MenuElem(string_compose(_("Controllers %1-%2"),
 
911
                                                                        (16 * n_groups), (16 * n_groups) + n_items - 1),
 
912
                                                         *ctl_menu));
 
913
                                        ctl_menu = NULL;
 
914
                                        n_items  = 0;
 
915
                                        ++n_groups;
 
916
                                }
 
917
                        }
 
918
                }
 
919
        } else {
 
920
                /* No controllers names, generate generic numeric menu */
 
921
                for (int i = 0; i < 127; i += 16) {
 
922
                        Menu*     ctl_menu = manage (new Menu);
 
923
                        MenuList& ctl_items (ctl_menu->items());
 
924
 
 
925
                        for (int ctl = i; ctl < i+16; ++ctl) {
 
926
                                if (ctl == MIDI_CTL_MSB_BANK || ctl == MIDI_CTL_LSB_BANK) {
 
927
                                        /* Skip bank select controllers since they're handled specially */
 
928
                                        continue;
 
929
                                }
 
930
 
 
931
                                if (chn_cnt > 1) {
 
932
                                        add_multi_channel_controller_item(
 
933
                                                ctl_items, ctl, string_compose(_("Controller %1"), ctl));
 
934
                                } else {
 
935
                                        add_single_channel_controller_item(
 
936
                                                ctl_items, ctl, string_compose(_("Controller %1"), ctl));
 
937
                                }
 
938
                        }
 
939
 
 
940
                        /* Add submenu for this block of controllers to controller menu */
 
941
                        items.push_back (
 
942
                                MenuElem (string_compose (_("Controllers %1-%2"), i, i + 15),
 
943
                                          *ctl_menu));
 
944
                }
 
945
        }
 
946
}
 
947
 
 
948
Gtk::Menu*
 
949
MidiTimeAxisView::build_note_mode_menu()
 
950
{
 
951
        using namespace Menu_Helpers;
 
952
 
 
953
        Menu* mode_menu = manage (new Menu);
 
954
        MenuList& items = mode_menu->items();
 
955
        mode_menu->set_name ("ArdourContextMenu");
 
956
 
 
957
        RadioMenuItem::Group mode_group;
 
958
        items.push_back (
 
959
                RadioMenuElem (mode_group,_("Sustained"),
 
960
                               sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_mode),
 
961
                                           Sustained, true)));
 
962
        _note_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
 
963
        _note_mode_item->set_active(_note_mode == Sustained);
 
964
 
 
965
        items.push_back (
 
966
                RadioMenuElem (mode_group, _("Percussive"),
 
967
                               sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_mode),
 
968
                                           Percussive, true)));
 
969
        _percussion_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
 
970
        _percussion_mode_item->set_active(_note_mode == Percussive);
 
971
 
 
972
        return mode_menu;
 
973
}
 
974
 
 
975
Gtk::Menu*
 
976
MidiTimeAxisView::build_color_mode_menu()
 
977
{
 
978
        using namespace Menu_Helpers;
 
979
 
 
980
        Menu* mode_menu = manage (new Menu);
 
981
        MenuList& items = mode_menu->items();
 
982
        mode_menu->set_name ("ArdourContextMenu");
 
983
 
 
984
        RadioMenuItem::Group mode_group;
 
985
        items.push_back (
 
986
                RadioMenuElem (mode_group, _("Meter Colors"),
 
987
                               sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode),
 
988
                                           MeterColors, false, true, true)));
 
989
        _meter_color_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
 
990
        _meter_color_mode_item->set_active(_color_mode == MeterColors);
 
991
 
 
992
        items.push_back (
 
993
                RadioMenuElem (mode_group, _("Channel Colors"),
 
994
                               sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode),
 
995
                                           ChannelColors, false, true, true)));
 
996
        _channel_color_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
 
997
        _channel_color_mode_item->set_active(_color_mode == ChannelColors);
 
998
 
 
999
        items.push_back (
 
1000
                RadioMenuElem (mode_group, _("Track Color"),
 
1001
                               sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_color_mode),
 
1002
                                           TrackColor, false, true, true)));
 
1003
        _channel_color_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
 
1004
        _channel_color_mode_item->set_active(_color_mode == TrackColor);
 
1005
 
 
1006
        return mode_menu;
 
1007
}
 
1008
 
 
1009
void
 
1010
MidiTimeAxisView::set_note_mode(NoteMode mode, bool apply_to_selection)
 
1011
{
 
1012
        if (apply_to_selection) {
 
1013
                _editor.get_selection().tracks.foreach_midi_time_axis (
 
1014
                        boost::bind (&MidiTimeAxisView::set_note_mode, _1, mode, false));
 
1015
        } else {
 
1016
                if (_note_mode != mode || midi_track()->note_mode() != mode) {
 
1017
                        _note_mode = mode;
 
1018
                        midi_track()->set_note_mode(mode);
 
1019
                        set_gui_property ("note-mode", enum_2_string(_note_mode));
 
1020
                        _view->redisplay_track();
 
1021
                }
 
1022
        }
 
1023
}
 
1024
 
 
1025
void
 
1026
MidiTimeAxisView::set_color_mode (ColorMode mode, bool force, bool redisplay, bool apply_to_selection)
 
1027
{
 
1028
        if (apply_to_selection) {
 
1029
                _editor.get_selection().tracks.foreach_midi_time_axis (
 
1030
                        boost::bind (&MidiTimeAxisView::set_color_mode, _1, mode, force, redisplay, false));
 
1031
        } else {
 
1032
                if (_color_mode == mode && !force) {
 
1033
                        return;
 
1034
                }
 
1035
                
 
1036
                if (_channel_selector) {
 
1037
                        if (mode == ChannelColors) {
 
1038
                                _channel_selector->set_channel_colors(CanvasNoteEvent::midi_channel_colors);
 
1039
                        } else {
 
1040
                                _channel_selector->set_default_channel_color();
 
1041
                        }
 
1042
                }
 
1043
                
 
1044
                _color_mode = mode;
 
1045
                set_gui_property ("color-mode", enum_2_string(_color_mode));
 
1046
                if (redisplay) {
 
1047
                        _view->redisplay_track();
 
1048
                }
 
1049
        }
 
1050
}
 
1051
 
 
1052
void
 
1053
MidiTimeAxisView::set_note_range (MidiStreamView::VisibleNoteRange range, bool apply_to_selection)
 
1054
{
 
1055
        if (apply_to_selection) {
 
1056
                _editor.get_selection().tracks.foreach_midi_time_axis (
 
1057
                        boost::bind (&MidiTimeAxisView::set_note_range, _1, range, false));
 
1058
        } else {
 
1059
                if (!_ignore_signals) {
 
1060
                        midi_view()->set_note_range(range);
 
1061
                }
 
1062
        }
 
1063
}
 
1064
 
 
1065
void
 
1066
MidiTimeAxisView::update_range()
 
1067
{
 
1068
        MidiGhostRegion* mgr;
 
1069
 
 
1070
        for (list<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
 
1071
                if ((mgr = dynamic_cast<MidiGhostRegion*>(*i)) != 0) {
 
1072
                        mgr->update_range();
 
1073
                }
 
1074
        }
 
1075
}
 
1076
 
 
1077
void
 
1078
MidiTimeAxisView::show_all_automation (bool apply_to_selection)
 
1079
{
 
1080
        if (apply_to_selection) {
 
1081
                _editor.get_selection().tracks.foreach_midi_time_axis (
 
1082
                        boost::bind (&MidiTimeAxisView::show_all_automation, _1, false));
 
1083
        } else {
 
1084
                if (midi_track()) {
 
1085
                        const set<Evoral::Parameter> params = midi_track()->midi_playlist()->contained_automation();
 
1086
 
 
1087
                        for (set<Evoral::Parameter>::const_iterator i = params.begin(); i != params.end(); ++i) {
 
1088
                                create_automation_child(*i, true);
 
1089
                        }
 
1090
                }
 
1091
 
 
1092
                RouteTimeAxisView::show_all_automation ();
 
1093
        }
 
1094
}
 
1095
 
 
1096
void
 
1097
MidiTimeAxisView::show_existing_automation (bool apply_to_selection)
 
1098
{
 
1099
        if (apply_to_selection) {
 
1100
                _editor.get_selection().tracks.foreach_midi_time_axis (
 
1101
                        boost::bind (&MidiTimeAxisView::show_existing_automation, _1, false));
 
1102
        } else {
 
1103
                if (midi_track()) {
 
1104
                        const set<Evoral::Parameter> params = midi_track()->midi_playlist()->contained_automation();
 
1105
 
 
1106
                        for (set<Evoral::Parameter>::const_iterator i = params.begin(); i != params.end(); ++i) {
 
1107
                                create_automation_child (*i, true);
 
1108
                        }
 
1109
                }
 
1110
 
 
1111
                RouteTimeAxisView::show_existing_automation ();
 
1112
        }
 
1113
}
 
1114
 
 
1115
/** Create an automation track for the given parameter (pitch bend, channel pressure).
 
1116
 */
 
1117
void
 
1118
MidiTimeAxisView::create_automation_child (const Evoral::Parameter& param, bool show)
 
1119
{
 
1120
        if (param.type() == NullAutomation) {
 
1121
                return;
 
1122
        }
 
1123
 
 
1124
        AutomationTracks::iterator existing = _automation_tracks.find (param);
 
1125
 
 
1126
        if (existing != _automation_tracks.end()) {
 
1127
 
 
1128
                /* automation track created because we had existing data for
 
1129
                 * the processor, but visibility may need to be controlled
 
1130
                 * since it will have been set visible by default.
 
1131
                 */
 
1132
 
 
1133
                if (existing->second->set_marked_for_display (show) && !no_redraw) {
 
1134
                        request_redraw ();
 
1135
                }
 
1136
 
 
1137
                return;
 
1138
        }
 
1139
 
 
1140
        boost::shared_ptr<AutomationTimeAxisView> track;
 
1141
 
 
1142
        switch (param.type()) {
 
1143
 
 
1144
        case GainAutomation:
 
1145
                create_gain_automation_child (param, show);
 
1146
                break;
 
1147
 
 
1148
        case PluginAutomation:
 
1149
                /* handled elsewhere */
 
1150
                break;
 
1151
 
 
1152
        case MidiCCAutomation:
 
1153
        case MidiPgmChangeAutomation:
 
1154
        case MidiPitchBenderAutomation:
 
1155
        case MidiChannelPressureAutomation:
 
1156
        case MidiSystemExclusiveAutomation:
 
1157
                /* These controllers are region "automation" - they are owned
 
1158
                 * by regions (and their MidiModels), not by the track. As a
 
1159
                 * result we do not create an AutomationList/Line for the track
 
1160
                 * ... except here we are doing something!! XXX 
 
1161
                 */
 
1162
 
 
1163
                track.reset (new AutomationTimeAxisView (
 
1164
                                     _session,
 
1165
                                     _route,
 
1166
                                     boost::shared_ptr<Automatable> (),
 
1167
                                     boost::shared_ptr<AutomationControl> (),
 
1168
                                     param,
 
1169
                                     _editor,
 
1170
                                     *this,
 
1171
                                     true,
 
1172
                                     parent_canvas,
 
1173
                                     _route->describe_parameter(param)));
 
1174
 
 
1175
                if (_view) {
 
1176
                        _view->foreach_regionview (
 
1177
                                sigc::mem_fun (*track.get(), &TimeAxisView::add_ghost));
 
1178
                }
 
1179
 
 
1180
                add_automation_child (param, track, show);
 
1181
                break;
 
1182
 
 
1183
        default:
 
1184
                error << "MidiTimeAxisView: unknown automation child "
 
1185
                      << EventTypeMap::instance().to_symbol(param) << endmsg;
 
1186
        }
 
1187
}
 
1188
 
 
1189
void
 
1190
MidiTimeAxisView::route_active_changed ()
 
1191
{
 
1192
        RouteUI::route_active_changed ();
 
1193
 
 
1194
        if (is_track()) {
 
1195
                if (_route->active()) {
 
1196
                        controls_ebox.set_name ("MidiTrackControlsBaseUnselected");
 
1197
                        controls_base_selected_name = "MidiTrackControlsBaseSelected";
 
1198
                        controls_base_unselected_name = "MidiTrackControlsBaseUnselected";
 
1199
                } else {
 
1200
                        controls_ebox.set_name ("MidiTrackControlsBaseInactiveUnselected");
 
1201
                        controls_base_selected_name = "MidiTrackControlsBaseInactiveSelected";
 
1202
                        controls_base_unselected_name = "MidiTrackControlsBaseInactiveUnselected";
 
1203
                }
 
1204
        } else {
 
1205
                if (_route->active()) {
 
1206
                        controls_ebox.set_name ("BusControlsBaseUnselected");
 
1207
                        controls_base_selected_name = "BusControlsBaseSelected";
 
1208
                        controls_base_unselected_name = "BusControlsBaseUnselected";
 
1209
                } else {
 
1210
                        controls_ebox.set_name ("BusControlsBaseInactiveUnselected");
 
1211
                        controls_base_selected_name = "BusControlsBaseInactiveSelected";
 
1212
                        controls_base_unselected_name = "BusControlsBaseInactiveUnselected";
 
1213
                }
 
1214
        }
 
1215
}
 
1216
 
 
1217
void
 
1218
MidiTimeAxisView::set_note_selection (uint8_t note)
 
1219
{
 
1220
        if (!_editor.internal_editing()) {
 
1221
                return;
 
1222
        }
 
1223
 
 
1224
        uint16_t chn_mask = midi_track()->get_playback_channel_mask();
 
1225
 
 
1226
        if (_view->num_selected_regionviews() == 0) {
 
1227
                _view->foreach_regionview (
 
1228
                        sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection_region_view),
 
1229
                                    note, chn_mask));
 
1230
        } else {
 
1231
                _view->foreach_selected_regionview (
 
1232
                        sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::set_note_selection_region_view),
 
1233
                                    note, chn_mask));
 
1234
        }
 
1235
}
 
1236
 
 
1237
void
 
1238
MidiTimeAxisView::add_note_selection (uint8_t note)
 
1239
{
 
1240
        if (!_editor.internal_editing()) {
 
1241
                return;
 
1242
        }
 
1243
 
 
1244
        const uint16_t chn_mask = midi_track()->get_playback_channel_mask();
 
1245
 
 
1246
        if (_view->num_selected_regionviews() == 0) {
 
1247
                _view->foreach_regionview (
 
1248
                        sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection_region_view),
 
1249
                                    note, chn_mask));
 
1250
        } else {
 
1251
                _view->foreach_selected_regionview (
 
1252
                        sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::add_note_selection_region_view),
 
1253
                                    note, chn_mask));
 
1254
        }
 
1255
}
 
1256
 
 
1257
void
 
1258
MidiTimeAxisView::extend_note_selection (uint8_t note)
 
1259
{
 
1260
        if (!_editor.internal_editing()) {
 
1261
                return;
 
1262
        }
 
1263
 
 
1264
        const uint16_t chn_mask = midi_track()->get_playback_channel_mask();
 
1265
 
 
1266
        if (_view->num_selected_regionviews() == 0) {
 
1267
                _view->foreach_regionview (
 
1268
                        sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection_region_view),
 
1269
                                    note, chn_mask));
 
1270
        } else {
 
1271
                _view->foreach_selected_regionview (
 
1272
                        sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::extend_note_selection_region_view),
 
1273
                                    note, chn_mask));
 
1274
        }
 
1275
}
 
1276
 
 
1277
void
 
1278
MidiTimeAxisView::toggle_note_selection (uint8_t note)
 
1279
{
 
1280
        if (!_editor.internal_editing()) {
 
1281
                return;
 
1282
        }
 
1283
 
 
1284
        const uint16_t chn_mask = midi_track()->get_playback_channel_mask();
 
1285
 
 
1286
        if (_view->num_selected_regionviews() == 0) {
 
1287
                _view->foreach_regionview (
 
1288
                        sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection_region_view),
 
1289
                                    note, chn_mask));
 
1290
        } else {
 
1291
                _view->foreach_selected_regionview (
 
1292
                        sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::toggle_note_selection_region_view),
 
1293
                                    note, chn_mask));
 
1294
        }
 
1295
}
 
1296
 
 
1297
void
 
1298
MidiTimeAxisView::set_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask)
 
1299
{
 
1300
        dynamic_cast<MidiRegionView*>(rv)->select_matching_notes (note, chn_mask, false, false);
 
1301
}
 
1302
 
 
1303
void
 
1304
MidiTimeAxisView::add_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask)
 
1305
{
 
1306
        dynamic_cast<MidiRegionView*>(rv)->select_matching_notes (note, chn_mask, true, false);
 
1307
}
 
1308
 
 
1309
void
 
1310
MidiTimeAxisView::extend_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask)
 
1311
{
 
1312
        dynamic_cast<MidiRegionView*>(rv)->select_matching_notes (note, chn_mask, true, true);
 
1313
}
 
1314
 
 
1315
void
 
1316
MidiTimeAxisView::toggle_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask)
 
1317
{
 
1318
        dynamic_cast<MidiRegionView*>(rv)->toggle_matching_notes (note, chn_mask);
 
1319
}
 
1320
 
 
1321
void
 
1322
MidiTimeAxisView::set_channel_mode (ChannelMode, uint16_t)
 
1323
{
 
1324
        /* hide all automation tracks that use the wrong channel(s) and show all those that use
 
1325
           the right ones.
 
1326
        */
 
1327
 
 
1328
        const uint16_t selected_channels = midi_track()->get_playback_channel_mask();
 
1329
        bool changed = false;
 
1330
 
 
1331
        no_redraw = true;
 
1332
 
 
1333
        for (uint32_t ctl = 0; ctl < 127; ++ctl) {
 
1334
 
 
1335
                for (uint32_t chn = 0; chn < 16; ++chn) {
 
1336
                        Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl);
 
1337
                        boost::shared_ptr<AutomationTimeAxisView> track = automation_child (fully_qualified_param);
 
1338
 
 
1339
                        if (!track) {
 
1340
                                continue;
 
1341
                        }
 
1342
 
 
1343
                        if ((selected_channels & (0x0001 << chn)) == 0) {
 
1344
                                /* channel not in use. hiding it will trigger RouteTimeAxisView::automation_track_hidden()
 
1345
                                   which will cause a redraw. We don't want one per channel, so block that with no_redraw.
 
1346
                                */
 
1347
                                changed = track->set_marked_for_display (false) || changed;
 
1348
                        } else {
 
1349
                                changed = track->set_marked_for_display (true) || changed;
 
1350
                        }
 
1351
                }
 
1352
        }
 
1353
 
 
1354
        no_redraw = false;
 
1355
 
 
1356
        /* TODO: Bender, Pressure */
 
1357
 
 
1358
        /* invalidate the controller menu, so that we rebuild it next time */
 
1359
        _controller_menu_map.clear ();
 
1360
        delete controller_menu;
 
1361
        controller_menu = 0;
 
1362
 
 
1363
        if (changed) {
 
1364
                request_redraw ();
 
1365
        }
 
1366
}
 
1367
 
 
1368
Gtk::CheckMenuItem*
 
1369
MidiTimeAxisView::automation_child_menu_item (Evoral::Parameter param)
 
1370
{
 
1371
        Gtk::CheckMenuItem* m = RouteTimeAxisView::automation_child_menu_item (param);
 
1372
        if (m) {
 
1373
                return m;
 
1374
        }
 
1375
 
 
1376
        ParameterMenuMap::iterator i = _controller_menu_map.find (param);
 
1377
        if (i != _controller_menu_map.end()) {
 
1378
                return i->second;
 
1379
        }
 
1380
 
 
1381
        i = _channel_command_menu_map.find (param);
 
1382
        if (i != _channel_command_menu_map.end()) {
 
1383
                return i->second;
 
1384
        }
 
1385
 
 
1386
        return 0;
 
1387
}
 
1388
 
 
1389
boost::shared_ptr<MidiRegion>
 
1390
MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit)
 
1391
{
 
1392
        Editor* real_editor = dynamic_cast<Editor*> (&_editor);
 
1393
 
 
1394
        real_editor->begin_reversible_command (Operations::create_region);
 
1395
        playlist()->clear_changes ();
 
1396
 
 
1397
        real_editor->snap_to (pos, 0);
 
1398
 
 
1399
        boost::shared_ptr<Source> src = _session->create_midi_source_for_session (
 
1400
                view()->trackview().track().get(), view()->trackview().track()->name());
 
1401
        PropertyList plist;
 
1402
 
 
1403
        plist.add (ARDOUR::Properties::start, 0);
 
1404
        plist.add (ARDOUR::Properties::length, length);
 
1405
        plist.add (ARDOUR::Properties::name, PBD::basename_nosuffix(src->name()));
 
1406
 
 
1407
        boost::shared_ptr<Region> region = (RegionFactory::create (src, plist));
 
1408
 
 
1409
        playlist()->add_region (region, pos);
 
1410
        _session->add_command (new StatefulDiffCommand (playlist()));
 
1411
 
 
1412
        if (commit) {
 
1413
                real_editor->commit_reversible_command ();
 
1414
        }
 
1415
 
 
1416
        return boost::dynamic_pointer_cast<MidiRegion>(region);
 
1417
}
 
1418
 
 
1419
void
 
1420
MidiTimeAxisView::ensure_step_editor ()
 
1421
{
 
1422
        if (!_step_editor) {
 
1423
                _step_editor = new StepEditor (_editor, midi_track(), *this);
 
1424
        }
 
1425
}
 
1426
 
 
1427
void
 
1428
MidiTimeAxisView::start_step_editing ()
 
1429
{
 
1430
        ensure_step_editor ();
 
1431
        _step_editor->start_step_editing ();
 
1432
 
 
1433
}
 
1434
void
 
1435
MidiTimeAxisView::stop_step_editing ()
 
1436
{
 
1437
        if (_step_editor) {
 
1438
                _step_editor->stop_step_editing ();
 
1439
        }
 
1440
}
 
1441
 
 
1442
/** @return channel (counted from 0) to add an event to, based on the current setting
 
1443
 *  of the channel selector.
 
1444
 */
 
1445
uint8_t
 
1446
MidiTimeAxisView::get_channel_for_add () const
 
1447
{
 
1448
        uint16_t const chn_mask = midi_track()->get_playback_channel_mask();
 
1449
        int chn_cnt = 0;
 
1450
        uint8_t channel = 0;
 
1451
 
 
1452
        /* pick the highest selected channel, unless all channels are selected,
 
1453
           which is interpreted to mean channel 1 (zero)
 
1454
        */
 
1455
 
 
1456
        for (uint16_t i = 0; i < 16; ++i) {
 
1457
                if (chn_mask & (1<<i)) {
 
1458
                        channel = i;
 
1459
                        chn_cnt++;
 
1460
                }
 
1461
        }
 
1462
 
 
1463
        if (chn_cnt == 16) {
 
1464
                channel = 0;
 
1465
        }
 
1466
 
 
1467
        return channel;
 
1468
}
 
1469
 
 
1470
void
 
1471
MidiTimeAxisView::note_range_changed ()
 
1472
{
 
1473
        set_gui_property ("note-range-min", (int) midi_view()->lowest_note ());
 
1474
        set_gui_property ("note-range-max", (int) midi_view()->highest_note ());
 
1475
}
 
1476
 
 
1477
void
 
1478
MidiTimeAxisView::contents_height_changed ()
 
1479
{
 
1480
        _range_scroomer->set_size_request (-1, _view->child_height ());
 
1481
}
 
1482
 
 
1483
void
 
1484
MidiTimeAxisView::playback_channel_mode_changed ()
 
1485
{
 
1486
        switch (midi_track()->get_playback_channel_mode()) {
 
1487
        case AllChannels:
 
1488
                _playback_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2</i>", _("Play"), _("all")));
 
1489
                break;
 
1490
        case FilterChannels:
 
1491
                _playback_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2</i>", _("Play"), _("some")));
 
1492
                break;
 
1493
        case ForceChannel:
 
1494
                _playback_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2>%3</i>", _("Play"), _("all"), ffs (midi_track()->get_playback_channel_mask())));
 
1495
                break;
 
1496
        }
 
1497
}
 
1498
 
 
1499
void
 
1500
MidiTimeAxisView::capture_channel_mode_changed ()
 
1501
{
 
1502
        switch (midi_track()->get_capture_channel_mode()) {
 
1503
        case AllChannels:
 
1504
                _capture_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2</i>", _("Rec"), _("all")));
 
1505
                break;
 
1506
        case FilterChannels:
 
1507
                _capture_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2</i>", _("Rec"), _("some")));
 
1508
                break;
 
1509
        case ForceChannel:
 
1510
                _capture_channel_status.set_markup (string_compose ("<b>%1</b>: <i>%2>%3</i>", _("Rec"), _("all"), ffs (midi_track()->get_capture_channel_mask())));
 
1511
                break;
 
1512
        }
 
1513
}