2005-09-25 14:42:24 -04:00
|
|
|
/*
|
2019-08-02 17:26:43 -04:00
|
|
|
* Copyright (C) 2009-2011 Carl Hetherington <carl@carlh.net>
|
|
|
|
* Copyright (C) 2009-2014 David Robillard <d@drobilla.net>
|
|
|
|
* Copyright (C) 2009-2017 Paul Davis <paul@linuxaudiosystems.com>
|
|
|
|
* Copyright (C) 2013-2015 Nick Mainsbridge <mainsbridge@gmail.com>
|
|
|
|
* Copyright (C) 2014-2019 Robin Gareus <robin@gareus.org>
|
|
|
|
* Copyright (C) 2016-2018 Len Ovens <len@ovenwerks.net>
|
|
|
|
*
|
|
|
|
* 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.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
#include <cstdlib>
|
|
|
|
#include <cassert>
|
|
|
|
#include <cmath>
|
2008-12-08 13:16:12 -05:00
|
|
|
#include <list>
|
|
|
|
#include <vector>
|
2005-09-25 14:42:24 -04:00
|
|
|
#include <algorithm>
|
|
|
|
|
2012-06-27 18:57:06 -04:00
|
|
|
#include "pbd/unknown_type.h"
|
|
|
|
#include "pbd/unwind.h"
|
|
|
|
|
|
|
|
#include "ardour/debug.h"
|
2016-05-16 07:30:28 -04:00
|
|
|
#include "ardour/audio_track.h"
|
2012-06-27 18:57:06 -04:00
|
|
|
#include "ardour/midi_track.h"
|
2014-09-07 14:11:28 -04:00
|
|
|
#include "ardour/route.h"
|
2017-05-05 07:31:49 -04:00
|
|
|
#include "ardour/selection.h"
|
2009-10-30 11:30:22 -04:00
|
|
|
#include "ardour/session.h"
|
2016-04-08 16:49:47 -04:00
|
|
|
#include "ardour/solo_isolate_control.h"
|
|
|
|
#include "ardour/utils.h"
|
2016-05-21 16:36:08 -04:00
|
|
|
#include "ardour/vca.h"
|
|
|
|
#include "ardour/vca_manager.h"
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2012-06-27 22:11:26 -04:00
|
|
|
#include "gtkmm2ext/cell_renderer_pixbuf_multi.h"
|
|
|
|
#include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
|
|
|
|
#include "gtkmm2ext/treeutils.h"
|
|
|
|
|
2017-07-15 11:38:28 -04:00
|
|
|
#include "widgets/tooltips.h"
|
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
#include "actions.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
#include "ardour_ui.h"
|
|
|
|
#include "audio_time_axis.h"
|
2014-09-07 14:11:28 -04:00
|
|
|
#include "editor.h"
|
|
|
|
#include "editor_group_tabs.h"
|
|
|
|
#include "editor_routes.h"
|
|
|
|
#include "gui_thread.h"
|
|
|
|
#include "keyboard.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "midi_time_axis.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
#include "mixer_strip.h"
|
2016-05-19 10:29:39 -04:00
|
|
|
#include "plugin_setup_dialog.h"
|
2012-10-26 20:15:45 -04:00
|
|
|
#include "route_sorter.h"
|
2016-05-21 16:36:08 -04:00
|
|
|
#include "vca_time_axis.h"
|
2014-09-07 14:11:28 -04:00
|
|
|
#include "utils.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2016-07-14 14:44:52 -04:00
|
|
|
#include "pbd/i18n.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
using namespace std;
|
2005-09-25 14:42:24 -04:00
|
|
|
using namespace ARDOUR;
|
2017-07-15 11:38:28 -04:00
|
|
|
using namespace ArdourWidgets;
|
2014-06-25 15:27:37 -04:00
|
|
|
using namespace ARDOUR_UI_UTILS;
|
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
|
|
|
using namespace PBD;
|
2005-09-25 14:42:24 -04:00
|
|
|
using namespace Gtk;
|
2009-07-01 19:20:18 -04:00
|
|
|
using namespace Gtkmm2ext;
|
2008-01-10 16:20:59 -05:00
|
|
|
using namespace Glib;
|
2009-12-04 17:51:32 -05:00
|
|
|
using Gtkmm2ext::Keyboard;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2011-12-02 09:52:04 -05:00
|
|
|
struct ColumnInfo {
|
2014-09-07 14:11:28 -04:00
|
|
|
int index;
|
|
|
|
const char* label;
|
|
|
|
const char* tooltip;
|
2011-12-02 09:52:04 -05:00
|
|
|
};
|
|
|
|
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::EditorRoutes (Editor* e)
|
2010-09-28 21:22:11 -04:00
|
|
|
: EditorComponent (e)
|
2014-09-07 14:11:28 -04:00
|
|
|
, _ignore_reorder (false)
|
2017-01-27 13:18:33 -05:00
|
|
|
, _ignore_selection_change (false)
|
2020-01-14 01:13:04 -05:00
|
|
|
, column_does_not_select (false)
|
2014-09-07 14:11:28 -04:00
|
|
|
, _no_redisplay (false)
|
|
|
|
, _adding_routes (false)
|
|
|
|
, _route_deletion_in_progress (false)
|
2015-04-30 12:52:56 -04:00
|
|
|
, _redisplay_on_resume (false)
|
2021-03-18 22:14:14 -04:00
|
|
|
, _idle_update_queued (false)
|
2014-09-07 14:11:28 -04:00
|
|
|
, _redisplay_active (0)
|
|
|
|
, _menu (0)
|
|
|
|
, old_focus (0)
|
2015-04-30 12:01:30 -04:00
|
|
|
, name_editable (0)
|
2009-07-01 19:20:18 -04:00
|
|
|
{
|
2011-07-01 19:37:42 -04:00
|
|
|
static const int column_width = 22;
|
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
_scroller.add (_display);
|
|
|
|
_scroller.set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
|
|
|
|
|
|
|
|
_model = ListStore::create (_columns);
|
|
|
|
_display.set_model (_model);
|
|
|
|
|
2020-01-14 01:13:04 -05:00
|
|
|
_display.get_selection()->set_select_function (sigc::mem_fun (*this, &EditorRoutes::select_function));
|
|
|
|
|
2009-11-16 08:35:00 -05:00
|
|
|
// Record enable toggle
|
2010-08-15 06:33:41 -04:00
|
|
|
CellRendererPixbufMulti* rec_col_renderer = manage (new CellRendererPixbufMulti());
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2011-07-09 16:22:53 -04:00
|
|
|
rec_col_renderer->set_pixbuf (0, ::get_icon("record-normal-disabled"));
|
|
|
|
rec_col_renderer->set_pixbuf (1, ::get_icon("record-normal-in-progress"));
|
|
|
|
rec_col_renderer->set_pixbuf (2, ::get_icon("record-normal-enabled"));
|
|
|
|
rec_col_renderer->set_pixbuf (3, ::get_icon("record-step"));
|
2010-08-15 06:33:41 -04:00
|
|
|
rec_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_rec_enable_changed));
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2020-01-13 23:26:12 -05:00
|
|
|
rec_state_column = manage (new TreeViewColumn("R", *rec_col_renderer));
|
2009-11-16 08:35:00 -05:00
|
|
|
|
2010-08-15 06:33:41 -04:00
|
|
|
rec_state_column->add_attribute(rec_col_renderer->property_state(), _columns.rec_state);
|
2009-07-01 19:20:18 -04:00
|
|
|
rec_state_column->add_attribute(rec_col_renderer->property_visible(), _columns.is_track);
|
2011-07-01 11:48:24 -04:00
|
|
|
|
2010-01-22 12:23:58 -05:00
|
|
|
rec_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
rec_state_column->set_alignment(ALIGN_CENTER);
|
|
|
|
rec_state_column->set_expand(false);
|
2011-07-01 19:37:42 -04:00
|
|
|
rec_state_column->set_fixed_width(column_width);
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2016-05-24 15:30:33 -04:00
|
|
|
|
|
|
|
// Record safe toggle
|
|
|
|
CellRendererPixbufMulti* rec_safe_renderer = manage (new CellRendererPixbufMulti ());
|
|
|
|
|
|
|
|
rec_safe_renderer->set_pixbuf (0, ::get_icon("rec-safe-disabled"));
|
|
|
|
rec_safe_renderer->set_pixbuf (1, ::get_icon("rec-safe-enabled"));
|
|
|
|
rec_safe_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_rec_safe_toggled));
|
|
|
|
|
2020-01-13 23:26:12 -05:00
|
|
|
rec_safe_column = manage (new TreeViewColumn(_("RS"), *rec_safe_renderer));
|
2016-05-24 15:30:33 -04:00
|
|
|
rec_safe_column->add_attribute(rec_safe_renderer->property_state(), _columns.rec_safe);
|
|
|
|
rec_safe_column->add_attribute(rec_safe_renderer->property_visible(), _columns.is_track);
|
|
|
|
rec_safe_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
rec_safe_column->set_alignment(ALIGN_CENTER);
|
|
|
|
rec_safe_column->set_expand(false);
|
|
|
|
rec_safe_column->set_fixed_width(column_width);
|
|
|
|
|
|
|
|
|
2011-07-01 11:48:24 -04:00
|
|
|
// MIDI Input Active
|
|
|
|
|
|
|
|
CellRendererPixbufMulti* input_active_col_renderer = manage (new CellRendererPixbufMulti());
|
2011-07-09 16:22:53 -04:00
|
|
|
input_active_col_renderer->set_pixbuf (0, ::get_icon("midi-input-inactive"));
|
2011-07-01 12:31:21 -04:00
|
|
|
input_active_col_renderer->set_pixbuf (1, ::get_icon("midi-input-active"));
|
2011-07-01 11:48:24 -04:00
|
|
|
input_active_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_input_active_changed));
|
|
|
|
|
2020-01-13 23:26:12 -05:00
|
|
|
input_active_column = manage (new TreeViewColumn ("I", *input_active_col_renderer));
|
2011-07-01 11:48:24 -04:00
|
|
|
|
|
|
|
input_active_column->add_attribute(input_active_col_renderer->property_state(), _columns.is_input_active);
|
|
|
|
input_active_column->add_attribute (input_active_col_renderer->property_visible(), _columns.is_midi);
|
|
|
|
|
|
|
|
input_active_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
input_active_column->set_alignment(ALIGN_CENTER);
|
|
|
|
input_active_column->set_expand(false);
|
2011-07-01 19:37:42 -04:00
|
|
|
input_active_column->set_fixed_width(column_width);
|
2011-07-01 11:48:24 -04:00
|
|
|
|
2009-11-16 08:35:00 -05:00
|
|
|
// Mute enable toggle
|
2009-11-21 12:20:57 -05:00
|
|
|
CellRendererPixbufMulti* mute_col_renderer = manage (new CellRendererPixbufMulti());
|
2009-11-16 08:35:00 -05:00
|
|
|
|
2012-02-07 12:43:55 -05:00
|
|
|
mute_col_renderer->set_pixbuf (Gtkmm2ext::Off, ::get_icon("mute-disabled"));
|
|
|
|
mute_col_renderer->set_pixbuf (Gtkmm2ext::ImplicitActive, ::get_icon("muted-by-others"));
|
|
|
|
mute_col_renderer->set_pixbuf (Gtkmm2ext::ExplicitActive, ::get_icon("mute-enabled"));
|
2009-12-11 18:29:48 -05:00
|
|
|
mute_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_mute_enable_toggled));
|
2009-11-16 08:35:00 -05:00
|
|
|
|
2020-01-13 23:26:12 -05:00
|
|
|
mute_state_column = manage (new TreeViewColumn("M", *mute_col_renderer));
|
2009-11-16 08:35:00 -05:00
|
|
|
|
2009-11-21 12:20:57 -05:00
|
|
|
mute_state_column->add_attribute(mute_col_renderer->property_state(), _columns.mute_state);
|
2010-01-22 12:23:58 -05:00
|
|
|
mute_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
mute_state_column->set_alignment(ALIGN_CENTER);
|
|
|
|
mute_state_column->set_expand(false);
|
|
|
|
mute_state_column->set_fixed_width(15);
|
2009-11-16 08:35:00 -05:00
|
|
|
|
|
|
|
// Solo enable toggle
|
2009-11-21 12:20:57 -05:00
|
|
|
CellRendererPixbufMulti* solo_col_renderer = manage (new CellRendererPixbufMulti());
|
2009-11-16 08:35:00 -05:00
|
|
|
|
2012-02-07 12:43:55 -05:00
|
|
|
solo_col_renderer->set_pixbuf (Gtkmm2ext::Off, ::get_icon("solo-disabled"));
|
|
|
|
solo_col_renderer->set_pixbuf (Gtkmm2ext::ExplicitActive, ::get_icon("solo-enabled"));
|
|
|
|
solo_col_renderer->set_pixbuf (Gtkmm2ext::ImplicitActive, ::get_icon("soloed-by-others"));
|
2009-12-11 18:29:48 -05:00
|
|
|
solo_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_enable_toggled));
|
2009-11-16 08:35:00 -05:00
|
|
|
|
2020-01-13 23:26:12 -05:00
|
|
|
solo_state_column = manage (new TreeViewColumn("S", *solo_col_renderer));
|
2009-11-16 08:35:00 -05:00
|
|
|
|
2009-11-21 12:20:57 -05:00
|
|
|
solo_state_column->add_attribute(solo_col_renderer->property_state(), _columns.solo_state);
|
2011-11-17 19:08:47 -05:00
|
|
|
solo_state_column->add_attribute(solo_col_renderer->property_visible(), _columns.solo_visible);
|
2010-01-22 12:23:58 -05:00
|
|
|
solo_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
solo_state_column->set_alignment(ALIGN_CENTER);
|
|
|
|
solo_state_column->set_expand(false);
|
2011-07-01 19:37:42 -04:00
|
|
|
solo_state_column->set_fixed_width(column_width);
|
2009-11-30 14:48:50 -05:00
|
|
|
|
2009-12-10 15:51:35 -05:00
|
|
|
// Solo isolate toggle
|
|
|
|
CellRendererPixbufMulti* solo_iso_renderer = manage (new CellRendererPixbufMulti());
|
|
|
|
|
2011-07-01 17:05:58 -04:00
|
|
|
solo_iso_renderer->set_pixbuf (0, ::get_icon("solo-isolate-disabled"));
|
|
|
|
solo_iso_renderer->set_pixbuf (1, ::get_icon("solo-isolate-enabled"));
|
2009-12-11 18:29:48 -05:00
|
|
|
solo_iso_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_isolate_toggled));
|
2009-12-10 15:51:35 -05:00
|
|
|
|
2020-01-13 23:26:12 -05:00
|
|
|
solo_isolate_state_column = manage (new TreeViewColumn("SI", *solo_iso_renderer));
|
2009-12-10 15:51:35 -05:00
|
|
|
|
|
|
|
solo_isolate_state_column->add_attribute(solo_iso_renderer->property_state(), _columns.solo_isolate_state);
|
2017-08-06 17:49:12 -04:00
|
|
|
solo_isolate_state_column->add_attribute(solo_iso_renderer->property_visible(), _columns.solo_lock_iso_visible);
|
2010-01-22 12:23:58 -05:00
|
|
|
solo_isolate_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
solo_isolate_state_column->set_alignment(ALIGN_CENTER);
|
|
|
|
solo_isolate_state_column->set_expand(false);
|
2011-07-01 19:37:42 -04:00
|
|
|
solo_isolate_state_column->set_fixed_width(column_width);
|
2009-12-10 15:51:35 -05:00
|
|
|
|
2010-04-05 16:08:37 -04:00
|
|
|
// Solo safe toggle
|
|
|
|
CellRendererPixbufMulti* solo_safe_renderer = manage (new CellRendererPixbufMulti ());
|
|
|
|
|
2011-07-01 17:05:58 -04:00
|
|
|
solo_safe_renderer->set_pixbuf (0, ::get_icon("solo-safe-disabled"));
|
|
|
|
solo_safe_renderer->set_pixbuf (1, ::get_icon("solo-safe-enabled"));
|
2010-04-05 16:08:37 -04:00
|
|
|
solo_safe_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_safe_toggled));
|
|
|
|
|
2020-01-13 23:26:12 -05:00
|
|
|
solo_safe_state_column = manage (new TreeViewColumn(_("SS"), *solo_safe_renderer));
|
2010-04-05 16:08:37 -04:00
|
|
|
solo_safe_state_column->add_attribute(solo_safe_renderer->property_state(), _columns.solo_safe_state);
|
2017-08-06 17:49:12 -04:00
|
|
|
solo_safe_state_column->add_attribute(solo_safe_renderer->property_visible(), _columns.solo_lock_iso_visible);
|
2010-04-05 16:08:37 -04:00
|
|
|
solo_safe_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
solo_safe_state_column->set_alignment(ALIGN_CENTER);
|
|
|
|
solo_safe_state_column->set_expand(false);
|
2011-07-01 19:37:42 -04:00
|
|
|
solo_safe_state_column->set_fixed_width(column_width);
|
2010-04-05 16:08:37 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
_name_column = _display.append_column ("", _columns.text) - 1;
|
2012-03-20 13:08:07 -04:00
|
|
|
_visible_column = _display.append_column ("", _columns.visible) - 1;
|
2022-01-01 10:52:55 -05:00
|
|
|
_trigger_column = _display.append_column ("", _columns.trigger) - 1;
|
2012-03-20 13:08:07 -04:00
|
|
|
_active_column = _display.append_column ("", _columns.active) - 1;
|
|
|
|
|
2020-01-14 01:13:04 -05:00
|
|
|
name_column = _display.get_column (_name_column);
|
|
|
|
visible_column = _display.get_column (_visible_column);
|
2022-01-01 10:52:55 -05:00
|
|
|
trigger_column = _display.get_column (_trigger_column);
|
2020-01-14 01:13:04 -05:00
|
|
|
active_column = _display.get_column (_active_column);
|
|
|
|
|
2011-07-01 11:48:24 -04:00
|
|
|
_display.append_column (*input_active_column);
|
2009-07-01 19:20:18 -04:00
|
|
|
_display.append_column (*rec_state_column);
|
2016-05-24 15:30:33 -04:00
|
|
|
_display.append_column (*rec_safe_column);
|
2009-11-16 08:35:00 -05:00
|
|
|
_display.append_column (*mute_state_column);
|
|
|
|
_display.append_column (*solo_state_column);
|
2009-12-10 15:51:35 -05:00
|
|
|
_display.append_column (*solo_isolate_state_column);
|
2010-04-05 16:08:37 -04:00
|
|
|
_display.append_column (*solo_safe_state_column);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-12-02 09:52:04 -05:00
|
|
|
|
|
|
|
TreeViewColumn* col;
|
|
|
|
Gtk::Label* l;
|
|
|
|
|
|
|
|
ColumnInfo ci[] = {
|
2015-04-04 18:44:03 -04:00
|
|
|
{ 0, _("Name"), _("Track/Bus Name") },
|
|
|
|
{ 1, S_("Visible|V"), _("Track/Bus visible ?") },
|
2022-01-01 10:52:55 -05:00
|
|
|
{ 2, S_("Trigger|T"), _("Visible on TriggerPage ?") },
|
|
|
|
{ 3, S_("Active|A"), _("Track/Bus active ?") },
|
|
|
|
{ 4, S_("MidiInput|I"), _("MIDI input enabled") },
|
|
|
|
{ 5, S_("Rec|R"), _("Record enabled") },
|
|
|
|
{ 6, S_("Rec|RS"), _("Record Safe") },
|
|
|
|
{ 7, S_("Mute|M"), _("Muted") },
|
|
|
|
{ 8, S_("Solo|S"), _("Soloed") },
|
|
|
|
{ 9, S_("SoloIso|SI"), _("Solo Isolated") },
|
|
|
|
{10, S_("SoloLock|SS"), _("Solo Safe (Locked)") },
|
2011-12-02 09:52:04 -05:00
|
|
|
{ -1, 0, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
for (int i = 0; ci[i].index >= 0; ++i) {
|
|
|
|
col = _display.get_column (ci[i].index);
|
|
|
|
l = manage (new Label (ci[i].label));
|
2015-01-05 00:32:14 -05:00
|
|
|
set_tooltip (*l, ci[i].tooltip);
|
2011-12-02 09:52:04 -05:00
|
|
|
col->set_widget (*l);
|
|
|
|
l->show ();
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
_display.set_headers_visible (true);
|
2017-01-27 13:18:33 -05:00
|
|
|
_display.get_selection()->set_mode (SELECTION_MULTIPLE);
|
2014-03-24 17:31:26 -04:00
|
|
|
_display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::selection_changed));
|
2009-07-01 19:20:18 -04:00
|
|
|
_display.set_reorderable (true);
|
2012-12-07 17:38:49 -05:00
|
|
|
_display.set_name (X_("EditGroupList"));
|
2009-07-01 19:20:18 -04:00
|
|
|
_display.set_rules_hint (true);
|
|
|
|
_display.set_size_request (100, -1);
|
|
|
|
|
2011-07-01 11:48:24 -04:00
|
|
|
CellRendererText* name_cell = dynamic_cast<CellRendererText*> (_display.get_column_cell_renderer (_name_column));
|
2010-01-22 12:23:58 -05:00
|
|
|
|
2009-11-11 19:17:45 -05:00
|
|
|
assert (name_cell);
|
2014-09-07 14:11:28 -04:00
|
|
|
name_cell->signal_editing_started().connect (sigc::mem_fun (*this, &EditorRoutes::name_edit_started));
|
2009-11-24 18:59:15 -05:00
|
|
|
|
2011-07-01 11:48:24 -04:00
|
|
|
TreeViewColumn* name_column = _display.get_column (_name_column);
|
2010-01-22 12:23:58 -05:00
|
|
|
|
2009-11-24 18:59:15 -05:00
|
|
|
assert (name_column);
|
|
|
|
|
|
|
|
name_column->add_attribute (name_cell->property_editable(), _columns.name_editable);
|
2010-01-22 12:23:58 -05:00
|
|
|
name_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
name_column->set_expand(true);
|
|
|
|
name_column->set_min_width(50);
|
|
|
|
|
2009-11-11 19:17:45 -05:00
|
|
|
name_cell->property_editable() = true;
|
2009-12-11 18:29:48 -05:00
|
|
|
name_cell->signal_edited().connect (sigc::mem_fun (*this, &EditorRoutes::name_edit));
|
2009-11-11 19:17:45 -05:00
|
|
|
|
2010-01-22 12:23:58 -05:00
|
|
|
// Set the visible column cell renderer to radio toggle
|
2011-07-01 11:48:24 -04:00
|
|
|
CellRendererToggle* visible_cell = dynamic_cast<CellRendererToggle*> (_display.get_column_cell_renderer (_visible_column));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
visible_cell->property_activatable() = true;
|
|
|
|
visible_cell->property_radio() = false;
|
2009-12-11 18:29:48 -05:00
|
|
|
visible_cell->signal_toggled().connect (sigc::mem_fun (*this, &EditorRoutes::visible_changed));
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-07-01 11:48:24 -04:00
|
|
|
TreeViewColumn* visible_col = dynamic_cast<TreeViewColumn*> (_display.get_column (_visible_column));
|
2010-01-22 12:23:58 -05:00
|
|
|
visible_col->set_expand(false);
|
2010-01-24 21:03:24 -05:00
|
|
|
visible_col->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
visible_col->set_fixed_width(30);
|
|
|
|
visible_col->set_alignment(ALIGN_CENTER);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2022-01-01 10:52:55 -05:00
|
|
|
CellRendererToggle* trigger_cell = dynamic_cast<CellRendererToggle*> (_display.get_column_cell_renderer (_trigger_column));
|
|
|
|
|
|
|
|
trigger_cell->property_activatable() = true;
|
|
|
|
trigger_cell->property_radio() = false;
|
|
|
|
trigger_cell->signal_toggled().connect (sigc::mem_fun (*this, &EditorRoutes::trigger_changed));
|
|
|
|
|
|
|
|
TreeViewColumn* trigger_col = dynamic_cast<TreeViewColumn*> (_display.get_column (_trigger_column));
|
|
|
|
trigger_col->set_expand(false);
|
|
|
|
trigger_col->set_sizing(TREE_VIEW_COLUMN_FIXED);
|
|
|
|
trigger_col->set_fixed_width(30);
|
|
|
|
trigger_col->set_alignment(ALIGN_CENTER);
|
|
|
|
trigger_col->add_attribute (trigger_cell->property_visible(), _columns.is_track);
|
|
|
|
|
2011-09-19 18:34:30 -04:00
|
|
|
CellRendererToggle* active_cell = dynamic_cast<CellRendererToggle*> (_display.get_column_cell_renderer (_active_column));
|
|
|
|
|
|
|
|
active_cell->property_activatable() = true;
|
|
|
|
active_cell->property_radio() = false;
|
|
|
|
active_cell->signal_toggled().connect (sigc::mem_fun (*this, &EditorRoutes::active_changed));
|
|
|
|
|
|
|
|
TreeViewColumn* active_col = dynamic_cast<TreeViewColumn*> (_display.get_column (_active_column));
|
|
|
|
active_col->set_expand (false);
|
|
|
|
active_col->set_sizing (TREE_VIEW_COLUMN_FIXED);
|
|
|
|
active_col->set_fixed_width (30);
|
|
|
|
active_col->set_alignment (ALIGN_CENTER);
|
2017-08-07 19:49:05 -04:00
|
|
|
active_col->add_attribute (active_cell->property_visible(), _columns.no_vca);
|
2014-09-07 14:11:28 -04:00
|
|
|
|
2022-01-01 10:52:55 -05:00
|
|
|
|
2014-06-20 21:51:59 -04:00
|
|
|
_model->signal_row_deleted().connect (sigc::mem_fun (*this, &EditorRoutes::row_deleted));
|
2009-12-11 18:29:48 -05:00
|
|
|
_model->signal_rows_reordered().connect (sigc::mem_fun (*this, &EditorRoutes::reordered));
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
_display.signal_button_press_event().connect (sigc::mem_fun (*this, &EditorRoutes::button_press), false);
|
2020-01-14 01:13:04 -05:00
|
|
|
_display.signal_button_release_event().connect (sigc::mem_fun (*this, &EditorRoutes::button_release), false);
|
2010-09-28 21:22:11 -04:00
|
|
|
_scroller.signal_key_press_event().connect (sigc::mem_fun(*this, &EditorRoutes::key_press), false);
|
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
_scroller.signal_focus_in_event().connect (sigc::mem_fun (*this, &EditorRoutes::focus_in), false);
|
|
|
|
_scroller.signal_focus_out_event().connect (sigc::mem_fun (*this, &EditorRoutes::focus_out));
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
_display.signal_enter_notify_event().connect (sigc::mem_fun (*this, &EditorRoutes::enter_notify), false);
|
|
|
|
_display.signal_leave_notify_event().connect (sigc::mem_fun (*this, &EditorRoutes::leave_notify), false);
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
_display.set_enable_search (false);
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2016-05-19 10:29:39 -04:00
|
|
|
Route::PluginSetup.connect_same_thread (*this, boost::bind (&EditorRoutes::plugin_setup, this, _1, _2, _3));
|
2009-07-01 19:20:18 -04:00
|
|
|
}
|
|
|
|
|
2019-03-07 10:40:16 -05:00
|
|
|
EditorRoutes::~EditorRoutes ()
|
|
|
|
{
|
|
|
|
delete _menu;
|
|
|
|
}
|
|
|
|
|
2010-09-28 21:22:11 -04:00
|
|
|
bool
|
|
|
|
EditorRoutes::focus_in (GdkEventFocus*)
|
|
|
|
{
|
2014-09-07 14:11:28 -04:00
|
|
|
Window* win = dynamic_cast<Window*> (_scroller.get_toplevel ());
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
if (win) {
|
|
|
|
old_focus = win->get_focus ();
|
|
|
|
} else {
|
|
|
|
old_focus = 0;
|
|
|
|
}
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
name_editable = 0;
|
2010-09-28 22:01:35 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
/* try to do nothing on focus in (doesn't work, hence selection_count nonsense) */
|
|
|
|
return true;
|
2010-09-28 21:22:11 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
EditorRoutes::focus_out (GdkEventFocus*)
|
|
|
|
{
|
2014-09-07 14:11:28 -04:00
|
|
|
if (old_focus) {
|
|
|
|
old_focus->grab_focus ();
|
|
|
|
old_focus = 0;
|
|
|
|
}
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
return false;
|
2010-09-28 21:22:11 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2010-11-13 00:14:48 -05:00
|
|
|
EditorRoutes::enter_notify (GdkEventCrossing*)
|
2010-09-28 21:22:11 -04:00
|
|
|
{
|
2011-01-01 13:46:20 -05:00
|
|
|
if (name_editable) {
|
|
|
|
return true;
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
Keyboard::magic_widget_grab_focus ();
|
|
|
|
return false;
|
2010-09-28 21:22:11 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2010-11-13 00:14:48 -05:00
|
|
|
EditorRoutes::leave_notify (GdkEventCrossing*)
|
2010-09-28 21:22:11 -04:00
|
|
|
{
|
2014-09-07 14:11:28 -04:00
|
|
|
if (old_focus) {
|
|
|
|
old_focus->grab_focus ();
|
|
|
|
old_focus = 0;
|
|
|
|
}
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
Keyboard::magic_widget_drop_focus ();
|
|
|
|
return false;
|
2010-09-28 21:22:11 -04:00
|
|
|
}
|
|
|
|
|
2009-07-04 09:44:01 -04:00
|
|
|
void
|
2009-12-17 13:24:23 -05:00
|
|
|
EditorRoutes::set_session (Session* s)
|
2009-07-04 09:44:01 -04:00
|
|
|
{
|
2010-07-19 17:47:07 -04:00
|
|
|
SessionHandlePtr::set_session (s);
|
2009-07-04 09:44:01 -04:00
|
|
|
|
|
|
|
initial_display ();
|
2009-11-25 22:02:16 -05:00
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
if (_session) {
|
2010-03-30 11:18:43 -04:00
|
|
|
_session->SoloChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::solo_changed_so_update_mute, this), gui_context());
|
2010-08-15 06:33:41 -04:00
|
|
|
_session->RecordStateChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
|
2015-04-30 12:01:30 -04:00
|
|
|
|
|
|
|
/* TODO: check if these needs to be tied in with DisplaySuspender
|
|
|
|
* Given that the UI is single-threaded and DisplaySuspender is only used
|
|
|
|
* in loops in the UI thread all should be fine.
|
|
|
|
*/
|
|
|
|
_session->BatchUpdateStart.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::suspend_redisplay, this), gui_context());
|
|
|
|
_session->BatchUpdateEnd.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::resume_redisplay, this), gui_context());
|
2009-12-17 13:24:23 -05:00
|
|
|
}
|
2009-07-04 09:44:01 -04:00
|
|
|
}
|
|
|
|
|
2011-07-01 11:48:24 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::on_input_active_changed (std::string const & path_string)
|
|
|
|
{
|
|
|
|
// Get the model row that has been toggled.
|
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
|
|
|
|
|
|
|
|
TimeAxisView* tv = row[_columns.tv];
|
|
|
|
RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
|
|
|
|
|
|
|
|
if (rtv) {
|
|
|
|
boost::shared_ptr<MidiTrack> mt;
|
|
|
|
mt = rtv->midi_track();
|
|
|
|
if (mt) {
|
|
|
|
mt->set_input_active (!mt->input_active());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
void
|
2010-09-14 12:51:02 -04:00
|
|
|
EditorRoutes::on_tv_rec_enable_changed (std::string const & path_string)
|
2009-07-01 19:20:18 -04:00
|
|
|
{
|
|
|
|
// Get the model row that has been toggled.
|
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
|
|
|
|
|
2011-01-01 14:04:11 -05:00
|
|
|
TimeAxisView* tv = row[_columns.tv];
|
2017-08-06 17:49:12 -04:00
|
|
|
StripableTimeAxisView* stv = dynamic_cast<StripableTimeAxisView*> (tv);
|
2016-06-02 08:42:58 -04:00
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
if (!stv || !stv->stripable()) {
|
2016-06-02 08:42:58 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
boost::shared_ptr<AutomationControl> ac = stv->stripable()->rec_enable_control();
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2016-05-27 16:13:10 -04:00
|
|
|
if (ac) {
|
|
|
|
ac->set_value (!ac->get_value(), Controllable::UseGroup);
|
2009-07-01 19:20:18 -04:00
|
|
|
}
|
|
|
|
}
|
2006-07-27 21:08:57 -04:00
|
|
|
|
2016-05-24 15:30:33 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::on_tv_rec_safe_toggled (std::string const & path_string)
|
|
|
|
{
|
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
|
|
|
|
TimeAxisView* tv = row[_columns.tv];
|
2017-08-06 17:49:12 -04:00
|
|
|
StripableTimeAxisView* stv = dynamic_cast<StripableTimeAxisView*> (tv);
|
2016-06-02 08:42:58 -04:00
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
if (!stv || !stv->stripable()) {
|
2016-06-02 08:42:58 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
boost::shared_ptr<AutomationControl> ac (stv->stripable()->rec_safe_control());
|
2016-05-24 15:30:33 -04:00
|
|
|
|
2016-05-27 16:13:10 -04:00
|
|
|
if (ac) {
|
|
|
|
ac->set_value (!ac->get_value(), Controllable::UseGroup);
|
2016-05-24 15:30:33 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-16 08:35:00 -05:00
|
|
|
void
|
2010-09-14 12:51:02 -04:00
|
|
|
EditorRoutes::on_tv_mute_enable_toggled (std::string const & path_string)
|
2009-11-16 08:35:00 -05:00
|
|
|
{
|
|
|
|
// Get the model row that has been toggled.
|
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
|
|
|
|
|
|
|
|
TimeAxisView *tv = row[_columns.tv];
|
2017-08-06 17:49:12 -04:00
|
|
|
StripableTimeAxisView* stv = dynamic_cast<StripableTimeAxisView*> (tv);
|
2016-06-02 08:42:58 -04:00
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
if (!stv || !stv->stripable()) {
|
2016-06-02 08:42:58 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
boost::shared_ptr<AutomationControl> ac (stv->stripable()->mute_control());
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2016-05-27 16:13:10 -04:00
|
|
|
if (ac) {
|
|
|
|
ac->set_value (!ac->get_value(), Controllable::UseGroup);
|
2009-11-16 08:35:00 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-09-14 12:51:02 -04:00
|
|
|
EditorRoutes::on_tv_solo_enable_toggled (std::string const & path_string)
|
2009-11-16 08:35:00 -05:00
|
|
|
{
|
|
|
|
// Get the model row that has been toggled.
|
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
|
|
|
|
|
|
|
|
TimeAxisView *tv = row[_columns.tv];
|
2017-08-06 17:49:12 -04:00
|
|
|
StripableTimeAxisView* stv = dynamic_cast<StripableTimeAxisView*> (tv);
|
2016-06-02 08:42:58 -04:00
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
if (!stv || !stv->stripable()) {
|
2016-06-02 08:42:58 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
boost::shared_ptr<AutomationControl> ac (stv->stripable()->solo_control());
|
2009-11-16 08:35:00 -05:00
|
|
|
|
2016-05-27 16:13:10 -04:00
|
|
|
if (ac) {
|
|
|
|
ac->set_value (!ac->get_value(), Controllable::UseGroup);
|
2009-11-16 08:35:00 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-10 15:51:35 -05:00
|
|
|
void
|
2010-09-14 12:51:02 -04:00
|
|
|
EditorRoutes::on_tv_solo_isolate_toggled (std::string const & path_string)
|
2009-12-10 15:51:35 -05:00
|
|
|
{
|
|
|
|
// Get the model row that has been toggled.
|
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
|
|
|
|
|
|
|
|
TimeAxisView *tv = row[_columns.tv];
|
2017-08-06 17:49:12 -04:00
|
|
|
StripableTimeAxisView* stv = dynamic_cast<StripableTimeAxisView*> (tv);
|
2016-06-02 08:42:58 -04:00
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
if (!stv || !stv->stripable()) {
|
2016-06-02 08:42:58 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
boost::shared_ptr<AutomationControl> ac (stv->stripable()->solo_isolate_control());
|
2009-12-10 15:51:35 -05:00
|
|
|
|
2016-05-27 16:13:10 -04:00
|
|
|
if (ac) {
|
|
|
|
ac->set_value (!ac->get_value(), Controllable::UseGroup);
|
2009-12-10 15:51:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-05 16:08:37 -04:00
|
|
|
void
|
2010-09-14 12:51:02 -04:00
|
|
|
EditorRoutes::on_tv_solo_safe_toggled (std::string const & path_string)
|
2010-04-05 16:08:37 -04:00
|
|
|
{
|
|
|
|
// Get the model row that has been toggled.
|
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
|
|
|
|
|
|
|
|
TimeAxisView *tv = row[_columns.tv];
|
2017-08-06 17:49:12 -04:00
|
|
|
StripableTimeAxisView* stv = dynamic_cast<StripableTimeAxisView*> (tv);
|
2016-06-02 08:42:58 -04:00
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
if (!stv || !stv->stripable()) {
|
2016-06-02 08:42:58 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-06 17:49:12 -04:00
|
|
|
boost::shared_ptr<AutomationControl> ac (stv->stripable()->solo_safe_control());
|
2010-04-05 16:08:37 -04:00
|
|
|
|
2016-05-27 16:13:10 -04:00
|
|
|
if (ac) {
|
|
|
|
ac->set_value (!ac->get_value(), Controllable::UseGroup);
|
2010-04-05 16:08:37 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::build_menu ()
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-07-01 19:20:18 -04:00
|
|
|
using namespace Menu_Helpers;
|
|
|
|
using namespace Gtk;
|
|
|
|
|
|
|
|
_menu = new Menu;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
MenuList& items = _menu->items();
|
|
|
|
_menu->set_name ("ArdourContextMenu");
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
items.push_back (MenuElem (_("Show All"), sigc::mem_fun (*this, &EditorRoutes::show_all_routes)));
|
|
|
|
items.push_back (MenuElem (_("Hide All"), sigc::mem_fun (*this, &EditorRoutes::hide_all_routes)));
|
|
|
|
items.push_back (MenuElem (_("Show All Audio Tracks"), sigc::mem_fun (*this, &EditorRoutes::show_all_audiotracks)));
|
|
|
|
items.push_back (MenuElem (_("Hide All Audio Tracks"), sigc::mem_fun (*this, &EditorRoutes::hide_all_audiotracks)));
|
2010-06-05 20:56:19 -04:00
|
|
|
items.push_back (MenuElem (_("Show All Midi Tracks"), sigc::mem_fun (*this, &EditorRoutes::show_all_miditracks)));
|
|
|
|
items.push_back (MenuElem (_("Hide All Midi Tracks"), sigc::mem_fun (*this, &EditorRoutes::hide_all_miditracks)));
|
2018-10-02 15:25:53 -04:00
|
|
|
items.push_back (MenuElem (_("Show All Busses"), sigc::mem_fun (*this, &EditorRoutes::show_all_audiobus)));
|
|
|
|
items.push_back (MenuElem (_("Hide All Busses"), sigc::mem_fun (*this, &EditorRoutes::hide_all_audiobus)));
|
2015-11-29 14:17:11 -05:00
|
|
|
items.push_back (MenuElem (_("Only Show Tracks with Regions Under Playhead"), sigc::mem_fun (*this, &EditorRoutes::show_tracks_with_regions_at_playhead)));
|
2009-07-01 19:20:18 -04:00
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
void
|
2014-09-07 14:23:22 -04:00
|
|
|
EditorRoutes::redisplay_real ()
|
2009-07-01 19:20:18 -04:00
|
|
|
{
|
|
|
|
TreeModel::Children rows = _model->children();
|
|
|
|
TreeModel::Children::iterator i;
|
|
|
|
uint32_t position;
|
2011-11-17 18:44:16 -05:00
|
|
|
|
|
|
|
/* n will be the count of tracks plus children (updated by TimeAxisView::show_at),
|
2014-09-07 14:23:22 -04:00
|
|
|
* so we will use that to know where to put things.
|
|
|
|
*/
|
2009-07-01 19:20:18 -04:00
|
|
|
int n;
|
|
|
|
|
2012-06-27 18:57:06 -04:00
|
|
|
for (n = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) {
|
2009-07-09 13:58:13 -04:00
|
|
|
TimeAxisView *tv = (*i)[_columns.tv];
|
2009-07-01 19:20:18 -04:00
|
|
|
|
|
|
|
if (tv == 0) {
|
|
|
|
// just a "title" row
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-07-06 20:37:13 -04:00
|
|
|
bool visible = tv->marked_for_display ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2009-07-09 13:58:13 -04:00
|
|
|
/* show or hide the TimeAxisView */
|
2009-07-01 19:20:18 -04:00
|
|
|
if (visible) {
|
|
|
|
position += tv->show_at (position, n, &_editor->edit_controls_vbox);
|
2006-08-24 03:37:17 -04:00
|
|
|
} else {
|
2011-07-06 20:37:13 -04:00
|
|
|
tv->hide ();
|
2006-08-24 03:37:17 -04:00
|
|
|
}
|
2011-07-12 07:02:12 -04:00
|
|
|
|
|
|
|
n++;
|
2009-07-01 19:20:18 -04:00
|
|
|
}
|
2008-09-12 05:01:52 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
/* whenever we go idle, update the track view list to reflect the new order.
|
2014-09-07 14:23:22 -04:00
|
|
|
* we can't do this here, because we could mess up something that is traversing
|
|
|
|
* the track order and has caused a redisplay of the list.
|
|
|
|
*/
|
2009-12-11 18:29:48 -05:00
|
|
|
Glib::signal_idle().connect (sigc::mem_fun (*_editor, &Editor::sync_track_view_list_and_routes));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2014-09-07 14:23:22 -04:00
|
|
|
_editor->reset_controls_layout_height (position);
|
|
|
|
_editor->reset_controls_layout_width ();
|
2013-04-04 00:32:52 -04:00
|
|
|
_editor->_full_canvas_height = position;
|
2007-11-06 07:53:04 -05:00
|
|
|
|
2013-04-04 00:32:52 -04:00
|
|
|
if ((_editor->vertical_adjustment.get_value() + _editor->_visible_canvas_height) > _editor->vertical_adjustment.get_upper()) {
|
2009-10-14 12:10:01 -04:00
|
|
|
/*
|
2014-09-07 14:23:22 -04:00
|
|
|
* We're increasing the size of the canvas while the bottom is visible.
|
|
|
|
* We scroll down to keep in step with the controls layout.
|
|
|
|
*/
|
2013-04-04 00:32:52 -04:00
|
|
|
_editor->vertical_adjustment.set_value (_editor->_full_canvas_height - _editor->_visible_canvas_height);
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2014-09-07 14:23:22 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
EditorRoutes::redisplay ()
|
|
|
|
{
|
2015-04-30 12:01:30 -04:00
|
|
|
if (!_session || _session->deletion_in_progress()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_no_redisplay) {
|
|
|
|
_redisplay_on_resume = true;
|
2014-09-07 14:23:22 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-03-18 22:14:14 -04:00
|
|
|
++_redisplay_active;
|
|
|
|
if (_redisplay_active != 1) {
|
2016-05-02 21:04:46 -04:00
|
|
|
/* recursive re-display can happen if redisplay shows/hides a TrackView
|
|
|
|
* which has children and their display status changes as result.
|
|
|
|
*/
|
2014-09-07 14:23:22 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
redisplay_real ();
|
|
|
|
|
2021-03-18 22:14:14 -04:00
|
|
|
while (_redisplay_active != 1) {
|
|
|
|
_redisplay_active = 1;
|
2014-09-07 14:23:22 -04:00
|
|
|
redisplay_real ();
|
2014-09-06 16:00:42 -04:00
|
|
|
}
|
2021-03-18 22:14:14 -04:00
|
|
|
_redisplay_active = 0;
|
2009-07-01 19:20:18 -04:00
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
void
|
2014-06-20 21:51:59 -04:00
|
|
|
EditorRoutes::row_deleted (Gtk::TreeModel::Path const &)
|
2009-07-01 19:20:18 -04:00
|
|
|
{
|
2016-05-02 21:04:46 -04:00
|
|
|
if (!_session || _session->deletion_in_progress()) {
|
|
|
|
return;
|
|
|
|
}
|
2014-06-20 21:51:59 -04:00
|
|
|
/* this happens as the second step of a DnD within the treeview, and
|
2014-09-07 14:11:28 -04:00
|
|
|
* when a route is actually removed. we don't differentiate between
|
|
|
|
* the two cases.
|
|
|
|
*
|
2016-05-16 07:30:28 -04:00
|
|
|
* note that the sync_presentation_info_from_treeview() step may not
|
|
|
|
* actually change any presentation info (e.g. the last track may be
|
|
|
|
* removed, so all other tracks keep the same presentation info), which
|
|
|
|
* means that no redisplay would happen. so we have to force a
|
|
|
|
* redisplay.
|
2014-09-07 14:11:28 -04:00
|
|
|
*/
|
2014-06-20 21:51:59 -04:00
|
|
|
|
2012-06-27 18:57:06 -04:00
|
|
|
DEBUG_TRACE (DEBUG::OrderKeys, "editor routes treeview row deleted\n");
|
2014-06-20 21:51:59 -04:00
|
|
|
|
2014-06-28 20:52:56 -04:00
|
|
|
DisplaySuspender ds;
|
2016-05-16 07:30:28 -04:00
|
|
|
sync_presentation_info_from_treeview ();
|
2012-06-27 18:57:06 -04:00
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2012-06-27 18:57:06 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::reordered (TreeModel::Path const &, TreeModel::iterator const &, int* /*what*/)
|
|
|
|
{
|
2016-05-16 07:30:28 -04:00
|
|
|
/* reordering implies that RID's will change, so
|
|
|
|
sync_presentation_info_from_treeview() will cause a redisplay.
|
2014-06-20 21:51:59 -04:00
|
|
|
*/
|
|
|
|
|
2012-06-27 18:57:06 -04:00
|
|
|
DEBUG_TRACE (DEBUG::OrderKeys, "editor routes treeview reordered\n");
|
2016-05-16 07:30:28 -04:00
|
|
|
sync_presentation_info_from_treeview ();
|
2009-07-01 19:20:18 -04:00
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
void
|
2010-09-14 12:51:02 -04:00
|
|
|
EditorRoutes::visible_changed (std::string const & path)
|
2009-07-01 19:20:18 -04:00
|
|
|
{
|
2009-12-22 15:21:43 -05:00
|
|
|
if (_session && _session->deletion_in_progress()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-06-28 20:52:56 -04:00
|
|
|
DisplaySuspender ds;
|
2009-11-30 14:48:50 -05:00
|
|
|
TreeIter iter;
|
|
|
|
|
|
|
|
if ((iter = _model->get_iter (path))) {
|
|
|
|
TimeAxisView* tv = (*iter)[_columns.tv];
|
|
|
|
if (tv) {
|
|
|
|
bool visible = (*iter)[_columns.visible];
|
2011-07-06 20:37:13 -04:00
|
|
|
|
|
|
|
if (tv->set_marked_for_display (!visible)) {
|
|
|
|
update_visibility ();
|
|
|
|
}
|
2009-11-30 14:48:50 -05:00
|
|
|
}
|
|
|
|
}
|
2009-07-01 19:20:18 -04:00
|
|
|
}
|
|
|
|
|
2022-01-01 10:52:55 -05:00
|
|
|
void
|
|
|
|
EditorRoutes::trigger_changed (std::string const & path)
|
|
|
|
{
|
|
|
|
if (_session && _session->deletion_in_progress()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (path);
|
|
|
|
assert (row[_columns.is_track]);
|
|
|
|
boost::shared_ptr<Stripable> stripable = row[_columns.stripable];
|
|
|
|
if (stripable) {
|
|
|
|
bool const tt = row[_columns.trigger];
|
|
|
|
stripable->presentation_info ().set_trigger_track (!tt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-19 18:34:30 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::active_changed (std::string const & path)
|
|
|
|
{
|
|
|
|
if (_session && _session->deletion_in_progress ()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (path);
|
2016-05-21 12:44:41 -04:00
|
|
|
boost::shared_ptr<Stripable> stripable = row[_columns.stripable];
|
|
|
|
boost::shared_ptr<Route> route = boost::dynamic_pointer_cast<Route> (stripable);
|
|
|
|
if (route) {
|
|
|
|
bool const active = row[_columns.active];
|
|
|
|
route->set_active (!active, this);
|
|
|
|
}
|
2011-09-19 18:34:30 -04:00
|
|
|
}
|
|
|
|
|
2016-05-21 16:36:08 -04:00
|
|
|
void
|
2016-06-03 15:15:30 -04:00
|
|
|
EditorRoutes::time_axis_views_added (list<TimeAxisView*> tavs)
|
2009-07-01 19:20:18 -04:00
|
|
|
{
|
2012-12-04 09:32:28 -05:00
|
|
|
PBD::Unwinder<bool> at (_adding_routes, true);
|
2015-03-14 11:57:39 -04:00
|
|
|
bool from_scratch = (_model->children().size() == 0);
|
2013-10-23 10:27:13 -04:00
|
|
|
Gtk::TreeModel::Children::iterator insert_iter = _model->children().end();
|
|
|
|
|
|
|
|
for (Gtk::TreeModel::Children::iterator it = _model->children().begin(); it != _model->children().end(); ++it) {
|
2016-06-03 15:15:30 -04:00
|
|
|
|
2016-05-21 12:44:41 -04:00
|
|
|
boost::shared_ptr<Stripable> r = (*it)[_columns.stripable];
|
2013-10-23 10:27:13 -04:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
if (r->presentation_info().order() == (tavs.front()->stripable()->presentation_info().order() + tavs.size())) {
|
2013-10-23 10:27:13 -04:00
|
|
|
insert_iter = it;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-05 07:31:49 -04:00
|
|
|
{
|
|
|
|
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
|
|
|
|
_display.set_model (Glib::RefPtr<ListStore>());
|
|
|
|
}
|
2012-12-04 09:32:28 -05:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
for (list<TimeAxisView*>::iterator x = tavs.begin(); x != tavs.end(); ++x) {
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
VCATimeAxisView* vtav = dynamic_cast<VCATimeAxisView*> (*x);
|
|
|
|
RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*x);
|
2011-07-01 11:48:24 -04:00
|
|
|
|
2013-10-23 10:27:13 -04:00
|
|
|
TreeModel::Row row = *(_model->insert (insert_iter));
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
boost::shared_ptr<Stripable> stripable;
|
|
|
|
boost::shared_ptr<MidiTrack> midi_trk;
|
2016-05-21 16:36:08 -04:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
if (vtav) {
|
2011-07-01 11:48:24 -04:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
stripable = vtav->vca();
|
|
|
|
|
|
|
|
row[_columns.is_track] = false;
|
2011-07-01 11:48:24 -04:00
|
|
|
row[_columns.is_input_active] = false;
|
|
|
|
row[_columns.is_midi] = false;
|
2017-08-07 19:49:05 -04:00
|
|
|
row[_columns.no_vca] = false;
|
2016-06-03 15:15:30 -04:00
|
|
|
|
|
|
|
} else if (rtav) {
|
|
|
|
|
|
|
|
stripable = rtav->route ();
|
|
|
|
midi_trk= boost::dynamic_pointer_cast<MidiTrack> (stripable);
|
|
|
|
|
|
|
|
row[_columns.is_track] = (boost::dynamic_pointer_cast<Track> (stripable) != 0);
|
2017-08-07 19:49:05 -04:00
|
|
|
row[_columns.no_vca] = true;
|
2016-06-03 15:15:30 -04:00
|
|
|
|
|
|
|
if (midi_trk) {
|
|
|
|
row[_columns.is_input_active] = midi_trk->input_active ();
|
|
|
|
row[_columns.is_midi] = true;
|
|
|
|
} else {
|
|
|
|
row[_columns.is_input_active] = false;
|
|
|
|
row[_columns.is_midi] = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!stripable) {
|
|
|
|
continue;
|
2011-07-01 11:48:24 -04:00
|
|
|
}
|
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
row[_columns.text] = stripable->name();
|
|
|
|
row[_columns.visible] = (*x)->marked_for_display();
|
2022-01-01 10:52:55 -05:00
|
|
|
row[_columns.trigger] = stripable->presentation_info ().trigger_track () && row[_columns.is_track];
|
2016-06-03 15:15:30 -04:00
|
|
|
row[_columns.active] = true;
|
|
|
|
row[_columns.tv] = *x;
|
|
|
|
row[_columns.stripable] = stripable;
|
|
|
|
row[_columns.mute_state] = RouteUI::mute_active_state (_session, stripable);
|
|
|
|
row[_columns.solo_state] = RouteUI::solo_active_state (stripable);
|
2017-08-06 17:49:12 -04:00
|
|
|
row[_columns.solo_visible] = !stripable->is_master ();
|
2017-08-07 19:49:05 -04:00
|
|
|
row[_columns.solo_lock_iso_visible] = row[_columns.solo_visible] && row[_columns.no_vca];
|
2016-06-03 15:15:30 -04:00
|
|
|
row[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (stripable);
|
|
|
|
row[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (stripable);
|
2010-02-02 20:23:38 -05:00
|
|
|
row[_columns.name_editable] = true;
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
boost::weak_ptr<Stripable> ws (stripable);
|
2009-12-17 13:24:23 -05:00
|
|
|
|
2016-06-08 11:03:07 -04:00
|
|
|
/* for now, we need both of these. PropertyChanged covers on
|
|
|
|
* pre-defined, "global" things of interest to a
|
|
|
|
* UI. gui_changed covers arbitrary, un-enumerated, un-typed
|
|
|
|
* changes that may only be of interest to a particular
|
|
|
|
* UI (e.g. track-height is not of any relevant to OSC)
|
|
|
|
*/
|
|
|
|
|
|
|
|
stripable->gui_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context());
|
2016-06-03 15:15:30 -04:00
|
|
|
stripable->PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, ws), gui_context());
|
2016-06-10 13:54:29 -04:00
|
|
|
stripable->presentation_info().PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, ws), gui_context());
|
2009-06-10 21:05:01 -04:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
if (boost::dynamic_pointer_cast<Track> (stripable)) {
|
|
|
|
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (stripable);
|
2016-04-08 16:49:47 -04:00
|
|
|
t->rec_enable_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
|
|
|
|
t->rec_safe_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
|
2009-07-01 19:20:18 -04:00
|
|
|
}
|
2009-11-25 22:02:16 -05:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
if (midi_trk) {
|
|
|
|
midi_trk->StepEditStatusChange.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
|
|
|
|
midi_trk->InputActiveChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_input_active_display, this), gui_context());
|
2014-09-07 14:11:28 -04:00
|
|
|
}
|
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
boost::shared_ptr<AutomationControl> ac;
|
2012-12-04 09:32:28 -05:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
if ((ac = stripable->mute_control()) != 0) {
|
|
|
|
ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_mute_display, this), gui_context());
|
|
|
|
}
|
|
|
|
if ((ac = stripable->solo_control()) != 0) {
|
|
|
|
ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this), gui_context());
|
|
|
|
}
|
|
|
|
if ((ac = stripable->solo_isolate_control()) != 0) {
|
|
|
|
ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_isolate_display, this), gui_context());
|
|
|
|
}
|
|
|
|
if ((ac = stripable->solo_safe_control()) != 0) {
|
|
|
|
ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_safe_display, this), gui_context());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rtav) {
|
|
|
|
rtav->route()->active_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_active_display, this), gui_context ());
|
|
|
|
}
|
2009-07-01 19:20:18 -04:00
|
|
|
}
|
|
|
|
|
2009-11-24 18:59:15 -05:00
|
|
|
update_rec_display ();
|
2010-01-14 19:06:11 -05:00
|
|
|
update_mute_display ();
|
2016-01-21 11:03:14 -05:00
|
|
|
update_solo_display ();
|
2010-01-14 19:06:11 -05:00
|
|
|
update_solo_isolate_display ();
|
2010-04-05 16:08:37 -04:00
|
|
|
update_solo_safe_display ();
|
2011-07-01 11:48:24 -04:00
|
|
|
update_input_active_display ();
|
2011-09-19 18:34:30 -04:00
|
|
|
update_active_display ();
|
2012-12-04 09:32:28 -05:00
|
|
|
|
2017-05-05 07:31:49 -04:00
|
|
|
{
|
|
|
|
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
|
|
|
|
_display.set_model (_model);
|
|
|
|
}
|
2012-06-27 18:57:06 -04:00
|
|
|
|
|
|
|
/* now update route order keys from the treeview/track display order */
|
2016-06-06 12:52:48 -04:00
|
|
|
|
2015-03-14 11:57:39 -04:00
|
|
|
if (!from_scratch) {
|
2016-05-16 07:30:28 -04:00
|
|
|
sync_presentation_info_from_treeview ();
|
2015-03-14 11:57:39 -04:00
|
|
|
}
|
2016-06-06 14:44:58 -04:00
|
|
|
|
|
|
|
redisplay ();
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-12-22 15:21:43 -05:00
|
|
|
EditorRoutes::handle_gui_changes (string const & what, void*)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2012-12-04 09:32:28 -05:00
|
|
|
if (_adding_routes) {
|
|
|
|
return;
|
|
|
|
}
|
2008-12-12 09:43:24 -05:00
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
if (what == "track_height") {
|
2009-10-14 12:10:01 -04:00
|
|
|
/* Optional :make tracks change height while it happens, instead
|
2008-09-10 11:03:30 -04:00
|
|
|
of on first-idle
|
|
|
|
*/
|
2009-07-01 19:20:18 -04:00
|
|
|
redisplay ();
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
if (what == "visible_tracks") {
|
2009-07-01 19:20:18 -04:00
|
|
|
redisplay ();
|
2008-09-10 11:03:30 -04:00
|
|
|
}
|
|
|
|
}
|
2005-10-26 14:12:00 -04:00
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
void
|
2009-07-09 13:58:13 -04:00
|
|
|
EditorRoutes::route_removed (TimeAxisView *tv)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-12-11 18:29:48 -05:00
|
|
|
ENSURE_GUI_THREAD (*this, &EditorRoutes::route_removed, tv)
|
2005-10-26 14:12:00 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
2005-10-26 14:12:00 -04:00
|
|
|
TreeModel::Children::iterator ri;
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2017-05-08 05:31:59 -04:00
|
|
|
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
|
|
|
|
|
2005-10-26 14:12:00 -04:00
|
|
|
for (ri = rows.begin(); ri != rows.end(); ++ri) {
|
2009-07-09 13:58:13 -04:00
|
|
|
if ((*ri)[_columns.tv] == tv) {
|
2014-09-06 07:10:47 -04:00
|
|
|
PBD::Unwinder<bool> uw (_route_deletion_in_progress, true);
|
2009-07-01 19:20:18 -04:00
|
|
|
_model->erase (ri);
|
2005-09-25 14:42:24 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2016-05-21 16:36:08 -04:00
|
|
|
EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr<Stripable> s)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2022-01-01 10:52:55 -05:00
|
|
|
if (_adding_routes) {
|
2016-06-10 13:53:48 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-01-01 10:52:55 -05:00
|
|
|
PropertyChange interests;
|
|
|
|
interests.add (ARDOUR::Properties::name);
|
|
|
|
interests.add (ARDOUR::Properties::hidden);
|
|
|
|
interests.add (ARDOUR::Properties::trigger_track);
|
|
|
|
|
|
|
|
if (!what_changed.contains (interests)) {
|
2010-02-19 13:09:08 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-10 13:53:48 -04:00
|
|
|
boost::shared_ptr<Stripable> stripable = s.lock ();
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2016-06-10 13:53:48 -04:00
|
|
|
if (!stripable) {
|
|
|
|
return;
|
|
|
|
}
|
2010-02-19 13:09:08 -05:00
|
|
|
|
2016-06-10 13:53:48 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
|
|
|
TreeModel::Children::iterator i;
|
|
|
|
|
|
|
|
for (i = rows.begin(); i != rows.end(); ++i) {
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2016-06-10 13:53:48 -04:00
|
|
|
boost::shared_ptr<Stripable> ss = (*i)[_columns.stripable];
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2016-06-10 13:53:48 -04:00
|
|
|
if (ss == stripable) {
|
|
|
|
|
|
|
|
if (what_changed.contains (ARDOUR::Properties::name)) {
|
2016-06-08 11:03:07 -04:00
|
|
|
(*i)[_columns.text] = stripable->name();
|
|
|
|
break;
|
|
|
|
}
|
2016-06-10 13:53:48 -04:00
|
|
|
|
|
|
|
if (what_changed.contains (ARDOUR::Properties::hidden)) {
|
|
|
|
(*i)[_columns.visible] = !stripable->presentation_info().hidden();
|
|
|
|
redisplay ();
|
2022-01-01 10:52:55 -05:00
|
|
|
}
|
2016-06-10 15:00:43 -04:00
|
|
|
|
2022-01-01 10:52:55 -05:00
|
|
|
if (what_changed.contains (ARDOUR::Properties::trigger_track)) {
|
|
|
|
(*i)[_columns.trigger] = stripable->presentation_info ().trigger_track () && (*i)[_columns.is_track];
|
2016-06-10 13:53:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2008-09-10 11:03:30 -04:00
|
|
|
}
|
|
|
|
|
2011-09-19 18:34:30 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::update_active_display ()
|
|
|
|
{
|
2021-03-18 22:14:14 -04:00
|
|
|
if (!_idle_update_queued) {
|
|
|
|
_idle_update_queued = true;
|
2014-09-06 07:10:47 -04:00
|
|
|
Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
|
2011-09-19 18:34:30 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::update_visibility ()
|
2008-09-10 11:03:30 -04:00
|
|
|
{
|
2009-07-01 19:20:18 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
2008-09-10 11:03:30 -04:00
|
|
|
TreeModel::Children::iterator i;
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2014-10-22 21:32:14 -04:00
|
|
|
DisplaySuspender ds;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
for (i = rows.begin(); i != rows.end(); ++i) {
|
2009-07-09 13:58:13 -04:00
|
|
|
TimeAxisView *tv = (*i)[_columns.tv];
|
2009-07-01 19:20:18 -04:00
|
|
|
(*i)[_columns.visible] = tv->marked_for_display ();
|
2008-09-10 11:03:30 -04:00
|
|
|
}
|
|
|
|
|
2017-06-17 12:26:59 -04:00
|
|
|
/* force route order keys catch up with visibility changes */
|
2012-06-27 18:57:06 -04:00
|
|
|
|
2016-05-16 07:30:28 -04:00
|
|
|
sync_presentation_info_from_treeview ();
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-07-09 13:58:13 -04:00
|
|
|
EditorRoutes::hide_track_in_display (TimeAxisView& tv)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-07-01 19:20:18 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
2005-10-26 14:12:00 -04:00
|
|
|
TreeModel::Children::iterator i;
|
|
|
|
|
|
|
|
for (i = rows.begin(); i != rows.end(); ++i) {
|
2009-10-14 12:10:01 -04:00
|
|
|
if ((*i)[_columns.tv] == &tv) {
|
2011-07-07 14:58:02 -04:00
|
|
|
tv.set_marked_for_display (false);
|
2009-07-01 19:20:18 -04:00
|
|
|
(*i)[_columns.visible] = false;
|
2011-07-07 14:58:02 -04:00
|
|
|
redisplay ();
|
2006-01-09 23:25:47 -05:00
|
|
|
break;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-07-09 13:58:13 -04:00
|
|
|
EditorRoutes::show_track_in_display (TimeAxisView& tv)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-07-01 19:20:18 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
2005-10-26 14:12:00 -04:00
|
|
|
TreeModel::Children::iterator i;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-07-07 14:58:02 -04:00
|
|
|
|
2005-10-26 14:12:00 -04:00
|
|
|
for (i = rows.begin(); i != rows.end(); ++i) {
|
2009-10-14 12:10:01 -04:00
|
|
|
if ((*i)[_columns.tv] == &tv) {
|
2011-07-07 14:58:02 -04:00
|
|
|
tv.set_marked_for_display (true);
|
2009-07-01 19:20:18 -04:00
|
|
|
(*i)[_columns.visible] = true;
|
2011-07-07 14:58:02 -04:00
|
|
|
redisplay ();
|
2006-01-09 23:25:47 -05:00
|
|
|
break;
|
2005-10-26 14:12:00 -04:00
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-19 18:35:43 -04:00
|
|
|
void
|
2016-05-16 07:30:28 -04:00
|
|
|
EditorRoutes::sync_presentation_info_from_treeview ()
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2012-06-27 18:57:06 -04:00
|
|
|
if (_ignore_reorder || !_session || _session->deletion_in_progress()) {
|
|
|
|
return;
|
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
2014-09-07 14:11:28 -04:00
|
|
|
|
2012-06-27 18:57:06 -04:00
|
|
|
if (rows.empty()) {
|
2007-10-11 18:07:47 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-17 09:36:28 -04:00
|
|
|
DEBUG_TRACE (DEBUG::OrderKeys, "editor sync presentation info from treeview\n");
|
2012-06-27 18:57:06 -04:00
|
|
|
|
2016-05-16 07:30:28 -04:00
|
|
|
bool change = false;
|
|
|
|
PresentationInfo::order_t order = 0;
|
2016-11-04 11:39:41 -04:00
|
|
|
|
2017-01-26 13:20:40 -05:00
|
|
|
PresentationInfo::ChangeSuspender cs;
|
|
|
|
|
2017-06-17 12:26:59 -04:00
|
|
|
for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri) {
|
2016-05-21 12:44:41 -04:00
|
|
|
boost::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
|
2012-07-19 18:35:43 -04:00
|
|
|
bool visible = (*ri)[_columns.visible];
|
|
|
|
|
2017-06-16 17:45:16 -04:00
|
|
|
#ifndef NDEBUG // these should not exist in the treeview
|
2017-06-17 12:26:59 -04:00
|
|
|
assert (stripable);
|
2016-06-03 15:15:30 -04:00
|
|
|
if (stripable->is_monitor() || stripable->is_auditioner()) {
|
2017-06-16 17:45:16 -04:00
|
|
|
assert (0);
|
2016-05-16 07:30:28 -04:00
|
|
|
continue;
|
2008-12-08 13:16:12 -05:00
|
|
|
}
|
2017-06-16 17:45:16 -04:00
|
|
|
#endif
|
2012-07-19 18:35:43 -04:00
|
|
|
|
2016-06-05 16:09:47 -04:00
|
|
|
stripable->presentation_info().set_hidden (!visible);
|
2016-06-03 15:15:30 -04:00
|
|
|
|
|
|
|
if (order != stripable->presentation_info().order()) {
|
2017-01-26 13:20:40 -05:00
|
|
|
stripable->set_presentation_order (order);
|
2016-05-16 07:30:28 -04:00
|
|
|
change = true;
|
2012-07-19 18:35:43 -04:00
|
|
|
}
|
|
|
|
++order;
|
2012-06-27 18:57:06 -04:00
|
|
|
}
|
2014-09-07 14:11:28 -04:00
|
|
|
|
2017-06-16 17:45:16 -04:00
|
|
|
change |= _session->ensure_stripable_sort_order ();
|
|
|
|
|
|
|
|
if (change) {
|
|
|
|
_session->set_dirty();
|
2017-01-06 12:40:21 -05:00
|
|
|
}
|
2012-06-27 18:57:06 -04:00
|
|
|
}
|
|
|
|
|
2017-01-27 13:18:33 -05:00
|
|
|
void
|
|
|
|
EditorRoutes::sync_treeview_from_presentation_info (PropertyChange const & what_changed)
|
2012-06-27 18:57:06 -04:00
|
|
|
{
|
2014-09-07 14:11:28 -04:00
|
|
|
/* Some route order key(s) have been changed, make sure that
|
2012-06-28 18:27:37 -04:00
|
|
|
we update out tree/list model and GUI to reflect the change.
|
|
|
|
*/
|
|
|
|
|
2013-10-20 09:19:43 -04:00
|
|
|
if (_ignore_reorder || !_session || _session->deletion_in_progress()) {
|
2012-06-27 18:57:06 -04:00
|
|
|
return;
|
|
|
|
}
|
2011-05-11 10:15:32 -04:00
|
|
|
|
2016-05-16 07:30:28 -04:00
|
|
|
DEBUG_TRACE (DEBUG::OrderKeys, "editor sync model from presentation info.\n");
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2017-01-27 13:18:33 -05:00
|
|
|
PropertyChange hidden_or_order;
|
|
|
|
hidden_or_order.add (Properties::hidden);
|
|
|
|
hidden_or_order.add (Properties::order);
|
|
|
|
|
2012-06-27 18:57:06 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
|
|
|
|
2017-06-17 12:26:35 -04:00
|
|
|
bool changed = false;
|
2012-06-27 18:57:06 -04:00
|
|
|
|
2017-06-17 12:26:35 -04:00
|
|
|
if (what_changed.contains (hidden_or_order)) {
|
2017-01-27 13:18:33 -05:00
|
|
|
vector<int> neworder;
|
|
|
|
uint32_t old_order = 0;
|
2012-06-27 18:57:06 -04:00
|
|
|
|
2017-01-27 13:18:33 -05:00
|
|
|
if (rows.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-06-16 17:45:16 -04:00
|
|
|
TreeOrderKeys sorted;
|
2017-01-27 13:18:33 -05:00
|
|
|
for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++old_order) {
|
|
|
|
boost::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
|
|
|
|
/* use global order */
|
2017-06-16 17:45:16 -04:00
|
|
|
sorted.push_back (TreeOrderKey (old_order, stripable));
|
2017-01-27 13:18:33 -05:00
|
|
|
}
|
|
|
|
|
2017-06-16 17:45:16 -04:00
|
|
|
TreeOrderKeySorter cmp;
|
2012-10-26 20:15:45 -04:00
|
|
|
|
2017-01-27 13:18:33 -05:00
|
|
|
sort (sorted.begin(), sorted.end(), cmp);
|
|
|
|
neworder.assign (sorted.size(), 0);
|
2012-06-28 18:27:37 -04:00
|
|
|
|
2017-01-27 13:18:33 -05:00
|
|
|
uint32_t n = 0;
|
2012-10-26 20:15:45 -04:00
|
|
|
|
2017-06-16 17:45:16 -04:00
|
|
|
for (TreeOrderKeys::iterator sr = sorted.begin(); sr != sorted.end(); ++sr, ++n) {
|
2014-09-07 14:11:28 -04:00
|
|
|
|
2017-01-27 13:18:33 -05:00
|
|
|
neworder[n] = sr->old_display_order;
|
2012-10-26 20:15:45 -04:00
|
|
|
|
2017-01-27 13:18:33 -05:00
|
|
|
if (sr->old_display_order != n) {
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
2012-10-26 20:15:45 -04:00
|
|
|
|
2017-01-27 13:18:33 -05:00
|
|
|
if (changed) {
|
|
|
|
Unwinder<bool> uw (_ignore_reorder, true);
|
|
|
|
/* prevent traverse_cells: assertion 'row_path != NULL'
|
|
|
|
* in case of DnD re-order: row-removed + row-inserted.
|
|
|
|
*
|
|
|
|
* The rows (stripables) are not actually removed from the model,
|
|
|
|
* but only from the display in the DnDTreeView.
|
|
|
|
* ->reorder() will fail to find the row_path.
|
2017-02-13 16:09:55 -05:00
|
|
|
* (re-order drag -> remove row -> sync PI from TV -> notify -> sync TV from PI -> crash)
|
2017-01-27 13:18:33 -05:00
|
|
|
*/
|
2017-02-13 16:09:55 -05:00
|
|
|
Unwinder<bool> uw2 (_ignore_selection_change, true);
|
|
|
|
|
2017-01-27 13:18:33 -05:00
|
|
|
_display.unset_model();
|
|
|
|
_model->reorder (neworder);
|
|
|
|
_display.set_model (_model);
|
2012-06-28 18:27:37 -04:00
|
|
|
}
|
2012-06-27 18:57:06 -04:00
|
|
|
}
|
|
|
|
|
2017-06-17 12:26:35 -04:00
|
|
|
if (changed || what_changed.contains (Properties::selected)) {
|
2017-05-05 07:31:49 -04:00
|
|
|
/* by the time this is invoked, the GUI Selection model has
|
|
|
|
* already updated itself.
|
|
|
|
*/
|
2017-01-27 13:18:33 -05:00
|
|
|
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
|
2017-05-05 07:31:49 -04:00
|
|
|
|
2017-06-17 12:26:35 -04:00
|
|
|
/* set the treeview model selection state */
|
2017-01-27 13:18:33 -05:00
|
|
|
for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri) {
|
|
|
|
boost::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
|
2017-05-05 07:31:49 -04:00
|
|
|
if (stripable && stripable->is_selected()) {
|
2017-01-27 13:18:33 -05:00
|
|
|
_display.get_selection()->select (*ri);
|
|
|
|
} else {
|
|
|
|
_display.get_selection()->unselect (*ri);
|
|
|
|
}
|
|
|
|
}
|
2012-06-27 18:57:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
redisplay ();
|
|
|
|
}
|
2009-04-15 14:04:23 -04:00
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
void
|
2009-07-21 11:55:17 -04:00
|
|
|
EditorRoutes::hide_all_tracks (bool /*with_select*/)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-07-01 19:20:18 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
2005-10-26 14:12:00 -04:00
|
|
|
TreeModel::Children::iterator i;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2014-06-28 20:52:56 -04:00
|
|
|
DisplaySuspender ds;
|
2006-01-09 23:25:47 -05:00
|
|
|
|
2005-10-26 14:12:00 -04:00
|
|
|
for (i = rows.begin(); i != rows.end(); ++i) {
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2005-10-26 14:12:00 -04:00
|
|
|
TreeModel::Row row = (*i);
|
2009-07-09 13:58:13 -04:00
|
|
|
TimeAxisView *tv = row[_columns.tv];
|
2006-01-09 23:25:47 -05:00
|
|
|
|
|
|
|
if (tv == 0) {
|
|
|
|
continue;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-07-01 19:20:18 -04:00
|
|
|
row[_columns.visible] = false;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::set_all_tracks_visibility (bool yn)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-07-01 19:20:18 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
2005-10-26 14:12:00 -04:00
|
|
|
TreeModel::Children::iterator i;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2014-06-28 20:52:56 -04:00
|
|
|
DisplaySuspender ds;
|
2006-01-09 23:25:47 -05:00
|
|
|
|
2005-10-26 14:12:00 -04:00
|
|
|
for (i = rows.begin(); i != rows.end(); ++i) {
|
2006-01-09 23:25:47 -05:00
|
|
|
|
|
|
|
TreeModel::Row row = (*i);
|
2009-07-09 13:58:13 -04:00
|
|
|
TimeAxisView* tv = row[_columns.tv];
|
2006-01-09 23:25:47 -05:00
|
|
|
|
|
|
|
if (tv == 0) {
|
|
|
|
continue;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2013-04-01 19:56:33 -04:00
|
|
|
tv->set_marked_for_display (yn);
|
2009-07-01 19:20:18 -04:00
|
|
|
(*i)[_columns.visible] = yn;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2006-01-09 23:25:47 -05:00
|
|
|
|
2012-06-27 18:57:06 -04:00
|
|
|
/* force route order keys catch up with visibility changes
|
|
|
|
*/
|
|
|
|
|
2016-05-16 07:30:28 -04:00
|
|
|
sync_presentation_info_from_treeview ();
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-06-05 20:56:19 -04:00
|
|
|
EditorRoutes::set_all_audio_midi_visibility (int tracks, bool yn)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-07-01 19:20:18 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
2005-10-26 14:12:00 -04:00
|
|
|
TreeModel::Children::iterator i;
|
|
|
|
|
2014-06-28 20:52:56 -04:00
|
|
|
DisplaySuspender ds;
|
2006-01-09 23:25:47 -05:00
|
|
|
|
2005-10-26 14:12:00 -04:00
|
|
|
for (i = rows.begin(); i != rows.end(); ++i) {
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2006-01-09 23:25:47 -05:00
|
|
|
TreeModel::Row row = (*i);
|
2009-07-09 13:58:13 -04:00
|
|
|
TimeAxisView* tv = row[_columns.tv];
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-07-09 13:58:13 -04:00
|
|
|
AudioTimeAxisView* atv;
|
2010-06-05 20:56:19 -04:00
|
|
|
MidiTimeAxisView* mtv;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2006-01-09 23:25:47 -05:00
|
|
|
if (tv == 0) {
|
|
|
|
continue;
|
|
|
|
}
|
2005-10-26 14:12:00 -04:00
|
|
|
|
2009-07-09 13:58:13 -04:00
|
|
|
if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) != 0) {
|
2006-01-09 23:25:47 -05:00
|
|
|
switch (tracks) {
|
|
|
|
case 0:
|
2015-09-28 16:14:04 -04:00
|
|
|
atv->set_marked_for_display (yn);
|
2009-07-01 19:20:18 -04:00
|
|
|
(*i)[_columns.visible] = yn;
|
2006-01-09 23:25:47 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
if (atv->is_audio_track()) {
|
2015-09-28 16:14:04 -04:00
|
|
|
atv->set_marked_for_display (yn);
|
2009-07-01 19:20:18 -04:00
|
|
|
(*i)[_columns.visible] = yn;
|
2006-01-09 23:25:47 -05:00
|
|
|
}
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2006-01-09 23:25:47 -05:00
|
|
|
case 2:
|
|
|
|
if (!atv->is_audio_track()) {
|
2015-09-28 16:14:04 -04:00
|
|
|
atv->set_marked_for_display (yn);
|
2009-07-01 19:20:18 -04:00
|
|
|
(*i)[_columns.visible] = yn;
|
2006-01-09 23:25:47 -05:00
|
|
|
}
|
|
|
|
break;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
}
|
2010-06-05 20:56:19 -04:00
|
|
|
else if ((mtv = dynamic_cast<MidiTimeAxisView*>(tv)) != 0) {
|
|
|
|
switch (tracks) {
|
|
|
|
case 0:
|
2015-09-28 16:14:04 -04:00
|
|
|
mtv->set_marked_for_display (yn);
|
2010-06-05 20:56:19 -04:00
|
|
|
(*i)[_columns.visible] = yn;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
if (mtv->is_midi_track()) {
|
2015-09-28 16:14:04 -04:00
|
|
|
mtv->set_marked_for_display (yn);
|
2010-06-05 20:56:19 -04:00
|
|
|
(*i)[_columns.visible] = yn;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2012-06-27 18:57:06 -04:00
|
|
|
/* force route order keys catch up with visibility changes
|
|
|
|
*/
|
|
|
|
|
2016-05-16 07:30:28 -04:00
|
|
|
sync_presentation_info_from_treeview ();
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2005-10-26 14:12:00 -04:00
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::hide_all_routes ()
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2006-01-09 23:25:47 -05:00
|
|
|
set_all_tracks_visibility (false);
|
|
|
|
}
|
2005-10-26 14:12:00 -04:00
|
|
|
|
2006-01-09 23:25:47 -05:00
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::show_all_routes ()
|
2006-01-09 23:25:47 -05:00
|
|
|
{
|
|
|
|
set_all_tracks_visibility (true);
|
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2010-06-05 20:56:19 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::show_all_audiotracks()
|
|
|
|
{
|
|
|
|
set_all_audio_midi_visibility (1, true);
|
|
|
|
}
|
|
|
|
void
|
|
|
|
EditorRoutes::hide_all_audiotracks ()
|
|
|
|
{
|
|
|
|
set_all_audio_midi_visibility (1, false);
|
|
|
|
}
|
|
|
|
|
2006-01-09 23:25:47 -05:00
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::show_all_audiobus ()
|
2006-01-09 23:25:47 -05:00
|
|
|
{
|
2010-06-05 20:56:19 -04:00
|
|
|
set_all_audio_midi_visibility (2, true);
|
2006-01-09 23:25:47 -05:00
|
|
|
}
|
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::hide_all_audiobus ()
|
2006-01-09 23:25:47 -05:00
|
|
|
{
|
2010-06-05 20:56:19 -04:00
|
|
|
set_all_audio_midi_visibility (2, false);
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-06-05 20:56:19 -04:00
|
|
|
EditorRoutes::show_all_miditracks()
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2010-06-05 20:56:19 -04:00
|
|
|
set_all_audio_midi_visibility (3, true);
|
2006-01-09 23:25:47 -05:00
|
|
|
}
|
|
|
|
void
|
2010-06-05 20:56:19 -04:00
|
|
|
EditorRoutes::hide_all_miditracks ()
|
2006-01-09 23:25:47 -05:00
|
|
|
{
|
2010-06-05 20:56:19 -04:00
|
|
|
set_all_audio_midi_visibility (3, false);
|
2006-01-09 23:25:47 -05:00
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2010-09-28 14:37:21 -04:00
|
|
|
bool
|
|
|
|
EditorRoutes::key_press (GdkEventKey* ev)
|
|
|
|
{
|
2014-09-07 14:11:28 -04:00
|
|
|
TreeViewColumn *col;
|
|
|
|
boost::shared_ptr<RouteList> rl (new RouteList);
|
|
|
|
TreePath path;
|
|
|
|
|
|
|
|
switch (ev->keyval) {
|
|
|
|
case GDK_Tab:
|
|
|
|
case GDK_ISO_Left_Tab:
|
|
|
|
|
|
|
|
/* If we appear to be editing something, leave that cleanly and appropriately. */
|
|
|
|
if (name_editable) {
|
|
|
|
name_editable->editing_done ();
|
|
|
|
name_editable = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
col = _display.get_column (_name_column); // select&focus on name column
|
|
|
|
|
|
|
|
if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
|
|
|
|
treeview_select_previous (_display, _model, col);
|
2013-02-06 09:38:13 -05:00
|
|
|
} else {
|
2014-09-07 14:11:28 -04:00
|
|
|
treeview_select_next (_display, _model, col);
|
2013-02-06 09:38:13 -05:00
|
|
|
}
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'm':
|
|
|
|
if (get_relevant_routes (rl)) {
|
2016-05-27 16:13:10 -04:00
|
|
|
_session->set_controls (route_list_to_control_list (rl, &Stripable::mute_control), rl->front()->muted() ? 0.0 : 1.0, Controllable::NoGroup);
|
2014-09-07 14:11:28 -04:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
break;
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
case 's':
|
|
|
|
if (get_relevant_routes (rl)) {
|
2016-05-27 16:13:10 -04:00
|
|
|
_session->set_controls (route_list_to_control_list (rl, &Stripable::solo_control), rl->front()->self_soloed() ? 0.0 : 1.0, Controllable::NoGroup);
|
2014-09-07 14:11:28 -04:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'r':
|
|
|
|
if (get_relevant_routes (rl)) {
|
2016-04-08 16:49:47 -04:00
|
|
|
for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
|
|
|
|
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*r);
|
|
|
|
if (t) {
|
2016-05-27 16:13:10 -04:00
|
|
|
_session->set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), !t->rec_enable_control()->get_value(), Controllable::NoGroup);
|
2016-04-08 16:49:47 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-09-07 14:11:28 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2010-09-28 14:37:21 -04:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-09-28 21:22:11 -04:00
|
|
|
bool
|
|
|
|
EditorRoutes::get_relevant_routes (boost::shared_ptr<RouteList> rl)
|
|
|
|
{
|
2014-09-07 14:11:28 -04:00
|
|
|
TimeAxisView* tv;
|
|
|
|
RouteTimeAxisView* rtv;
|
2010-09-28 21:22:11 -04:00
|
|
|
RefPtr<TreeSelection> selection = _display.get_selection();
|
2014-09-07 14:11:28 -04:00
|
|
|
TreePath path;
|
|
|
|
TreeIter iter;
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
if (selection->count_selected_rows() != 0) {
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
/* use selection */
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
RefPtr<TreeModel> tm = RefPtr<TreeModel>::cast_dynamic (_model);
|
|
|
|
iter = selection->get_selected (tm);
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
} else {
|
|
|
|
/* use mouse pointer */
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
int x, y;
|
|
|
|
int bx, by;
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
_display.get_pointer (x, y);
|
|
|
|
_display.convert_widget_to_bin_window_coords (x, y, bx, by);
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
if (_display.get_path_at_pos (bx, by, path)) {
|
|
|
|
iter = _model->get_iter (path);
|
|
|
|
}
|
|
|
|
}
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
if (iter) {
|
|
|
|
tv = (*iter)[_columns.tv];
|
|
|
|
if (tv) {
|
|
|
|
rtv = dynamic_cast<RouteTimeAxisView*>(tv);
|
|
|
|
if (rtv) {
|
|
|
|
rl->push_back (rtv->route());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
return !rl->empty();
|
2010-09-28 21:22:11 -04:00
|
|
|
}
|
|
|
|
|
2020-01-14 01:13:04 -05:00
|
|
|
bool
|
|
|
|
EditorRoutes::select_function(const Glib::RefPtr<Gtk::TreeModel>&, const Gtk::TreeModel::Path&, bool)
|
|
|
|
{
|
|
|
|
return !column_does_not_select;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
EditorRoutes::button_release (GdkEventButton*)
|
|
|
|
{
|
|
|
|
column_does_not_select = false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2006-01-09 23:25:47 -05:00
|
|
|
bool
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::button_press (GdkEventButton* ev)
|
2006-01-09 23:25:47 -05:00
|
|
|
{
|
|
|
|
if (Keyboard::is_context_menu_event (ev)) {
|
2017-03-15 21:25:53 -04:00
|
|
|
if (_menu == 0) {
|
|
|
|
build_menu ();
|
|
|
|
}
|
|
|
|
_menu->popup (ev->button, ev->time);
|
2006-01-09 23:25:47 -05:00
|
|
|
return true;
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-12-06 11:46:50 -05:00
|
|
|
TreeModel::Path path;
|
|
|
|
TreeViewColumn *tvc;
|
|
|
|
int cell_x;
|
|
|
|
int cell_y;
|
|
|
|
|
|
|
|
if (!_display.get_path_at_pos ((int) ev->x, (int) ev->y, path, tvc, cell_x, cell_y)) {
|
|
|
|
/* cancel selection */
|
|
|
|
_display.get_selection()->unselect_all ();
|
|
|
|
/* end any editing by grabbing focus */
|
|
|
|
_display.grab_focus ();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-01-14 01:13:04 -05:00
|
|
|
if ((tvc == rec_state_column) ||
|
|
|
|
(tvc == rec_safe_column) ||
|
|
|
|
(tvc == input_active_column) ||
|
|
|
|
(tvc == mute_state_column) ||
|
|
|
|
(tvc == solo_state_column) ||
|
|
|
|
(tvc == solo_safe_state_column) ||
|
|
|
|
(tvc == solo_isolate_state_column) ||
|
|
|
|
(tvc == visible_column) ||
|
2022-01-01 10:52:55 -05:00
|
|
|
(tvc == trigger_column) ||
|
2020-01-14 01:13:04 -05:00
|
|
|
(tvc == active_column)) {
|
|
|
|
column_does_not_select = true;
|
|
|
|
}
|
2020-01-13 23:26:12 -05:00
|
|
|
|
2010-01-22 12:23:58 -05:00
|
|
|
//Scroll editor canvas to selected track
|
|
|
|
if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-01-22 12:23:58 -05:00
|
|
|
Gtk::TreeModel::Row row = *_model->get_iter (path);
|
|
|
|
TimeAxisView *tv = row[_columns.tv];
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2014-03-24 17:31:26 -04:00
|
|
|
if (tv) {
|
2014-03-24 19:46:45 -04:00
|
|
|
_editor->ensure_time_axis_view_is_visible (*tv, true);
|
2010-01-22 12:23:58 -05:00
|
|
|
}
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2006-01-09 23:25:47 -05:00
|
|
|
return false;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2014-03-24 17:31:26 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::selection_changed ()
|
|
|
|
{
|
2020-01-14 01:13:04 -05:00
|
|
|
if (_ignore_selection_change || column_does_not_select) {
|
2017-01-27 13:18:33 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-13 05:41:30 -05:00
|
|
|
_editor->begin_reversible_selection_op (X_("Select Track from Route List"));
|
|
|
|
|
2014-03-24 17:31:26 -04:00
|
|
|
if (_display.get_selection()->count_selected_rows() > 0) {
|
|
|
|
|
|
|
|
TreeIter iter;
|
|
|
|
TreeView::Selection::ListHandle_Path rows = _display.get_selection()->get_selected_rows ();
|
|
|
|
TrackViewList selected;
|
|
|
|
|
|
|
|
for (TreeView::Selection::ListHandle_Path::iterator i = rows.begin(); i != rows.end(); ++i) {
|
|
|
|
|
|
|
|
if ((iter = _model->get_iter (*i))) {
|
|
|
|
|
|
|
|
TimeAxisView* tv = (*iter)[_columns.tv];
|
|
|
|
selected.push_back (tv);
|
|
|
|
}
|
2014-09-07 14:11:28 -04:00
|
|
|
|
2014-03-24 17:31:26 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
_editor->get_selection().set (selected);
|
2014-03-24 19:46:45 -04:00
|
|
|
_editor->ensure_time_axis_view_is_visible (*(selected.front()), true);
|
2014-03-24 17:31:26 -04:00
|
|
|
|
|
|
|
} else {
|
|
|
|
_editor->get_selection().clear_tracks ();
|
|
|
|
}
|
2015-01-13 05:41:30 -05:00
|
|
|
|
|
|
|
_editor->commit_reversible_selection_op ();
|
2014-03-24 17:31:26 -04:00
|
|
|
}
|
|
|
|
|
2006-01-09 23:25:47 -05:00
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::initial_display ()
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-12-17 13:24:23 -05:00
|
|
|
|
|
|
|
if (!_session) {
|
2017-10-29 13:32:27 -04:00
|
|
|
clear ();
|
2009-12-17 13:24:23 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-02-20 19:35:18 -05:00
|
|
|
DisplaySuspender ds;
|
2017-02-21 06:25:57 -05:00
|
|
|
_model->clear ();
|
2017-02-20 19:35:18 -05:00
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
StripableList s;
|
|
|
|
|
2018-11-07 16:05:05 -05:00
|
|
|
_session->get_stripables (s);
|
2016-06-05 16:10:33 -04:00
|
|
|
_editor->add_stripables (s);
|
2017-01-27 13:18:33 -05:00
|
|
|
|
|
|
|
sync_treeview_from_presentation_info (Properties::order);
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2016-06-03 15:15:30 -04:00
|
|
|
struct ViewStripable {
|
|
|
|
TimeAxisView* tav;
|
|
|
|
boost::shared_ptr<Stripable> stripable;
|
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
ViewStripable (TimeAxisView* t, boost::shared_ptr<Stripable> s)
|
|
|
|
: tav (t), stripable (s) {}
|
2016-06-03 15:15:30 -04:00
|
|
|
};
|
|
|
|
|
2008-12-08 13:16:12 -05:00
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::move_selected_tracks (bool up)
|
2008-12-08 13:16:12 -05:00
|
|
|
{
|
2017-02-13 16:22:53 -05:00
|
|
|
TimeAxisView* scroll_to = 0;
|
2017-02-13 16:09:55 -05:00
|
|
|
StripableList sl;
|
|
|
|
_session->get_stripables (sl);
|
|
|
|
|
|
|
|
if (sl.size() < 2) {
|
|
|
|
/* nope */
|
2008-12-08 13:16:12 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-06-16 17:45:16 -04:00
|
|
|
sl.sort (Stripable::Sorter());
|
2017-02-13 16:09:55 -05:00
|
|
|
|
2016-05-21 12:44:41 -04:00
|
|
|
std::list<ViewStripable> view_stripables;
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
/* build a list that includes time axis view information */
|
|
|
|
|
|
|
|
for (StripableList::const_iterator sli = sl.begin(); sli != sl.end(); ++sli) {
|
2017-05-05 07:31:49 -04:00
|
|
|
TimeAxisView* tv = _editor->time_axis_view_from_stripable (*sli);
|
2017-02-13 16:09:55 -05:00
|
|
|
view_stripables.push_back (ViewStripable (tv, *sli));
|
2008-12-08 13:16:12 -05:00
|
|
|
}
|
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
/* for each selected stripable, move it above or below the adjacent
|
|
|
|
* stripable that has a time-axis view representation here. If there's
|
|
|
|
* no such representation, then
|
|
|
|
*/
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
list<ViewStripable>::iterator unselected_neighbour;
|
|
|
|
list<ViewStripable>::iterator vsi;
|
2017-01-29 03:34:09 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
{
|
|
|
|
PresentationInfo::ChangeSuspender cs;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
if (up) {
|
2017-02-20 15:52:13 -05:00
|
|
|
unselected_neighbour = view_stripables.end ();
|
2017-02-13 16:09:55 -05:00
|
|
|
vsi = view_stripables.begin();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
while (vsi != view_stripables.end()) {
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2017-05-05 07:31:49 -04:00
|
|
|
if (vsi->stripable->is_selected()) {
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
if (unselected_neighbour != view_stripables.end()) {
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
PresentationInfo::order_t unselected_neighbour_order = unselected_neighbour->stripable->presentation_info().order();
|
|
|
|
PresentationInfo::order_t my_order = vsi->stripable->presentation_info().order();
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
unselected_neighbour->stripable->set_presentation_order (my_order);
|
|
|
|
vsi->stripable->set_presentation_order (unselected_neighbour_order);
|
2017-02-13 16:22:53 -05:00
|
|
|
|
|
|
|
if (!scroll_to) {
|
|
|
|
scroll_to = vsi->tav;
|
|
|
|
}
|
2017-02-13 16:09:55 -05:00
|
|
|
}
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
} else {
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
if (vsi->tav) {
|
|
|
|
unselected_neighbour = vsi;
|
|
|
|
}
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-01-29 03:34:09 -05:00
|
|
|
}
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
++vsi;
|
|
|
|
}
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
} else {
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
unselected_neighbour = view_stripables.end();
|
|
|
|
vsi = unselected_neighbour;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
do {
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-20 15:37:50 -05:00
|
|
|
--vsi;
|
|
|
|
|
2017-05-05 07:31:49 -04:00
|
|
|
if (vsi->stripable->is_selected()) {
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
if (unselected_neighbour != view_stripables.end()) {
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
PresentationInfo::order_t unselected_neighbour_order = unselected_neighbour->stripable->presentation_info().order();
|
|
|
|
PresentationInfo::order_t my_order = vsi->stripable->presentation_info().order();
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
unselected_neighbour->stripable->set_presentation_order (my_order);
|
|
|
|
vsi->stripable->set_presentation_order (unselected_neighbour_order);
|
2017-02-13 16:22:53 -05:00
|
|
|
|
|
|
|
if (!scroll_to) {
|
|
|
|
scroll_to = vsi->tav;
|
|
|
|
}
|
2017-02-13 16:09:55 -05:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
} else {
|
2008-12-08 13:16:12 -05:00
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
if (vsi->tav) {
|
|
|
|
unselected_neighbour = vsi;
|
|
|
|
}
|
2008-12-08 13:16:12 -05:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-13 16:09:55 -05:00
|
|
|
} while (vsi != view_stripables.begin());
|
|
|
|
}
|
2012-06-27 18:57:06 -04:00
|
|
|
}
|
2011-11-17 18:44:16 -05:00
|
|
|
|
2017-02-13 16:22:53 -05:00
|
|
|
if (scroll_to) {
|
|
|
|
_editor->ensure_time_axis_view_is_visible (*scroll_to, false);
|
|
|
|
}
|
2008-12-12 09:43:24 -05:00
|
|
|
}
|
2009-06-17 21:48:11 -04:00
|
|
|
|
2011-07-01 11:48:24 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::update_input_active_display ()
|
|
|
|
{
|
|
|
|
TreeModel::Children rows = _model->children();
|
|
|
|
TreeModel::Children::iterator i;
|
|
|
|
|
|
|
|
for (i = rows.begin(); i != rows.end(); ++i) {
|
2016-05-21 12:44:41 -04:00
|
|
|
boost::shared_ptr<Stripable> stripable = (*i)[_columns.stripable];
|
2011-07-01 11:48:24 -04:00
|
|
|
|
2016-05-21 12:44:41 -04:00
|
|
|
if (boost::dynamic_pointer_cast<Track> (stripable)) {
|
|
|
|
boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (stripable);
|
2014-09-07 14:11:28 -04:00
|
|
|
|
2011-07-01 11:48:24 -04:00
|
|
|
if (mt) {
|
|
|
|
(*i)[_columns.is_input_active] = mt->input_active();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-17 21:48:11 -04:00
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::update_rec_display ()
|
2009-06-17 21:48:11 -04:00
|
|
|
{
|
2021-03-18 22:14:14 -04:00
|
|
|
if (!_idle_update_queued) {
|
|
|
|
_idle_update_queued = true;
|
2014-09-06 07:10:47 -04:00
|
|
|
Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
EditorRoutes::idle_update_mute_rec_solo_etc()
|
|
|
|
{
|
2021-03-18 22:14:14 -04:00
|
|
|
_idle_update_queued = false;
|
2009-07-01 19:20:18 -04:00
|
|
|
TreeModel::Children rows = _model->children();
|
2009-06-17 21:48:11 -04:00
|
|
|
TreeModel::Children::iterator i;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-06-17 21:48:11 -04:00
|
|
|
for (i = rows.begin(); i != rows.end(); ++i) {
|
2016-05-21 12:44:41 -04:00
|
|
|
boost::shared_ptr<Stripable> stripable = (*i)[_columns.stripable];
|
|
|
|
boost::shared_ptr<Route> route = boost::dynamic_pointer_cast<Route> (stripable);
|
|
|
|
(*i)[_columns.mute_state] = RouteUI::mute_active_state (_session, stripable);
|
|
|
|
(*i)[_columns.solo_state] = RouteUI::solo_active_state (stripable);
|
|
|
|
(*i)[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (stripable) ? 1 : 0;
|
|
|
|
(*i)[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (stripable) ? 1 : 0;
|
|
|
|
if (route) {
|
|
|
|
(*i)[_columns.active] = route->active ();
|
|
|
|
} else {
|
|
|
|
(*i)[_columns.active] = true;
|
|
|
|
}
|
2016-04-08 16:49:47 -04:00
|
|
|
|
|
|
|
boost::shared_ptr<Track> trk (boost::dynamic_pointer_cast<Track>(route));
|
|
|
|
|
|
|
|
if (trk) {
|
2014-12-26 13:04:40 -05:00
|
|
|
boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2016-04-08 16:49:47 -04:00
|
|
|
if (trk->rec_enable_control()->get_value()) {
|
2014-12-26 13:04:40 -05:00
|
|
|
if (_session->record_status() == Session::Recording) {
|
|
|
|
(*i)[_columns.rec_state] = 1;
|
2010-08-15 06:33:41 -04:00
|
|
|
} else {
|
2014-12-26 13:04:40 -05:00
|
|
|
(*i)[_columns.rec_state] = 2;
|
2010-08-15 06:33:41 -04:00
|
|
|
}
|
2014-12-26 13:04:40 -05:00
|
|
|
} else if (mt && mt->step_editing()) {
|
|
|
|
(*i)[_columns.rec_state] = 3;
|
|
|
|
} else {
|
|
|
|
(*i)[_columns.rec_state] = 0;
|
2014-09-06 07:10:47 -04:00
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2016-05-27 16:13:10 -04:00
|
|
|
(*i)[_columns.rec_safe] = trk->rec_safe_control()->get_value();
|
2016-04-08 16:49:47 -04:00
|
|
|
(*i)[_columns.name_editable] = !trk->rec_enable_control()->get_value();
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2009-06-17 21:48:11 -04:00
|
|
|
}
|
2014-12-26 13:04:40 -05:00
|
|
|
|
2014-09-06 07:10:47 -04:00
|
|
|
return false; // do not call again (until needed)
|
2009-06-17 21:48:11 -04:00
|
|
|
}
|
2009-07-01 19:20:18 -04:00
|
|
|
|
2014-09-06 07:10:47 -04:00
|
|
|
|
2009-11-16 08:35:00 -05:00
|
|
|
void
|
2009-12-17 13:24:23 -05:00
|
|
|
EditorRoutes::update_mute_display ()
|
2009-11-16 08:35:00 -05:00
|
|
|
{
|
2021-03-18 22:14:14 -04:00
|
|
|
if (!_idle_update_queued) {
|
|
|
|
_idle_update_queued = true;
|
2014-09-06 07:10:47 -04:00
|
|
|
Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
|
2009-11-16 08:35:00 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2016-01-21 11:03:14 -05:00
|
|
|
EditorRoutes::update_solo_display ()
|
2009-11-16 08:35:00 -05:00
|
|
|
{
|
2021-03-18 22:14:14 -04:00
|
|
|
if (!_idle_update_queued) {
|
|
|
|
_idle_update_queued = true;
|
2014-09-06 07:10:47 -04:00
|
|
|
Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
|
2009-11-16 08:35:00 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-10 15:51:35 -05:00
|
|
|
void
|
2009-12-17 13:24:23 -05:00
|
|
|
EditorRoutes::update_solo_isolate_display ()
|
2009-12-10 15:51:35 -05:00
|
|
|
{
|
2021-03-18 22:14:14 -04:00
|
|
|
if (!_idle_update_queued) {
|
|
|
|
_idle_update_queued = true;
|
2014-09-06 07:10:47 -04:00
|
|
|
Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
|
2009-12-10 15:51:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-05 16:08:37 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::update_solo_safe_display ()
|
|
|
|
{
|
2021-03-18 22:14:14 -04:00
|
|
|
if (!_idle_update_queued) {
|
|
|
|
_idle_update_queued = true;
|
2014-09-06 07:10:47 -04:00
|
|
|
Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
|
2010-04-05 16:08:37 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-09 13:58:13 -04:00
|
|
|
list<TimeAxisView*>
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::views () const
|
2009-07-01 19:20:18 -04:00
|
|
|
{
|
2009-07-09 13:58:13 -04:00
|
|
|
list<TimeAxisView*> v;
|
2009-07-01 19:20:18 -04:00
|
|
|
for (TreeModel::Children::iterator i = _model->children().begin(); i != _model->children().end(); ++i) {
|
|
|
|
v.push_back ((*i)[_columns.tv]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-07-03 14:37:15 -04:00
|
|
|
EditorRoutes::clear ()
|
2009-07-01 19:20:18 -04:00
|
|
|
{
|
2017-05-05 07:31:49 -04:00
|
|
|
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
|
2009-07-01 19:20:18 -04:00
|
|
|
_display.set_model (Glib::RefPtr<Gtk::TreeStore> (0));
|
|
|
|
_model->clear ();
|
|
|
|
_display.set_model (_model);
|
|
|
|
}
|
2009-11-11 19:17:45 -05:00
|
|
|
|
2010-09-28 21:22:11 -04:00
|
|
|
void
|
|
|
|
EditorRoutes::name_edit_started (CellEditable* ce, const Glib::ustring&)
|
|
|
|
{
|
2014-09-07 14:11:28 -04:00
|
|
|
name_editable = ce;
|
2010-11-05 12:53:57 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
/* give it a special name */
|
2010-11-05 12:53:57 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
Gtk::Entry *e = dynamic_cast<Gtk::Entry*> (ce);
|
2010-11-05 12:53:57 -04:00
|
|
|
|
2014-09-07 14:11:28 -04:00
|
|
|
if (e) {
|
|
|
|
e->set_name (X_("RouteNameEditorEntry"));
|
|
|
|
}
|
2010-09-28 21:22:11 -04:00
|
|
|
}
|
|
|
|
|
2009-11-11 19:17:45 -05:00
|
|
|
void
|
2010-09-14 12:51:02 -04:00
|
|
|
EditorRoutes::name_edit (std::string const & path, std::string const & new_text)
|
2009-11-11 19:17:45 -05:00
|
|
|
{
|
2014-09-07 14:11:28 -04:00
|
|
|
name_editable = 0;
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2009-11-11 19:17:45 -05:00
|
|
|
TreeIter iter = _model->get_iter (path);
|
2010-09-28 21:22:11 -04:00
|
|
|
|
2009-11-11 19:17:45 -05:00
|
|
|
if (!iter) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-21 12:44:41 -04:00
|
|
|
boost::shared_ptr<Stripable> stripable = (*iter)[_columns.stripable];
|
2009-11-11 19:17:45 -05:00
|
|
|
|
2016-05-21 12:44:41 -04:00
|
|
|
if (stripable && stripable->name() != new_text) {
|
|
|
|
stripable->set_name (new_text);
|
2009-11-11 19:17:45 -05:00
|
|
|
}
|
|
|
|
}
|
2009-11-25 22:02:16 -05:00
|
|
|
|
|
|
|
void
|
|
|
|
EditorRoutes::solo_changed_so_update_mute ()
|
|
|
|
{
|
2009-12-17 13:24:23 -05:00
|
|
|
update_mute_display ();
|
2009-11-25 22:02:16 -05:00
|
|
|
}
|
2009-11-29 07:47:59 -05:00
|
|
|
|
|
|
|
void
|
|
|
|
EditorRoutes::show_tracks_with_regions_at_playhead ()
|
|
|
|
{
|
2020-10-05 00:52:17 -04:00
|
|
|
boost::shared_ptr<RouteList> const r = _session->get_routes_with_regions_at (timepos_t (_session->transport_sample ()));
|
2009-11-29 07:47:59 -05:00
|
|
|
|
|
|
|
set<TimeAxisView*> show;
|
|
|
|
for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
|
2017-05-05 07:31:49 -04:00
|
|
|
TimeAxisView* tav = _editor->time_axis_view_from_stripable (*i);
|
2009-11-29 07:47:59 -05:00
|
|
|
if (tav) {
|
|
|
|
show.insert (tav);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-28 20:52:56 -04:00
|
|
|
DisplaySuspender ds;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-11-29 07:47:59 -05:00
|
|
|
TreeModel::Children rows = _model->children ();
|
|
|
|
for (TreeModel::Children::iterator i = rows.begin(); i != rows.end(); ++i) {
|
|
|
|
TimeAxisView* tv = (*i)[_columns.tv];
|
2015-09-28 16:14:04 -04:00
|
|
|
bool to_show = (show.find (tv) != show.end());
|
|
|
|
|
|
|
|
tv->set_marked_for_display (to_show);
|
|
|
|
(*i)[_columns.visible] = to_show;
|
2009-11-29 07:47:59 -05:00
|
|
|
}
|
2015-09-28 16:14:04 -04:00
|
|
|
|
|
|
|
/* force route order keys catch up with visibility changes
|
|
|
|
*/
|
|
|
|
|
2016-05-16 07:30:28 -04:00
|
|
|
sync_presentation_info_from_treeview ();
|
2009-11-29 07:47:59 -05:00
|
|
|
}
|
2016-05-19 10:29:39 -04:00
|
|
|
|
|
|
|
int
|
|
|
|
EditorRoutes::plugin_setup (boost::shared_ptr<Route> r, boost::shared_ptr<PluginInsert> pi, ARDOUR::Route::PluginSetupOptions flags)
|
|
|
|
{
|
|
|
|
PluginSetupDialog psd (r, pi, flags);
|
2017-01-20 18:40:18 -05:00
|
|
|
int rv = psd.run ();
|
|
|
|
return rv + (psd.fan_out() ? 4 : 0);
|
2016-05-19 10:29:39 -04:00
|
|
|
}
|