2006-07-23 08:03:19 -04:00
|
|
|
/*
|
2019-08-02 17:26:43 -04:00
|
|
|
* Copyright (C) 2006-2014 David Robillard <d@drobilla.net>
|
|
|
|
* Copyright (C) 2007-2012 Carl Hetherington <carl@carlh.net>
|
|
|
|
* Copyright (C) 2007-2017 Paul Davis <paul@linuxaudiosystems.com>
|
|
|
|
* Copyright (C) 2007 Doug McLain <doug@nostar.net>
|
|
|
|
* Copyright (C) 2008-2009 Hans Baier <hansfbaier@googlemail.com>
|
|
|
|
* Copyright (C) 2012-2019 Robin Gareus <robin@gareus.org>
|
|
|
|
* Copyright (C) 2013-2014 Colin Fletcher <colin.m.fletcher@googlemail.com>
|
|
|
|
* Copyright (C) 2014-2017 Ben Loftis <ben@harrisonconsoles.com>
|
|
|
|
* Copyright (C) 2015-2016 Nick Mainsbridge <mainsbridge@gmail.com>
|
|
|
|
* Copyright (C) 2015-2016 Tim Mayberry <mojofunk@gmail.com>
|
|
|
|
* Copyright (C) 2016 Julien "_FrnchFrgg_" RIVAUD <frnchfrgg@free.fr>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <cmath>
|
|
|
|
#include <cassert>
|
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
2010-10-17 19:35:05 -04:00
|
|
|
#include <map>
|
2007-06-27 11:51:50 -04:00
|
|
|
#include <utility>
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
#include <sigc++/bind.h>
|
|
|
|
|
2017-07-16 21:48:18 -04:00
|
|
|
#include <gtkmm/menu.h>
|
|
|
|
#include <gtkmm/menuitem.h>
|
|
|
|
#include <gtkmm/stock.h>
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/error.h"
|
|
|
|
#include "pbd/stl_delete.h"
|
|
|
|
#include "pbd/whitespace.h"
|
|
|
|
#include "pbd/memento_command.h"
|
2009-08-25 21:06:31 -04:00
|
|
|
#include "pbd/enumwriter.h"
|
2010-03-04 08:15:04 -05:00
|
|
|
#include "pbd/stateful_diff_command.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2017-07-16 21:48:18 -04:00
|
|
|
#include "evoral/Parameter.hpp"
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
#include "ardour/amp.h"
|
2013-07-02 16:58:24 -04:00
|
|
|
#include "ardour/meter.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/event_type_map.h"
|
2014-11-30 16:24:18 -05:00
|
|
|
#include "ardour/pannable.h"
|
|
|
|
#include "ardour/panner.h"
|
2017-09-09 12:25:36 -04:00
|
|
|
#include "ardour/plugin_insert.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/processor.h"
|
|
|
|
#include "ardour/profile.h"
|
|
|
|
#include "ardour/route_group.h"
|
|
|
|
#include "ardour/session.h"
|
2012-05-24 02:09:29 -04:00
|
|
|
#include "ardour/session_playlists.h"
|
2017-07-16 21:48:18 -04:00
|
|
|
#include "ardour/track.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2013-11-03 10:07:00 -05:00
|
|
|
#include "canvas/debug.h"
|
|
|
|
|
2017-07-16 21:48:18 -04:00
|
|
|
#include "gtkmm2ext/gtk_ui.h"
|
|
|
|
#include "gtkmm2ext/utils.h"
|
|
|
|
|
|
|
|
#include "widgets/ardour_button.h"
|
2017-07-16 23:18:48 -04:00
|
|
|
#include "widgets/prompter.h"
|
2017-07-16 21:48:18 -04:00
|
|
|
#include "widgets/tooltips.h"
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "ardour_ui.h"
|
2015-06-20 15:27:45 -04:00
|
|
|
#include "audio_streamview.h"
|
2011-02-20 21:58:16 -05:00
|
|
|
#include "debug.h"
|
2016-08-30 08:36:45 -04:00
|
|
|
#include "enums_convert.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "route_time_axis.h"
|
2006-07-29 23:25:38 -04:00
|
|
|
#include "automation_time_axis.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "enums.h"
|
|
|
|
#include "gui_thread.h"
|
2014-11-16 17:04:27 -05:00
|
|
|
#include "item_counts.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "keyboard.h"
|
2014-12-06 12:20:52 -05:00
|
|
|
#include "paste_context.h"
|
2017-09-09 12:25:36 -04:00
|
|
|
#include "patch_change_widget.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "playlist_selector.h"
|
|
|
|
#include "point_selection.h"
|
|
|
|
#include "public_editor.h"
|
2006-08-01 13:19:38 -04:00
|
|
|
#include "region_view.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "rgb_macros.h"
|
|
|
|
#include "selection.h"
|
|
|
|
#include "streamview.h"
|
2015-01-02 09:44:54 -05:00
|
|
|
#include "ui_config.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
#include "utils.h"
|
2009-06-28 20:38:58 -04:00
|
|
|
#include "route_group_menu.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2016-07-14 14:44:52 -04:00
|
|
|
#include "pbd/i18n.h"
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
using namespace ARDOUR;
|
2017-07-15 11:38:28 -04:00
|
|
|
using namespace ArdourWidgets;
|
2006-07-23 08:03:19 -04:00
|
|
|
using namespace PBD;
|
2008-02-16 17:43:18 -05:00
|
|
|
using namespace Gtkmm2ext;
|
2006-07-23 08:03:19 -04:00
|
|
|
using namespace Gtk;
|
|
|
|
using namespace Editing;
|
2008-02-16 17:43:18 -05:00
|
|
|
using namespace std;
|
2011-11-03 17:35:20 -04:00
|
|
|
using std::list;
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2013-04-04 00:32:52 -04:00
|
|
|
RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session* sess, ArdourCanvas::Canvas& canvas)
|
2016-06-05 15:47:39 -04:00
|
|
|
: RouteUI(sess)
|
2017-06-09 08:48:33 -04:00
|
|
|
, StripableTimeAxisView(ed, sess, canvas)
|
2011-07-06 20:37:13 -04:00
|
|
|
, _view (0)
|
2009-06-23 16:02:15 -04:00
|
|
|
, button_table (3, 3)
|
2015-04-04 18:17:53 -04:00
|
|
|
, route_group_button (S_("RTAV|G"))
|
|
|
|
, playlist_button (S_("RTAV|P"))
|
|
|
|
, automation_button (S_("RTAV|A"))
|
2011-07-06 20:37:13 -04:00
|
|
|
, automation_action_menu (0)
|
|
|
|
, plugins_submenu_item (0)
|
|
|
|
, route_group_menu (0)
|
|
|
|
, playlist_action_menu (0)
|
2014-08-31 15:32:22 -04:00
|
|
|
, gm (sess, true, 75, 14)
|
2012-06-13 16:58:07 -04:00
|
|
|
, _ignore_set_layer_display (false)
|
2014-11-30 16:24:18 -05:00
|
|
|
, pan_automation_item(NULL)
|
2009-06-23 16:02:15 -04:00
|
|
|
{
|
2014-09-05 11:45:45 -04:00
|
|
|
number_label.set_name("tracknumber label");
|
2014-08-29 15:10:20 -04:00
|
|
|
number_label.set_elements((ArdourButton::Element)(ArdourButton::Edge|ArdourButton::Body|ArdourButton::Text|ArdourButton::Inactive));
|
2014-06-26 13:21:05 -04:00
|
|
|
number_label.set_alignment(.5, .5);
|
2014-08-28 15:25:19 -04:00
|
|
|
number_label.set_fallthrough_to_parent (true);
|
2014-06-26 13:21:05 -04:00
|
|
|
|
|
|
|
sess->config.ParameterChanged.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::parameter_changed, this, _1), gui_context());
|
2016-05-04 11:36:40 -04:00
|
|
|
UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &RouteTimeAxisView::parameter_changed));
|
|
|
|
|
|
|
|
parameter_changed ("editor-stereo-only-meters");
|
2011-07-06 20:37:13 -04:00
|
|
|
}
|
|
|
|
|
2016-06-05 16:13:52 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::route_property_changed (const PBD::PropertyChange& what_changed)
|
|
|
|
{
|
|
|
|
if (what_changed.contains (ARDOUR::Properties::name)) {
|
|
|
|
label_view ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-06 20:37:13 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::set_route (boost::shared_ptr<Route> rt)
|
|
|
|
{
|
|
|
|
RouteUI::set_route (rt);
|
2017-06-09 08:48:33 -04:00
|
|
|
StripableTimeAxisView::set_stripable (rt);
|
2013-01-14 16:46:32 -05:00
|
|
|
|
2013-11-03 10:07:00 -05:00
|
|
|
CANVAS_DEBUG_NAME (_canvas_display, string_compose ("main for %1", rt->name()));
|
|
|
|
CANVAS_DEBUG_NAME (selection_group, string_compose ("selections for %1", rt->name()));
|
|
|
|
CANVAS_DEBUG_NAME (_ghost_group, string_compose ("ghosts for %1", rt->name()));
|
|
|
|
|
2013-07-02 16:58:24 -04:00
|
|
|
int meter_width = 3;
|
|
|
|
if (_route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
|
|
|
|
meter_width = 6;
|
|
|
|
}
|
2016-01-25 11:47:44 -05:00
|
|
|
gm.set_controls (_route, _route->shared_peak_meter(), _route->amp(), _route->gain_control());
|
2008-09-10 11:03:30 -04:00
|
|
|
gm.get_level_meter().set_no_show_all();
|
2013-07-02 16:58:24 -04:00
|
|
|
gm.get_level_meter().setup_meters(50, meter_width);
|
2012-05-31 20:41:28 -04:00
|
|
|
gm.update_gain_sensitive ();
|
2008-02-16 17:43:18 -05:00
|
|
|
|
2016-08-30 08:36:45 -04:00
|
|
|
uint32_t height;
|
|
|
|
if (get_gui_property ("height", height)) {
|
|
|
|
set_height (height);
|
2011-07-06 20:37:13 -04:00
|
|
|
} else {
|
|
|
|
set_height (preset_height (HeightNormal));
|
|
|
|
}
|
2008-09-12 05:01:52 -04:00
|
|
|
|
2013-04-06 16:04:02 -04:00
|
|
|
if (!_route->is_auditioner()) {
|
2011-07-11 16:32:33 -04:00
|
|
|
if (gui_property ("visible").empty()) {
|
|
|
|
set_gui_property ("visible", true);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
set_gui_property ("visible", false);
|
2008-09-12 05:01:52 -04:00
|
|
|
}
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
timestretch_rect = 0;
|
|
|
|
no_redraw = false;
|
|
|
|
|
|
|
|
ignore_toggle = false;
|
|
|
|
|
2011-11-11 12:24:05 -05:00
|
|
|
route_group_button.set_name ("route button");
|
|
|
|
playlist_button.set_name ("route button");
|
|
|
|
automation_button.set_name ("route button");
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2016-08-18 04:42:43 -04:00
|
|
|
route_group_button.signal_button_press_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::route_group_click), false);
|
|
|
|
playlist_button.signal_button_press_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::playlist_click), false);
|
|
|
|
automation_button.signal_button_press_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::automation_click), false);
|
2009-12-11 18:29:48 -05:00
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
if (is_track()) {
|
2006-11-19 11:45:16 -05:00
|
|
|
|
2014-08-31 10:12:43 -04:00
|
|
|
if (ARDOUR::Profile->get_mixbus()) {
|
|
|
|
controls_table.attach (*rec_enable_button, 0, 1, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
} else {
|
|
|
|
controls_table.attach (*rec_enable_button, 2, 3, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
}
|
2010-07-24 12:40:56 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
if (is_midi_track()) {
|
|
|
|
set_tooltip(*rec_enable_button, _("Record (Right-click for Step Edit)"));
|
2013-01-11 20:37:27 -05:00
|
|
|
gm.set_fader_name ("MidiTrackFader");
|
2017-06-23 17:42:42 -04:00
|
|
|
} else {
|
|
|
|
set_tooltip(*rec_enable_button, _("Record"));
|
2013-01-11 20:37:27 -05:00
|
|
|
gm.set_fader_name ("AudioTrackFader");
|
2017-06-23 17:42:42 -04:00
|
|
|
}
|
2008-01-10 16:20:59 -05:00
|
|
|
|
2012-06-11 19:15:17 -04:00
|
|
|
/* set playlist button tip to the current playlist, and make it update when it changes */
|
|
|
|
update_playlist_tip ();
|
|
|
|
track()->PlaylistChanged.connect (*this, invalidator (*this), ui_bind(&RouteTimeAxisView::update_playlist_tip, this), gui_context());
|
2013-01-11 20:37:27 -05:00
|
|
|
|
|
|
|
} else {
|
|
|
|
gm.set_fader_name ("AudioBusFader");
|
2014-08-31 01:11:24 -04:00
|
|
|
Gtk::Fixed *blank = manage(new Gtk::Fixed());
|
|
|
|
controls_button_size_group->add_widget(*blank);
|
2014-08-31 10:12:43 -04:00
|
|
|
if (ARDOUR::Profile->get_mixbus() ) {
|
|
|
|
controls_table.attach (*blank, 0, 1, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
} else {
|
|
|
|
controls_table.attach (*blank, 2, 3, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
}
|
2014-08-31 01:11:24 -04:00
|
|
|
blank->show();
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
2013-07-03 01:36:15 -04:00
|
|
|
|
2014-09-08 12:42:41 -04:00
|
|
|
top_hbox.pack_end(gm.get_level_meter(), false, false, 2);
|
2013-07-03 01:36:15 -04:00
|
|
|
|
2014-08-31 10:12:43 -04:00
|
|
|
if (!ARDOUR::Profile->get_mixbus()) {
|
|
|
|
controls_meters_size_group->add_widget (gm.get_level_meter());
|
|
|
|
}
|
|
|
|
|
2017-03-08 12:37:36 -05:00
|
|
|
if (_route->is_master()) {
|
|
|
|
route_group_button.set_sensitive(false);
|
|
|
|
}
|
|
|
|
|
2010-04-03 09:40:34 -04:00
|
|
|
_route->meter_change.connect (*this, invalidator (*this), bind (&RouteTimeAxisView::meter_changed, this), gui_context());
|
2012-04-25 08:58:19 -04:00
|
|
|
_route->input()->changed.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context());
|
|
|
|
_route->output()->changed.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context());
|
2014-06-26 13:21:05 -04:00
|
|
|
_route->track_number_changed.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::label_view, this), gui_context());
|
2007-12-20 18:25:19 -05:00
|
|
|
|
2014-08-31 10:12:43 -04:00
|
|
|
if (ARDOUR::Profile->get_mixbus()) {
|
|
|
|
controls_table.attach (*mute_button, 1, 2, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
} else {
|
|
|
|
controls_table.attach (*mute_button, 3, 4, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
}
|
2014-09-07 12:50:57 -04:00
|
|
|
// mute button is always present, it is used to
|
|
|
|
// force the 'blank' placeholders to the proper size
|
2014-08-31 01:11:24 -04:00
|
|
|
controls_button_size_group->add_widget(*mute_button);
|
2010-04-20 09:09:13 -04:00
|
|
|
|
2014-08-31 01:11:24 -04:00
|
|
|
if (!_route->is_master()) {
|
2014-08-31 10:12:43 -04:00
|
|
|
if (ARDOUR::Profile->get_mixbus()) {
|
|
|
|
controls_table.attach (*solo_button, 2, 3, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
} else {
|
|
|
|
controls_table.attach (*solo_button, 4, 5, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
}
|
2014-08-31 01:11:24 -04:00
|
|
|
} else {
|
|
|
|
Gtk::Fixed *blank = manage(new Gtk::Fixed());
|
|
|
|
controls_button_size_group->add_widget(*blank);
|
2014-08-31 10:12:43 -04:00
|
|
|
if (ARDOUR::Profile->get_mixbus()) {
|
|
|
|
controls_table.attach (*blank, 2, 3, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
} else {
|
|
|
|
controls_table.attach (*blank, 4, 5, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
}
|
2014-08-31 01:11:24 -04:00
|
|
|
blank->show();
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2014-08-31 10:12:43 -04:00
|
|
|
if (ARDOUR::Profile->get_mixbus()) {
|
2014-08-31 15:32:22 -04:00
|
|
|
controls_table.attach (route_group_button, 2, 3, 2, 3, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
controls_table.attach (gm.get_gain_slider(), 3, 5, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 1, 0);
|
2014-08-31 10:12:43 -04:00
|
|
|
}
|
|
|
|
else if (!ARDOUR::Profile->get_trx()) {
|
2014-08-31 15:32:22 -04:00
|
|
|
controls_table.attach (route_group_button, 4, 5, 2, 3, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
|
|
|
|
controls_table.attach (gm.get_gain_slider(), 0, 2, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 1, 0);
|
2014-04-10 13:30:25 -04:00
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2015-01-05 00:32:14 -05:00
|
|
|
set_tooltip(*solo_button,_("Solo"));
|
|
|
|
set_tooltip(*mute_button,_("Mute"));
|
|
|
|
set_tooltip(route_group_button, _("Route Group"));
|
2012-01-10 10:53:33 -05:00
|
|
|
|
2014-09-07 12:50:57 -04:00
|
|
|
mute_button->set_tweaks(ArdourButton::TrackHeader);
|
|
|
|
solo_button->set_tweaks(ArdourButton::TrackHeader);
|
|
|
|
rec_enable_button->set_tweaks(ArdourButton::TrackHeader);
|
|
|
|
playlist_button.set_tweaks(ArdourButton::TrackHeader);
|
|
|
|
automation_button.set_tweaks(ArdourButton::TrackHeader);
|
|
|
|
route_group_button.set_tweaks(ArdourButton::TrackHeader);
|
2014-09-03 12:56:31 -04:00
|
|
|
|
2012-01-10 10:53:33 -05:00
|
|
|
if (is_midi_track()) {
|
2015-01-05 00:32:14 -05:00
|
|
|
set_tooltip(automation_button, _("MIDI Controllers and Automation"));
|
2012-01-10 10:53:33 -05:00
|
|
|
} else {
|
2015-01-05 00:32:14 -05:00
|
|
|
set_tooltip(automation_button, _("Automation"));
|
2012-01-10 10:53:33 -05:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2014-06-26 13:21:05 -04:00
|
|
|
update_track_number_visibility();
|
2006-07-23 08:03:19 -04:00
|
|
|
label_view ();
|
|
|
|
|
2014-08-31 10:12:43 -04:00
|
|
|
if (ARDOUR::Profile->get_mixbus()) {
|
2014-08-31 15:32:22 -04:00
|
|
|
controls_table.attach (automation_button, 1, 2, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
|
2014-04-10 13:30:25 -04:00
|
|
|
}
|
2014-08-31 10:12:43 -04:00
|
|
|
else if (!ARDOUR::Profile->get_trx()) {
|
2014-08-31 15:32:22 -04:00
|
|
|
controls_table.attach (automation_button, 3, 4, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
|
2014-08-31 10:12:43 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2014-08-31 10:12:43 -04:00
|
|
|
if (is_track() && track()->mode() == ARDOUR::Normal) {
|
|
|
|
if (ARDOUR::Profile->get_mixbus()) {
|
2014-08-31 15:32:22 -04:00
|
|
|
controls_table.attach (playlist_button, 0, 1, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
|
2014-08-31 10:12:43 -04:00
|
|
|
}
|
|
|
|
else if (!ARDOUR::Profile->get_trx()) {
|
2014-08-31 15:32:22 -04:00
|
|
|
controls_table.attach (playlist_button, 2, 3, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
|
2014-08-31 10:12:43 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2009-01-01 19:17:55 -05:00
|
|
|
_y_position = -1;
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2012-04-25 08:58:19 -04:00
|
|
|
_route->processors_changed.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::processors_changed, this, _1), gui_context());
|
2006-09-18 23:29:16 -04:00
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
if (is_track()) {
|
|
|
|
|
2016-08-30 08:36:45 -04:00
|
|
|
LayerDisplay layer_display;
|
|
|
|
if (get_gui_property ("layer-display", layer_display)) {
|
|
|
|
set_layer_display (layer_display);
|
2011-07-06 20:37:13 -04:00
|
|
|
}
|
|
|
|
|
2010-03-30 11:18:43 -04:00
|
|
|
track()->FreezeChange.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::map_frozen, this), gui_context());
|
2010-04-21 16:42:22 -04:00
|
|
|
track()->SpeedChanged.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::speed_changed, this), gui_context());
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
/* pick up the correct freeze state */
|
|
|
|
map_frozen ();
|
2012-12-27 09:08:38 -05:00
|
|
|
|
2015-10-04 14:51:05 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2015-01-02 09:44:54 -05:00
|
|
|
UIConfiguration::instance().ColorsChanged.connect (sigc::mem_fun (*this, &RouteTimeAxisView::color_handler));
|
2008-02-16 17:43:18 -05:00
|
|
|
|
2010-02-18 08:59:49 -05:00
|
|
|
PropertyList* plist = new PropertyList();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2016-06-05 15:54:37 -04:00
|
|
|
plist->add (ARDOUR::Properties::group_mute, true);
|
|
|
|
plist->add (ARDOUR::Properties::group_solo, true);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-02-18 08:59:49 -05:00
|
|
|
route_group_menu = new RouteGroupMenu (_session, plist);
|
2009-06-28 20:38:58 -04:00
|
|
|
|
2011-09-25 09:15:59 -04:00
|
|
|
gm.get_level_meter().signal_scroll_event().connect (sigc::mem_fun (*this, &RouteTimeAxisView::controls_ebox_scroll), false);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RouteTimeAxisView::~RouteTimeAxisView ()
|
|
|
|
{
|
2015-03-30 15:27:18 -04:00
|
|
|
cleanup_gui_properties ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
|
2006-07-29 23:25:38 -04:00
|
|
|
delete *i;
|
|
|
|
}
|
|
|
|
|
2008-12-18 14:31:00 -05:00
|
|
|
delete playlist_action_menu;
|
2019-03-07 10:40:16 -05:00
|
|
|
delete automation_action_menu;
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2008-12-18 14:31:00 -05:00
|
|
|
delete _view;
|
|
|
|
_view = 0;
|
2007-10-16 17:01:12 -04:00
|
|
|
|
|
|
|
_automation_tracks.clear ();
|
2009-06-28 20:38:58 -04:00
|
|
|
|
|
|
|
delete route_group_menu;
|
2015-01-07 18:41:59 -05:00
|
|
|
CatchDeletion (this);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2016-06-05 15:39:22 -04:00
|
|
|
string
|
|
|
|
RouteTimeAxisView::name() const
|
|
|
|
{
|
|
|
|
if (_route) {
|
|
|
|
return _route->name();
|
|
|
|
}
|
|
|
|
return string();
|
|
|
|
}
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
void
|
2007-01-09 18:24:54 -05:00
|
|
|
RouteTimeAxisView::post_construct ()
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2007-01-09 18:24:54 -05:00
|
|
|
/* map current state of the route */
|
|
|
|
|
|
|
|
update_diskstream_display ();
|
2011-07-02 19:36:01 -04:00
|
|
|
setup_processor_menu_and_curves ();
|
|
|
|
reset_processor_automation_curves ();
|
|
|
|
}
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2011-07-02 19:36:01 -04:00
|
|
|
/** Set up the processor menu for the current set of processors, and
|
|
|
|
* display automation curves for any parameters which have data.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::setup_processor_menu_and_curves ()
|
|
|
|
{
|
2010-06-08 17:48:38 -04:00
|
|
|
_subplugin_menu_map.clear ();
|
2007-10-01 13:19:09 -04:00
|
|
|
subplugin_menu.items().clear ();
|
2009-12-11 18:29:48 -05:00
|
|
|
_route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_processor_to_subplugin_menu));
|
|
|
|
_route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_existing_processor_automation_curves));
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
|
|
|
|
2016-08-18 04:42:43 -04:00
|
|
|
bool
|
2010-08-10 22:04:49 -04:00
|
|
|
RouteTimeAxisView::route_group_click (GdkEventButton *ev)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2008-01-10 16:20:59 -05:00
|
|
|
if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
|
2009-12-09 22:25:32 -05:00
|
|
|
if (_route->route_group()) {
|
|
|
|
_route->route_group()->remove (_route);
|
|
|
|
}
|
|
|
|
return false;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
2009-06-20 11:40:26 -04:00
|
|
|
|
2011-03-07 08:04:03 -05:00
|
|
|
WeakRouteList r;
|
|
|
|
r.push_back (route ());
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-03-07 08:04:03 -05:00
|
|
|
route_group_menu->build (r);
|
2016-08-18 04:42:43 -04:00
|
|
|
if (ev->button == 1) {
|
|
|
|
Gtkmm2ext::anchored_menu_popup(route_group_menu->menu(),
|
|
|
|
&route_group_button,
|
|
|
|
"", 1, ev->time);
|
|
|
|
} else {
|
|
|
|
route_group_menu->menu()->popup (ev->button, ev->time);
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2016-08-18 04:42:43 -04:00
|
|
|
return true;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::playlist_changed ()
|
|
|
|
{
|
|
|
|
label_view ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::label_view ()
|
|
|
|
{
|
2014-06-26 13:21:05 -04:00
|
|
|
string x = _route->name ();
|
|
|
|
if (x != name_label.get_text ()) {
|
2011-01-05 20:36:28 -05:00
|
|
|
name_label.set_text (x);
|
|
|
|
}
|
2014-06-26 13:21:05 -04:00
|
|
|
const int64_t track_number = _route->track_number ();
|
|
|
|
if (track_number == 0) {
|
|
|
|
number_label.set_text ("");
|
|
|
|
} else {
|
2016-09-21 01:25:30 -04:00
|
|
|
number_label.set_text (PBD::to_string (abs(_route->track_number ())));
|
2014-06-26 13:21:05 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::update_track_number_visibility ()
|
|
|
|
{
|
2014-08-31 01:12:21 -04:00
|
|
|
DisplaySuspender ds;
|
2014-06-26 13:21:05 -04:00
|
|
|
bool show_label = _session->config.get_track_name_number();
|
|
|
|
|
|
|
|
if (_route && _route->is_master()) {
|
|
|
|
show_label = false;
|
|
|
|
}
|
2011-01-05 20:36:28 -05:00
|
|
|
|
2014-06-26 13:21:05 -04:00
|
|
|
if (number_label.get_parent()) {
|
2014-08-31 10:12:43 -04:00
|
|
|
controls_table.remove (number_label);
|
2014-06-26 13:21:05 -04:00
|
|
|
}
|
|
|
|
if (show_label) {
|
2014-08-31 10:12:43 -04:00
|
|
|
if (ARDOUR::Profile->get_mixbus()) {
|
2014-09-06 06:49:57 -04:00
|
|
|
controls_table.attach (number_label, 3, 4, 0, 1, Gtk::SHRINK, Gtk::EXPAND|Gtk::FILL, 1, 0);
|
2014-08-31 10:12:43 -04:00
|
|
|
} else {
|
2014-09-06 06:49:57 -04:00
|
|
|
controls_table.attach (number_label, 0, 1, 0, 1, Gtk::SHRINK, Gtk::EXPAND|Gtk::FILL, 1, 0);
|
2014-08-31 10:12:43 -04:00
|
|
|
}
|
2014-09-03 21:09:38 -04:00
|
|
|
// see ArdourButton::on_size_request(), we should probably use a global size-group here instead.
|
|
|
|
// except the width of the number label is subtracted from the name-hbox, so we
|
|
|
|
// need to explictly calculate it anyway until the name-label & entry become ArdourWidgets.
|
|
|
|
int tnw = (2 + std::max(2u, _session->track_number_decimals())) * number_label.char_pixel_width();
|
|
|
|
if (tnw & 1) --tnw;
|
2014-09-02 13:27:40 -04:00
|
|
|
number_label.set_size_request(tnw, -1);
|
2014-06-26 13:21:05 -04:00
|
|
|
number_label.show ();
|
|
|
|
} else {
|
|
|
|
number_label.hide ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::parameter_changed (string const & p)
|
|
|
|
{
|
|
|
|
if (p == "track-name-number") {
|
|
|
|
update_track_number_visibility();
|
2016-05-04 11:36:40 -04:00
|
|
|
} else if (p == "editor-stereo-only-meters") {
|
|
|
|
if (UIConfiguration::instance().get_editor_stereo_only_meters()) {
|
|
|
|
gm.get_level_meter().set_max_audio_meter_count (2);
|
|
|
|
} else {
|
|
|
|
gm.get_level_meter().set_max_audio_meter_count (0);
|
|
|
|
}
|
2014-06-26 13:21:05 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::take_name_changed (void *src)
|
|
|
|
{
|
|
|
|
if (src != this) {
|
|
|
|
label_view ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-18 04:42:43 -04:00
|
|
|
bool
|
|
|
|
RouteTimeAxisView::playlist_click (GdkEventButton *ev)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2016-08-18 04:42:43 -04:00
|
|
|
if (ev->button != 1) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-05-21 19:17:11 -04:00
|
|
|
build_playlist_menu ();
|
2008-04-11 10:06:50 -04:00
|
|
|
conditionally_add_to_selection ();
|
2016-08-18 04:42:43 -04:00
|
|
|
Gtkmm2ext::anchored_menu_popup(playlist_action_menu, &playlist_button,
|
|
|
|
"", 1, ev->time);
|
|
|
|
return true;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2016-08-18 04:42:43 -04:00
|
|
|
bool
|
|
|
|
RouteTimeAxisView::automation_click (GdkEventButton *ev)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2016-08-18 04:42:43 -04:00
|
|
|
if (ev->button != 1) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-04-11 10:06:50 -04:00
|
|
|
conditionally_add_to_selection ();
|
2011-03-07 08:04:36 -05:00
|
|
|
build_automation_action_menu (false);
|
2016-08-18 04:42:43 -04:00
|
|
|
Gtkmm2ext::anchored_menu_popup(automation_action_menu, &automation_button,
|
|
|
|
"", 1, ev->time);
|
2016-08-18 10:32:38 -04:00
|
|
|
return true;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
void
|
2011-03-07 08:04:36 -05:00
|
|
|
RouteTimeAxisView::build_automation_action_menu (bool for_selection)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
2010-05-25 19:39:44 -04:00
|
|
|
/* detach subplugin_menu from automation_action_menu before we delete automation_action_menu,
|
|
|
|
otherwise bad things happen (see comment for similar case in MidiTimeAxisView::build_automation_action_menu)
|
|
|
|
*/
|
|
|
|
|
|
|
|
detach_menu (subplugin_menu);
|
|
|
|
|
2010-06-08 17:48:38 -04:00
|
|
|
_main_automation_menu_map.clear ();
|
2010-01-08 21:36:47 -05:00
|
|
|
delete automation_action_menu;
|
|
|
|
automation_action_menu = new Menu;
|
2010-01-06 16:56:23 -05:00
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
MenuList& items = automation_action_menu->items();
|
2007-06-27 11:51:50 -04:00
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
automation_action_menu->set_name ("ArdourContextMenu");
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-03-23 09:11:14 -04:00
|
|
|
items.push_back (MenuElem (_("Show All Automation"),
|
2016-12-17 12:58:44 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_all_automation), for_selection)));
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-03-23 09:11:14 -04:00
|
|
|
items.push_back (MenuElem (_("Show Existing Automation"),
|
2016-12-17 12:58:44 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_existing_automation), for_selection)));
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-03-23 09:11:14 -04:00
|
|
|
items.push_back (MenuElem (_("Hide All Automation"),
|
2016-12-17 12:58:44 -05:00
|
|
|
sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::hide_all_automation), for_selection)));
|
2010-05-26 19:16:53 -04:00
|
|
|
|
2010-05-25 19:39:44 -04:00
|
|
|
/* Attach the plugin submenu. It may have previously been used elsewhere,
|
2015-10-04 14:51:05 -04:00
|
|
|
so it was detached above
|
2012-11-12 15:03:57 -05:00
|
|
|
*/
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2016-08-30 08:37:34 -04:00
|
|
|
bool single_track_selected = (!for_selection || _editor.get_selection().tracks.size() == 1);
|
|
|
|
|
2012-11-12 15:03:57 -05:00
|
|
|
if (!subplugin_menu.items().empty()) {
|
2013-03-30 09:23:12 -04:00
|
|
|
items.push_back (SeparatorElem ());
|
|
|
|
items.push_back (MenuElem (_("Processor automation"), subplugin_menu));
|
2016-08-30 08:37:34 -04:00
|
|
|
items.back().set_sensitive (single_track_selected);
|
2012-11-12 15:03:57 -05:00
|
|
|
}
|
2014-11-30 16:24:18 -05:00
|
|
|
|
|
|
|
/* Add any route automation */
|
|
|
|
|
|
|
|
if (gain_track) {
|
|
|
|
items.push_back (CheckMenuElem (_("Fader"), sigc::mem_fun (*this, &RouteTimeAxisView::update_gain_track_visibility)));
|
|
|
|
gain_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
|
2016-08-30 08:37:34 -04:00
|
|
|
gain_automation_item->set_active (single_track_selected &&
|
|
|
|
string_to<bool>(gain_track->gui_property ("visible")));
|
2014-11-30 16:24:18 -05:00
|
|
|
|
|
|
|
_main_automation_menu_map[Evoral::Parameter(GainAutomation)] = gain_automation_item;
|
|
|
|
}
|
|
|
|
|
2015-04-25 14:17:58 -04:00
|
|
|
if (trim_track) {
|
|
|
|
items.push_back (CheckMenuElem (_("Trim"), sigc::mem_fun (*this, &RouteTimeAxisView::update_trim_track_visibility)));
|
|
|
|
trim_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
|
2016-08-30 08:37:34 -04:00
|
|
|
trim_automation_item->set_active (single_track_selected &&
|
|
|
|
string_to<bool>(trim_track->gui_property ("visible")));
|
2015-04-25 14:17:58 -04:00
|
|
|
|
|
|
|
_main_automation_menu_map[Evoral::Parameter(TrimAutomation)] = trim_automation_item;
|
|
|
|
}
|
|
|
|
|
2014-11-30 16:24:18 -05:00
|
|
|
if (mute_track) {
|
|
|
|
items.push_back (CheckMenuElem (_("Mute"), sigc::mem_fun (*this, &RouteTimeAxisView::update_mute_track_visibility)));
|
|
|
|
mute_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
|
2016-08-30 08:37:34 -04:00
|
|
|
mute_automation_item->set_active (single_track_selected &&
|
|
|
|
string_to<bool>(mute_track->gui_property ("visible")));
|
2014-11-30 16:24:18 -05:00
|
|
|
|
|
|
|
_main_automation_menu_map[Evoral::Parameter(MuteAutomation)] = mute_automation_item;
|
|
|
|
}
|
|
|
|
|
2017-06-23 17:40:19 -04:00
|
|
|
if (!pan_tracks.empty() && !ARDOUR::Profile->get_mixbus()) {
|
2014-11-30 16:24:18 -05:00
|
|
|
items.push_back (CheckMenuElem (_("Pan"), sigc::mem_fun (*this, &RouteTimeAxisView::update_pan_track_visibility)));
|
|
|
|
pan_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
|
2016-08-30 08:37:34 -04:00
|
|
|
pan_automation_item->set_active (single_track_selected &&
|
|
|
|
string_to<bool>(pan_tracks.front()->gui_property ("visible")));
|
2014-11-30 16:24:18 -05:00
|
|
|
|
|
|
|
set<Evoral::Parameter> const & params = _route->pannable()->what_can_be_automated ();
|
|
|
|
for (set<Evoral::Parameter>::const_iterator p = params.begin(); p != params.end(); ++p) {
|
|
|
|
_main_automation_menu_map[*p] = pan_automation_item;
|
|
|
|
}
|
|
|
|
}
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::build_display_menu ()
|
|
|
|
{
|
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
|
|
|
/* prepare it */
|
|
|
|
|
|
|
|
TimeAxisView::build_display_menu ();
|
|
|
|
|
|
|
|
/* now fill it with our stuff */
|
|
|
|
|
|
|
|
MenuList& items = display_menu->items();
|
|
|
|
display_menu->set_name ("ArdourContextMenu");
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-02-22 20:03:51 -05:00
|
|
|
items.push_back (MenuElem (_("Color..."), sigc::mem_fun (*this, &RouteUI::choose_color)));
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2014-07-29 17:40:19 -04:00
|
|
|
items.push_back (MenuElem (_("Comments..."), sigc::mem_fun (*this, &RouteUI::open_comment_editor)));
|
|
|
|
|
2014-08-01 14:48:33 -04:00
|
|
|
items.push_back (MenuElem (_("Inputs..."), sigc::mem_fun (*this, &RouteUI::edit_input_configuration)));
|
|
|
|
|
|
|
|
items.push_back (MenuElem (_("Outputs..."), sigc::mem_fun (*this, &RouteUI::edit_output_configuration)));
|
|
|
|
|
|
|
|
items.push_back (SeparatorElem());
|
|
|
|
|
2011-02-22 20:05:15 -05:00
|
|
|
if (_size_menu) {
|
|
|
|
detach_menu (*_size_menu);
|
|
|
|
}
|
2011-02-16 12:59:28 -05:00
|
|
|
build_size_menu ();
|
|
|
|
items.push_back (MenuElem (_("Height"), *_size_menu));
|
2015-10-26 15:17:42 -04:00
|
|
|
items.push_back (SeparatorElem());
|
2006-07-29 23:25:38 -04:00
|
|
|
|
|
|
|
// Hook for derived classes to add type specific stuff
|
|
|
|
append_extra_display_menu_items ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
if (is_track()) {
|
|
|
|
|
2011-02-22 20:05:15 -05:00
|
|
|
Menu* layers_menu = manage (new Menu);
|
2007-07-14 21:56:11 -04:00
|
|
|
MenuList &layers_items = layers_menu->items();
|
|
|
|
layers_menu->set_name("ArdourContextMenu");
|
|
|
|
|
|
|
|
RadioMenuItem::Group layers_group;
|
|
|
|
|
2011-02-22 21:08:57 -05:00
|
|
|
/* Find out how many overlaid/stacked tracks we have in the selection */
|
|
|
|
|
|
|
|
int overlaid = 0;
|
|
|
|
int stacked = 0;
|
2017-01-29 09:02:07 -05:00
|
|
|
int unchangeable = 0;
|
2011-02-22 21:08:57 -05:00
|
|
|
TrackSelection const & s = _editor.get_selection().tracks;
|
2017-01-29 09:02:07 -05:00
|
|
|
|
2011-02-22 21:08:57 -05:00
|
|
|
for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) {
|
|
|
|
StreamView* v = (*i)->view ();
|
|
|
|
if (!v) {
|
|
|
|
continue;
|
|
|
|
}
|
2011-02-22 21:48:35 -05:00
|
|
|
|
2017-01-29 09:02:07 -05:00
|
|
|
if (v->can_change_layer_display()) {
|
|
|
|
switch (v->layer_display ()) {
|
|
|
|
case Overlaid:
|
|
|
|
++overlaid;
|
|
|
|
break;
|
|
|
|
case Stacked:
|
|
|
|
case Expanded:
|
|
|
|
++stacked;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
unchangeable++;
|
2011-02-22 21:08:57 -05:00
|
|
|
}
|
|
|
|
}
|
2011-02-22 20:44:50 -05:00
|
|
|
|
2011-02-22 21:08:57 -05:00
|
|
|
/* We're not connecting to signal_toggled() here; in the case where these two items are
|
|
|
|
set to be in the `inconsistent' state, it seems that one or other will end up active
|
|
|
|
as well as inconsistent (presumably due to the RadioMenuItem::Group). Then when you
|
|
|
|
select the active one, no toggled signal is emitted so nothing happens.
|
|
|
|
*/
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2012-06-13 16:37:07 -04:00
|
|
|
_ignore_set_layer_display = true;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-02-22 21:08:57 -05:00
|
|
|
layers_items.push_back (RadioMenuElem (layers_group, _("Overlaid")));
|
|
|
|
RadioMenuItem* i = dynamic_cast<RadioMenuItem*> (&layers_items.back ());
|
|
|
|
i->set_active (overlaid != 0 && stacked == 0);
|
|
|
|
i->set_inconsistent (overlaid != 0 && stacked != 0);
|
|
|
|
i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Overlaid, true));
|
|
|
|
|
2017-01-29 09:02:07 -05:00
|
|
|
if (unchangeable) {
|
|
|
|
i->set_sensitive (false);
|
|
|
|
}
|
|
|
|
|
2012-06-13 16:37:07 -04:00
|
|
|
layers_items.push_back (RadioMenuElem (layers_group, _("Stacked")));
|
2011-02-22 21:08:57 -05:00
|
|
|
i = dynamic_cast<RadioMenuItem*> (&layers_items.back ());
|
|
|
|
i->set_active (overlaid == 0 && stacked != 0);
|
|
|
|
i->set_inconsistent (overlaid != 0 && stacked != 0);
|
2012-06-13 16:37:07 -04:00
|
|
|
i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Stacked, true));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2017-01-29 09:02:07 -05:00
|
|
|
if (unchangeable) {
|
|
|
|
i->set_sensitive (false);
|
|
|
|
}
|
|
|
|
|
2012-06-13 16:37:07 -04:00
|
|
|
_ignore_set_layer_display = false;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2007-07-14 21:56:11 -04:00
|
|
|
items.push_back (MenuElem (_("Layers"), *layers_menu));
|
|
|
|
|
2015-10-26 15:17:42 -04:00
|
|
|
Menu* alignment_menu = manage (new Menu);
|
|
|
|
MenuList& alignment_items = alignment_menu->items();
|
|
|
|
alignment_menu->set_name ("ArdourContextMenu");
|
2010-03-23 09:11:14 -04:00
|
|
|
|
2015-10-26 15:17:42 -04:00
|
|
|
RadioMenuItem::Group align_group;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2015-10-26 15:17:42 -04:00
|
|
|
/* Same verbose hacks as for the layering options above */
|
2011-02-22 21:48:35 -05:00
|
|
|
|
2015-10-26 15:17:42 -04:00
|
|
|
int existing = 0;
|
|
|
|
int capture = 0;
|
|
|
|
int automatic = 0;
|
|
|
|
int styles = 0;
|
|
|
|
boost::shared_ptr<Track> first_track;
|
2011-02-22 21:48:35 -05:00
|
|
|
|
2015-10-27 09:27:28 -04:00
|
|
|
for (TrackSelection::const_iterator t = s.begin(); t != s.end(); ++t) {
|
|
|
|
RouteTimeAxisView* r = dynamic_cast<RouteTimeAxisView*> (*t);
|
2015-10-26 15:17:42 -04:00
|
|
|
if (!r || !r->is_track ()) {
|
|
|
|
continue;
|
|
|
|
}
|
2011-03-09 00:19:44 -05:00
|
|
|
|
2015-10-26 15:17:42 -04:00
|
|
|
if (!first_track) {
|
|
|
|
first_track = r->track();
|
2010-08-10 22:03:57 -04:00
|
|
|
}
|
2011-03-09 00:19:44 -05:00
|
|
|
|
2015-10-26 15:17:42 -04:00
|
|
|
switch (r->track()->alignment_choice()) {
|
|
|
|
case Automatic:
|
|
|
|
++automatic;
|
|
|
|
styles |= 0x1;
|
|
|
|
switch (r->track()->alignment_style()) {
|
|
|
|
case ExistingMaterial:
|
|
|
|
++existing;
|
|
|
|
break;
|
|
|
|
case CaptureTime:
|
|
|
|
++capture;
|
|
|
|
break;
|
2011-03-01 10:05:05 -05:00
|
|
|
}
|
2015-10-26 15:17:42 -04:00
|
|
|
break;
|
|
|
|
case UseExistingMaterial:
|
|
|
|
++existing;
|
|
|
|
styles |= 0x2;
|
|
|
|
break;
|
|
|
|
case UseCaptureTime:
|
|
|
|
++capture;
|
|
|
|
styles |= 0x4;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2015-10-26 15:17:42 -04:00
|
|
|
bool inconsistent;
|
|
|
|
switch (styles) {
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 4:
|
|
|
|
inconsistent = false;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
inconsistent = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!inconsistent && first_track) {
|
|
|
|
|
|
|
|
alignment_items.push_back (RadioMenuElem (align_group, _("Automatic (based on I/O connections)")));
|
|
|
|
i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
|
|
|
|
i->set_active (automatic != 0 && existing == 0 && capture == 0);
|
|
|
|
i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, Automatic, true));
|
|
|
|
|
|
|
|
switch (first_track->alignment_choice()) {
|
|
|
|
case Automatic:
|
|
|
|
switch (first_track->alignment_style()) {
|
|
|
|
case ExistingMaterial:
|
|
|
|
alignment_items.push_back (MenuElem (_("(Currently: Existing Material)")));
|
2011-03-01 10:05:05 -05:00
|
|
|
break;
|
2015-10-26 15:17:42 -04:00
|
|
|
case CaptureTime:
|
|
|
|
alignment_items.push_back (MenuElem (_("(Currently: Capture Time)")));
|
2011-03-01 10:05:05 -05:00
|
|
|
break;
|
|
|
|
}
|
2015-10-26 15:17:42 -04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
alignment_items.push_back (RadioMenuElem (align_group, _("Align With Existing Material")));
|
|
|
|
i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
|
|
|
|
i->set_active (existing != 0 && capture == 0 && automatic == 0);
|
|
|
|
i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, UseExistingMaterial, true));
|
|
|
|
|
|
|
|
alignment_items.push_back (RadioMenuElem (align_group, _("Align With Capture Time")));
|
|
|
|
i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
|
|
|
|
i->set_active (existing == 0 && capture != 0 && automatic == 0);
|
|
|
|
i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, UseCaptureTime, true));
|
|
|
|
|
|
|
|
items.push_back (MenuElem (_("Alignment"), *alignment_menu));
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* show nothing */
|
2019-03-07 10:40:16 -05:00
|
|
|
delete alignment_menu;
|
2015-10-26 15:17:42 -04:00
|
|
|
}
|
|
|
|
|
2008-01-10 16:20:59 -05:00
|
|
|
items.push_back (SeparatorElem());
|
2010-08-10 22:04:49 -04:00
|
|
|
|
|
|
|
build_playlist_menu ();
|
|
|
|
items.push_back (MenuElem (_("Playlist"), *playlist_action_menu));
|
2011-03-01 10:05:47 -05:00
|
|
|
items.back().set_sensitive (_editor.get_selection().tracks.size() <= 1);
|
2012-05-23 15:01:28 -04:00
|
|
|
}
|
2010-08-10 22:04:49 -04:00
|
|
|
|
2017-09-09 12:25:36 -04:00
|
|
|
if (!is_midi_track () && _route->the_instrument ()) {
|
|
|
|
/* MIDI Bus */
|
|
|
|
items.push_back (MenuElem (_("Patch Selector..."),
|
|
|
|
sigc::mem_fun(*this, &RouteUI::select_midi_patch)));
|
|
|
|
items.push_back (SeparatorElem());
|
|
|
|
}
|
|
|
|
|
2012-05-23 15:01:28 -04:00
|
|
|
route_group_menu->detach ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-05-23 15:01:28 -04:00
|
|
|
WeakRouteList r;
|
|
|
|
for (TrackSelection::iterator i = _editor.get_selection().tracks.begin(); i != _editor.get_selection().tracks.end(); ++i) {
|
|
|
|
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
|
|
|
|
if (rtv) {
|
|
|
|
r.push_back (rtv->route ());
|
2011-03-07 08:04:03 -05:00
|
|
|
}
|
2012-05-23 15:01:28 -04:00
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-05-23 15:01:28 -04:00
|
|
|
if (r.empty ()) {
|
|
|
|
r.push_back (route ());
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
2017-03-08 12:37:36 -05:00
|
|
|
if (!_route->is_master()) {
|
|
|
|
route_group_menu->build (r);
|
|
|
|
items.push_back (MenuElem (_("Group"), *route_group_menu->menu ()));
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-05-23 15:01:28 -04:00
|
|
|
build_automation_action_menu (true);
|
|
|
|
items.push_back (MenuElem (_("Automation"), *automation_action_menu));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-05-23 15:01:28 -04:00
|
|
|
items.push_back (SeparatorElem());
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-03-07 08:04:46 -05:00
|
|
|
int active = 0;
|
|
|
|
int inactive = 0;
|
|
|
|
TrackSelection const & s = _editor.get_selection().tracks;
|
|
|
|
for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) {
|
|
|
|
RouteTimeAxisView* r = dynamic_cast<RouteTimeAxisView*> (*i);
|
|
|
|
if (!r) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r->route()->active()) {
|
|
|
|
++active;
|
|
|
|
} else {
|
|
|
|
++inactive;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
items.push_back (CheckMenuElem (_("Active")));
|
2013-07-11 15:32:31 -04:00
|
|
|
Gtk::CheckMenuItem* i = dynamic_cast<Gtk::CheckMenuItem *> (&items.back());
|
2011-03-07 08:04:46 -05:00
|
|
|
bool click_sets_active = true;
|
|
|
|
if (active > 0 && inactive == 0) {
|
|
|
|
i->set_active (true);
|
|
|
|
click_sets_active = false;
|
|
|
|
} else if (active > 0 && inactive > 0) {
|
|
|
|
i->set_inconsistent (true);
|
|
|
|
}
|
2014-06-22 17:16:32 -04:00
|
|
|
i->set_sensitive(! _session->transport_rolling());
|
2011-03-07 08:04:46 -05:00
|
|
|
i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::set_route_active), click_sets_active, true));
|
2006-07-29 23:25:38 -04:00
|
|
|
|
|
|
|
items.push_back (SeparatorElem());
|
2011-03-07 08:05:45 -05:00
|
|
|
items.push_back (MenuElem (_("Hide"), sigc::bind (sigc::mem_fun(_editor, &PublicEditor::hide_track_in_display), this, true)));
|
2015-11-17 17:55:11 -05:00
|
|
|
if (_route && !_route->is_master()) {
|
|
|
|
items.push_back (SeparatorElem());
|
|
|
|
items.push_back (MenuElem (_("Duplicate..."), boost::bind (&ARDOUR_UI::start_duplicate_routes, ARDOUR_UI::instance())));
|
|
|
|
}
|
|
|
|
items.push_back (SeparatorElem());
|
|
|
|
items.push_back (MenuElem (_("Remove"), sigc::mem_fun(_editor, &PublicEditor::remove_tracks)));
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
void
|
2017-09-18 12:39:17 -04:00
|
|
|
RouteTimeAxisView::show_timestretch (samplepos_t start, samplepos_t end, int layers, int layer)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2012-05-27 16:07:13 -04:00
|
|
|
TimeAxisView::show_timestretch (start, end, layers, layer);
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
hide_timestretch ();
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
#if 0
|
2006-07-23 08:03:19 -04:00
|
|
|
if (ts.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
/* check that the time selection was made in our route, or our route group.
|
|
|
|
remember that route_group() == 0 implies the route is *not* in a edit group.
|
2006-07-23 08:03:19 -04:00
|
|
|
*/
|
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
if (!(ts.track == this || (ts.group != 0 && ts.group == _route->route_group()))) {
|
2006-07-23 08:03:19 -04:00
|
|
|
/* this doesn't apply to us */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ignore it if our edit group is not active */
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
if ((ts.track != this) && _route->route_group() && !_route->route_group()->is_active()) {
|
2006-07-23 08:03:19 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (timestretch_rect == 0) {
|
2013-04-04 00:32:52 -04:00
|
|
|
timestretch_rect = new ArdourCanvas::Rectangle (canvas_display ());
|
2017-07-17 12:34:35 -04:00
|
|
|
timestretch_rect->set_fill_color (Gtkmm2ext::HSV (UIConfiguration::instance().color ("time stretch fill")).mod (UIConfiguration::instance().modifier ("time stretch fill")).color());
|
2015-01-02 09:44:54 -05:00
|
|
|
timestretch_rect->set_outline_color (UIConfiguration::instance().color ("time stretch outline"));
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
timestretch_rect->show ();
|
|
|
|
timestretch_rect->raise_to_top ();
|
|
|
|
|
2012-05-27 16:07:13 -04:00
|
|
|
double const x1 = start / _editor.get_current_zoom();
|
|
|
|
double const x2 = (end - 1) / _editor.get_current_zoom();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2013-04-04 00:32:52 -04:00
|
|
|
timestretch_rect->set (ArdourCanvas::Rect (x1, current_height() * (layers - layer - 1) / layers,
|
|
|
|
x2, current_height() * (layers - layer) / layers));
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::hide_timestretch ()
|
|
|
|
{
|
|
|
|
TimeAxisView::hide_timestretch ();
|
|
|
|
|
|
|
|
if (timestretch_rect) {
|
|
|
|
timestretch_rect->hide ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::show_selection (TimeSelection& ts)
|
|
|
|
{
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/* ignore it if our edit group is not active or if the selection was started
|
2009-06-21 15:59:56 -04:00
|
|
|
in some other track or route group (remember that route_group() == 0 means
|
|
|
|
that the track is not in an route group).
|
2006-07-23 08:03:19 -04:00
|
|
|
*/
|
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
if (((ts.track != this && !is_child (ts.track)) && _route->route_group() && !_route->route_group()->is_active()) ||
|
|
|
|
(!(ts.track == this || is_child (ts.track) || (ts.group != 0 && ts.group == _route->route_group())))) {
|
2006-07-23 08:03:19 -04:00
|
|
|
hide_selection ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
TimeAxisView::show_selection (ts);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-03-19 16:47:34 -04:00
|
|
|
RouteTimeAxisView::set_height (uint32_t h, TrackHeightMode m)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2013-07-03 01:36:15 -04:00
|
|
|
int gmlen = h - 9;
|
2008-09-10 11:03:30 -04:00
|
|
|
bool height_changed = (height == 0) || (h != height);
|
2013-07-02 16:58:24 -04:00
|
|
|
|
|
|
|
int meter_width = 3;
|
|
|
|
if (_route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
|
|
|
|
meter_width = 6;
|
|
|
|
}
|
|
|
|
gm.get_level_meter().setup_meters (gmlen, meter_width);
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2015-03-19 16:47:34 -04:00
|
|
|
TimeAxisView::set_height (h, m);
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
if (_view) {
|
2008-09-10 11:03:30 -04:00
|
|
|
_view->set_height ((double) current_height());
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-05-10 20:09:41 -04:00
|
|
|
if (height >= preset_height (HeightNormal)) {
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2007-12-20 18:25:19 -05:00
|
|
|
reset_meter();
|
2006-08-09 21:22:45 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
gm.get_gain_slider().show();
|
2006-09-18 23:29:16 -04:00
|
|
|
mute_button->show();
|
2010-03-23 08:19:21 -04:00
|
|
|
if (!_route || _route->is_monitor()) {
|
2009-06-11 09:22:42 -04:00
|
|
|
solo_button->hide();
|
|
|
|
} else {
|
|
|
|
solo_button->show();
|
|
|
|
}
|
2006-08-09 21:22:45 -04:00
|
|
|
if (rec_enable_button)
|
2006-09-18 23:29:16 -04:00
|
|
|
rec_enable_button->show();
|
2006-08-09 21:22:45 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
route_group_button.show();
|
2006-09-18 23:29:16 -04:00
|
|
|
automation_button.show();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2006-08-09 21:22:45 -04:00
|
|
|
if (is_track() && track()->mode() == ARDOUR::Normal) {
|
2006-09-18 23:29:16 -04:00
|
|
|
playlist_button.show();
|
2006-08-09 21:22:45 -04:00
|
|
|
}
|
|
|
|
|
2011-06-01 20:06:35 -04:00
|
|
|
} else {
|
2011-05-04 08:26:32 -04:00
|
|
|
|
2007-12-20 18:25:19 -05:00
|
|
|
reset_meter();
|
2006-08-09 21:22:45 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
gm.get_gain_slider().hide();
|
2006-09-18 23:29:16 -04:00
|
|
|
mute_button->show();
|
2010-03-23 08:19:21 -04:00
|
|
|
if (!_route || _route->is_monitor()) {
|
2009-06-11 09:22:42 -04:00
|
|
|
solo_button->hide();
|
|
|
|
} else {
|
|
|
|
solo_button->show();
|
|
|
|
}
|
2006-08-09 21:22:45 -04:00
|
|
|
if (rec_enable_button)
|
2006-09-18 23:29:16 -04:00
|
|
|
rec_enable_button->show();
|
2006-08-09 21:22:45 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
route_group_button.hide ();
|
2006-07-23 08:03:19 -04:00
|
|
|
automation_button.hide ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2006-08-09 21:22:45 -04:00
|
|
|
if (is_track() && track()->mode() == ARDOUR::Normal) {
|
|
|
|
playlist_button.hide ();
|
|
|
|
}
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2010-01-10 13:11:02 -05:00
|
|
|
if (height_changed && !no_redraw) {
|
2006-07-23 08:03:19 -04:00
|
|
|
/* only emit the signal if the height really changed */
|
2011-07-06 20:37:13 -04:00
|
|
|
request_redraw ();
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-08-30 11:44:00 -04:00
|
|
|
RouteTimeAxisView::route_color_changed ()
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2017-07-15 11:38:28 -04:00
|
|
|
using namespace ARDOUR_UI_UTILS;
|
2011-02-22 20:03:37 -05:00
|
|
|
if (_view) {
|
2011-08-31 15:14:12 -04:00
|
|
|
_view->apply_color (color(), StreamView::RegionColor);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
2014-07-29 17:40:19 -04:00
|
|
|
number_label.set_fixed_colors (gdk_color_to_rgba (color()), gdk_color_to_rgba (color()));
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2013-04-12 11:31:50 -04:00
|
|
|
RouteTimeAxisView::set_samples_per_pixel (double fpp)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
|
|
|
if (_view) {
|
2017-04-17 06:12:49 -04:00
|
|
|
_view->set_samples_per_pixel (fpp);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2017-04-17 06:12:49 -04:00
|
|
|
StripableTimeAxisView::set_samples_per_pixel (fpp);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-03-09 00:19:44 -05:00
|
|
|
RouteTimeAxisView::set_align_choice (RadioMenuItem* mitem, AlignChoice choice, bool apply_to_selection)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2017-06-23 17:42:42 -04:00
|
|
|
if (!mitem->get_active()) {
|
|
|
|
/* this is one of the two calls made when these radio menu items change status. this one
|
|
|
|
is for the item that became inactive, and we want to ignore it.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
2011-03-09 00:19:44 -05:00
|
|
|
|
2011-02-22 21:48:35 -05:00
|
|
|
if (apply_to_selection) {
|
2011-03-09 00:19:44 -05:00
|
|
|
_editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_align_choice, _1, mitem, choice, false));
|
2011-02-22 21:48:35 -05:00
|
|
|
} else {
|
2011-02-23 19:05:28 -05:00
|
|
|
if (track ()) {
|
2011-03-09 00:19:44 -05:00
|
|
|
track()->set_align_choice (choice);
|
2011-02-23 19:05:28 -05:00
|
|
|
}
|
2006-11-19 11:45:16 -05:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::rename_current_playlist ()
|
|
|
|
{
|
2017-07-16 23:18:48 -04:00
|
|
|
Prompter prompter (true);
|
2006-07-23 08:03:19 -04:00
|
|
|
string name;
|
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Track> tr = track();
|
|
|
|
if (!tr || tr->destructive()) {
|
2006-07-23 08:03:19 -04:00
|
|
|
return;
|
2010-04-21 16:42:22 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Playlist> pl = tr->playlist();
|
|
|
|
if (!pl) {
|
2006-07-23 08:03:19 -04:00
|
|
|
return;
|
2010-04-21 16:42:22 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-04-25 15:38:04 -04:00
|
|
|
prompter.set_title (_("Rename Playlist"));
|
|
|
|
prompter.set_prompt (_("New name for playlist:"));
|
2006-07-23 08:03:19 -04:00
|
|
|
prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
|
2016-11-24 16:11:19 -05:00
|
|
|
prompter.set_initial_text (pl->name());
|
2006-07-23 08:03:19 -04:00
|
|
|
prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
|
|
|
|
|
2016-11-24 16:11:19 -05:00
|
|
|
while (true) {
|
|
|
|
if (prompter.run () != Gtk::RESPONSE_ACCEPT) {
|
|
|
|
break;
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
prompter.get_result (name);
|
|
|
|
if (name.length()) {
|
2019-03-19 00:14:40 -04:00
|
|
|
if (_session->playlists()->by_name (name)) {
|
2016-11-24 16:11:19 -05:00
|
|
|
MessageDialog msg (_("Given playlist name is not unique."));
|
|
|
|
msg.run ();
|
|
|
|
prompter.set_initial_text (Playlist::bump_name (name, *_session));
|
|
|
|
} else {
|
|
|
|
pl->set_name (name);
|
|
|
|
break;
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
std::string
|
2008-10-06 14:04:12 -04:00
|
|
|
RouteTimeAxisView::resolve_new_group_playlist_name(std::string &basename, vector<boost::shared_ptr<Playlist> > const & playlists)
|
|
|
|
{
|
2009-06-21 15:59:56 -04:00
|
|
|
std::string ret (basename);
|
2008-10-06 14:04:12 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
std::string const group_string = "." + route_group()->name() + ".";
|
2008-10-06 14:04:12 -04:00
|
|
|
|
2008-12-08 13:16:12 -05:00
|
|
|
// iterate through all playlists
|
|
|
|
int maxnumber = 0;
|
|
|
|
for (vector<boost::shared_ptr<Playlist> >::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
|
|
|
|
std::string tmp = (*i)->name();
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
std::string::size_type idx = tmp.find(group_string);
|
2008-12-08 13:16:12 -05:00
|
|
|
// find those which belong to this group
|
|
|
|
if (idx != string::npos) {
|
|
|
|
tmp = tmp.substr(idx + group_string.length());
|
|
|
|
|
|
|
|
// and find the largest current number
|
2013-06-08 03:03:26 -04:00
|
|
|
int x = atoi(tmp);
|
2008-12-08 13:16:12 -05:00
|
|
|
if (x > maxnumber) {
|
|
|
|
maxnumber = x;
|
2008-10-06 14:04:12 -04:00
|
|
|
}
|
|
|
|
}
|
2008-12-08 13:16:12 -05:00
|
|
|
}
|
2008-10-06 14:04:12 -04:00
|
|
|
|
2008-12-08 13:16:12 -05:00
|
|
|
maxnumber++;
|
2008-10-06 14:04:12 -04:00
|
|
|
|
2008-12-08 13:16:12 -05:00
|
|
|
char buf[32];
|
|
|
|
snprintf (buf, sizeof(buf), "%d", maxnumber);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
ret = this->name() + "." + route_group()->name () + "." + buf;
|
2008-10-06 14:04:12 -04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
void
|
2016-11-25 08:24:15 -05:00
|
|
|
RouteTimeAxisView::use_new_playlist (bool prompt, vector<boost::shared_ptr<Playlist> > const & playlists_before_op, bool copy)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
|
|
|
string name;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Track> tr = track ();
|
|
|
|
if (!tr || tr->destructive()) {
|
2006-07-23 08:03:19 -04:00
|
|
|
return;
|
2010-04-21 16:42:22 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<const Playlist> pl = tr->playlist();
|
|
|
|
if (!pl) {
|
2006-07-23 08:03:19 -04:00
|
|
|
return;
|
2010-04-21 16:42:22 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
name = pl->name();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2016-06-05 15:54:37 -04:00
|
|
|
if (route_group() && route_group()->is_active() && route_group()->enabled_property (ARDOUR::Properties::group_select.property_id)) {
|
2016-11-25 08:24:15 -05:00
|
|
|
name = resolve_new_group_playlist_name(name,playlists_before_op);
|
2008-10-06 14:04:12 -04:00
|
|
|
}
|
2007-01-09 18:24:54 -05:00
|
|
|
|
2019-03-19 00:14:40 -04:00
|
|
|
while (_session->playlists()->by_name(name)) {
|
2009-12-17 13:24:23 -05:00
|
|
|
name = Playlist::bump_name (name, *_session);
|
2008-10-06 14:04:12 -04:00
|
|
|
}
|
2007-01-09 18:24:54 -05:00
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
if (prompt) {
|
2016-11-25 08:24:15 -05:00
|
|
|
// TODO: The prompter "new" button should be de-activated if the user
|
|
|
|
// specifies a playlist name which already exists in the session.
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2017-07-16 23:18:48 -04:00
|
|
|
Prompter prompter (true);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2016-11-25 08:24:15 -05:00
|
|
|
if (copy) {
|
|
|
|
prompter.set_title (_("New Copy Playlist"));
|
|
|
|
prompter.set_prompt (_("Name for playlist copy:"));
|
|
|
|
} else {
|
|
|
|
prompter.set_title (_("New Playlist"));
|
|
|
|
prompter.set_prompt (_("Name for new playlist:"));
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
prompter.set_initial_text (name);
|
|
|
|
prompter.add_button (Gtk::Stock::NEW, Gtk::RESPONSE_ACCEPT);
|
2007-01-09 18:24:54 -05:00
|
|
|
prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, true);
|
2006-07-23 08:03:19 -04:00
|
|
|
prompter.show_all ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2016-11-25 08:24:15 -05:00
|
|
|
while (true) {
|
|
|
|
if (prompter.run () != Gtk::RESPONSE_ACCEPT) {
|
|
|
|
return;
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
prompter.get_result (name);
|
2016-11-25 08:24:15 -05:00
|
|
|
if (name.length()) {
|
2019-03-19 00:14:40 -04:00
|
|
|
if (_session->playlists()->by_name (name)) {
|
2016-11-25 08:24:15 -05:00
|
|
|
MessageDialog msg (_("Given playlist name is not unique."));
|
|
|
|
msg.run ();
|
|
|
|
prompter.set_initial_text (Playlist::bump_name (name, *_session));
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (name.length()) {
|
2016-11-25 08:24:15 -05:00
|
|
|
if (copy) {
|
|
|
|
tr->use_copy_playlist ();
|
2016-11-27 19:59:32 -05:00
|
|
|
} else {
|
2017-07-25 11:27:18 -04:00
|
|
|
tr->use_default_new_playlist ();
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
2010-04-21 16:42:22 -04:00
|
|
|
tr->playlist()->set_name (name);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::clear_playlist ()
|
|
|
|
{
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Track> tr = track ();
|
|
|
|
if (!tr || tr->destructive()) {
|
2006-07-23 08:03:19 -04:00
|
|
|
return;
|
2010-04-21 16:42:22 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Playlist> pl = tr->playlist();
|
|
|
|
if (!pl) {
|
2006-07-23 08:03:19 -04:00
|
|
|
return;
|
2010-04-21 16:42:22 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2009-01-01 19:17:55 -05:00
|
|
|
_editor.clear_playlist (pl);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::speed_changed ()
|
|
|
|
{
|
2013-04-12 11:31:50 -04:00
|
|
|
Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&RouteTimeAxisView::reset_samples_per_pixel, this));
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::update_diskstream_display ()
|
|
|
|
{
|
2010-04-21 16:42:22 -04:00
|
|
|
if (!track()) {
|
2006-07-23 08:03:19 -04:00
|
|
|
return;
|
2010-04-21 16:42:22 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
map_frozen ();
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::selection_click (GdkEventButton* ev)
|
|
|
|
{
|
2008-01-10 16:20:59 -05:00
|
|
|
if (Keyboard::modifier_state_equals (ev->state, (Keyboard::TertiaryModifier|Keyboard::PrimaryModifier))) {
|
2007-03-18 02:07:08 -04:00
|
|
|
|
|
|
|
/* special case: select/deselect all tracks */
|
2015-01-13 05:41:30 -05:00
|
|
|
|
|
|
|
_editor.begin_reversible_selection_op (X_("Selection Click"));
|
|
|
|
|
2009-07-09 13:58:13 -04:00
|
|
|
if (_editor.get_selection().selected (this)) {
|
2009-01-01 19:17:55 -05:00
|
|
|
_editor.get_selection().clear_tracks ();
|
2007-03-18 02:07:08 -04:00
|
|
|
} else {
|
2009-01-01 19:17:55 -05:00
|
|
|
_editor.select_all_tracks ();
|
2007-03-18 02:07:08 -04:00
|
|
|
}
|
|
|
|
|
2015-01-13 05:41:30 -05:00
|
|
|
_editor.commit_reversible_selection_op ();
|
|
|
|
|
2007-03-18 02:07:08 -04:00
|
|
|
return;
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2007-03-18 02:07:08 -04:00
|
|
|
|
2015-01-13 05:41:30 -05:00
|
|
|
_editor.begin_reversible_selection_op (X_("Selection Click"));
|
|
|
|
|
2009-12-04 17:51:32 -05:00
|
|
|
switch (ArdourKeyboard::selection_type (ev->state)) {
|
2006-07-23 08:03:19 -04:00
|
|
|
case Selection::Toggle:
|
2009-12-13 14:09:52 -05:00
|
|
|
_editor.get_selection().toggle (this);
|
2006-07-23 08:03:19 -04:00
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
case Selection::Set:
|
2009-12-13 14:09:52 -05:00
|
|
|
_editor.get_selection().set (this);
|
2006-07-23 08:03:19 -04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Selection::Extend:
|
2009-12-13 14:09:52 -05:00
|
|
|
_editor.extend_selection_to_track (*this);
|
2006-07-23 08:03:19 -04:00
|
|
|
break;
|
2006-11-19 11:45:16 -05:00
|
|
|
|
|
|
|
case Selection::Add:
|
2009-12-13 14:09:52 -05:00
|
|
|
_editor.get_selection().add (this);
|
2006-11-19 11:45:16 -05:00
|
|
|
break;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
2015-01-13 05:41:30 -05:00
|
|
|
|
|
|
|
_editor.commit_reversible_selection_op ();
|
2017-07-20 11:31:36 -04:00
|
|
|
|
|
|
|
_editor.set_selected_mixer_strip (*this);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::set_selected_points (PointSelection& points)
|
|
|
|
{
|
2017-07-07 08:47:36 -04:00
|
|
|
StripableTimeAxisView::set_selected_points (points);
|
2015-06-20 15:27:45 -04:00
|
|
|
AudioStreamView* asv = dynamic_cast<AudioStreamView*>(_view);
|
|
|
|
if (asv) {
|
|
|
|
asv->set_selected_points (points);
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::set_selected_regionviews (RegionSelection& regions)
|
|
|
|
{
|
2007-01-09 18:24:54 -05:00
|
|
|
if (_view) {
|
|
|
|
_view->set_selected_regionviews (regions);
|
|
|
|
}
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
2007-05-10 07:53:35 -04:00
|
|
|
/** Add the selectable things that we have to a list.
|
|
|
|
* @param results List to add things to.
|
|
|
|
*/
|
2006-07-23 08:03:19 -04:00
|
|
|
void
|
2017-09-18 12:39:17 -04:00
|
|
|
RouteTimeAxisView::get_selectables (samplepos_t start, samplepos_t end, double top, double bot, list<Selectable*>& results, bool within)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2008-05-02 14:35:05 -04:00
|
|
|
if ((_view && ((top < 0.0 && bot < 0.0))) || touched (top, bot)) {
|
2017-04-17 06:12:49 -04:00
|
|
|
_view->get_selectables (start, end, top, bot, results, within);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* pick up visible automation tracks */
|
2017-04-17 06:12:49 -04:00
|
|
|
for (Children::iterator i = children.begin(); i != children.end(); ++i) {
|
|
|
|
if (!(*i)->hidden()) {
|
|
|
|
(*i)->get_selectables (start, end, top, bot, results, within);
|
|
|
|
}
|
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::get_inverted_selectables (Selection& sel, list<Selectable*>& results)
|
|
|
|
{
|
|
|
|
if (_view) {
|
|
|
|
_view->get_inverted_selectables (sel, results);
|
|
|
|
}
|
2017-07-07 08:47:36 -04:00
|
|
|
StripableTimeAxisView::get_inverted_selectables (sel, results);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RouteGroup*
|
2009-06-21 15:59:56 -04:00
|
|
|
RouteTimeAxisView::route_group () const
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2009-06-21 15:59:56 -04:00
|
|
|
return _route->route_group();
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
boost::shared_ptr<Playlist>
|
2009-10-14 12:10:01 -04:00
|
|
|
RouteTimeAxisView::playlist () const
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Track> tr;
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
if ((tr = track()) != 0) {
|
|
|
|
return tr->playlist();
|
2006-07-23 08:03:19 -04:00
|
|
|
} else {
|
2007-01-09 18:24:54 -05:00
|
|
|
return boost::shared_ptr<Playlist> ();
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-21 19:17:11 -04:00
|
|
|
bool
|
|
|
|
RouteTimeAxisView::name_entry_changed (string const& str)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2016-05-21 19:17:11 -04:00
|
|
|
if (str == _route->name()) {
|
|
|
|
return true;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2016-05-21 19:17:11 -04:00
|
|
|
string x = str;
|
2016-12-17 12:58:44 -05:00
|
|
|
|
2011-08-03 09:28:54 -04:00
|
|
|
strip_whitespace_edges (x);
|
2007-01-09 18:24:54 -05:00
|
|
|
|
2016-05-21 19:17:11 -04:00
|
|
|
if (x.empty()) {
|
|
|
|
return false;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2011-08-03 09:28:54 -04:00
|
|
|
if (_session->route_name_internal (x)) {
|
2016-05-21 19:17:11 -04:00
|
|
|
ARDOUR_UI::instance()->popup_error (string_compose (_("The name \"%1\" is reserved for %2"), x, PROGRAM_NAME));
|
|
|
|
return false;
|
2011-08-03 09:28:54 -04:00
|
|
|
} else if (RouteUI::verify_new_route_name (x)) {
|
|
|
|
_route->set_name (x);
|
2016-05-21 19:17:11 -04:00
|
|
|
return true;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
2016-05-21 19:17:11 -04:00
|
|
|
|
|
|
|
return false;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2006-08-29 17:21:48 -04:00
|
|
|
boost::shared_ptr<Region>
|
2017-09-18 12:39:17 -04:00
|
|
|
RouteTimeAxisView::find_next_region (samplepos_t pos, RegionPoint point, int32_t dir)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Playlist> pl = playlist ();
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
if (pl) {
|
|
|
|
return pl->find_next_region (pos, point, dir);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2006-08-29 17:21:48 -04:00
|
|
|
return boost::shared_ptr<Region> ();
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
samplepos_t
|
|
|
|
RouteTimeAxisView::find_next_region_boundary (samplepos_t pos, int32_t dir)
|
2008-01-10 16:20:59 -05:00
|
|
|
{
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Playlist> pl = playlist ();
|
2008-01-10 16:20:59 -05:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
if (pl) {
|
|
|
|
return pl->find_next_region_boundary (pos, dir);
|
2008-01-10 16:20:59 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-07-10 08:17:22 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::fade_range (TimeSelection& selection)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<Playlist> what_we_got;
|
|
|
|
boost::shared_ptr<Track> tr = track ();
|
|
|
|
boost::shared_ptr<Playlist> playlist;
|
|
|
|
|
|
|
|
if (tr == 0) {
|
|
|
|
/* route is a bus, not a track */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
playlist = tr->playlist();
|
|
|
|
|
|
|
|
TimeSelection time (selection);
|
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
playlist->clear_changes ();
|
|
|
|
playlist->clear_owned_changes ();
|
2014-07-10 08:17:22 -04:00
|
|
|
|
|
|
|
playlist->fade_range (time);
|
|
|
|
|
|
|
|
vector<Command*> cmds;
|
|
|
|
playlist->rdiff (cmds);
|
|
|
|
_session->add_commands (cmds);
|
|
|
|
_session->add_command (new StatefulDiffCommand (playlist));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2010-08-05 09:35:43 -04:00
|
|
|
void
|
2006-07-23 08:03:19 -04:00
|
|
|
RouteTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op)
|
|
|
|
{
|
2007-01-09 18:24:54 -05:00
|
|
|
boost::shared_ptr<Playlist> what_we_got;
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Track> tr = track ();
|
2007-01-09 18:24:54 -05:00
|
|
|
boost::shared_ptr<Playlist> playlist;
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
if (tr == 0) {
|
2006-07-23 08:03:19 -04:00
|
|
|
/* route is a bus, not a track */
|
2010-08-05 09:35:43 -04:00
|
|
|
return;
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
playlist = tr->playlist();
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
TimeSelection time (selection.time);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
playlist->clear_changes ();
|
|
|
|
playlist->clear_owned_changes ();
|
2010-03-04 08:15:04 -05:00
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
switch (op) {
|
2011-06-12 11:50:47 -04:00
|
|
|
case Delete:
|
|
|
|
if (playlist->cut (time) != 0) {
|
2017-06-23 17:42:42 -04:00
|
|
|
if (Config->get_edit_mode() == Ripple) {
|
2014-05-16 15:04:57 -04:00
|
|
|
playlist->ripple(time.start(), -time.length(), NULL);
|
2017-06-23 17:42:42 -04:00
|
|
|
}
|
|
|
|
// no need to exclude any regions from rippling here
|
2014-05-15 19:51:54 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
vector<Command*> cmds;
|
|
|
|
playlist->rdiff (cmds);
|
|
|
|
_session->add_commands (cmds);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
_session->add_command (new StatefulDiffCommand (playlist));
|
2011-06-12 11:50:47 -04:00
|
|
|
}
|
|
|
|
break;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
case Cut:
|
|
|
|
if ((what_we_got = playlist->cut (time)) != 0) {
|
2009-01-01 19:17:55 -05:00
|
|
|
_editor.get_cut_buffer().add (what_we_got);
|
2017-06-23 17:42:42 -04:00
|
|
|
if (Config->get_edit_mode() == Ripple) {
|
2014-05-16 15:04:57 -04:00
|
|
|
playlist->ripple(time.start(), -time.length(), NULL);
|
2017-06-23 17:42:42 -04:00
|
|
|
}
|
|
|
|
// no need to exclude any regions from rippling here
|
2014-05-15 19:51:54 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
vector<Command*> cmds;
|
|
|
|
playlist->rdiff (cmds);
|
|
|
|
_session->add_commands (cmds);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
_session->add_command (new StatefulDiffCommand (playlist));
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Copy:
|
|
|
|
if ((what_we_got = playlist->copy (time)) != 0) {
|
2009-01-01 19:17:55 -05:00
|
|
|
_editor.get_cut_buffer().add (what_we_got);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Clear:
|
|
|
|
if ((what_we_got = playlist->cut (time)) != 0) {
|
2017-06-23 17:42:42 -04:00
|
|
|
if (Config->get_edit_mode() == Ripple) {
|
2014-05-16 15:04:57 -04:00
|
|
|
playlist->ripple(time.start(), -time.length(), NULL);
|
2017-06-23 17:42:42 -04:00
|
|
|
}
|
|
|
|
// no need to exclude any regions from rippling here
|
2010-08-25 21:44:11 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
vector<Command*> cmds;
|
|
|
|
playlist->rdiff (cmds);
|
2010-08-25 21:44:11 -04:00
|
|
|
_session->add_commands (cmds);
|
2017-06-23 17:42:42 -04:00
|
|
|
_session->add_command (new StatefulDiffCommand (playlist));
|
2007-01-09 18:24:54 -05:00
|
|
|
what_we_got->release ();
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2017-09-18 12:39:17 -04:00
|
|
|
RouteTimeAxisView::paste (samplepos_t pos, const Selection& selection, PasteContext& ctx, const int32_t sub_num)
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
|
|
|
if (!is_track()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-11-16 17:04:27 -05:00
|
|
|
boost::shared_ptr<Playlist> pl = playlist ();
|
|
|
|
const ARDOUR::DataType type = pl->data_type();
|
2014-12-06 12:20:52 -05:00
|
|
|
PlaylistSelection::const_iterator p = selection.playlists.get_nth(type, ctx.counts.n_playlists(type));
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
if (p == selection.playlists.end()) {
|
|
|
|
return false;
|
|
|
|
}
|
2014-12-06 12:20:52 -05:00
|
|
|
ctx.counts.increase_n_playlists(type);
|
2006-07-23 08:03:19 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("paste to %1\n", pos));
|
2011-02-20 21:58:16 -05:00
|
|
|
|
2014-11-14 20:04:09 -05:00
|
|
|
/* add multi-paste offset if applicable */
|
2019-04-08 15:37:02 -04:00
|
|
|
std::pair<samplepos_t, samplepos_t> extent = (*p)->get_extent();
|
2017-09-18 12:39:17 -04:00
|
|
|
const samplecnt_t duration = extent.second - extent.first;
|
2014-12-06 12:20:52 -05:00
|
|
|
pos += _editor.get_paste_offset(pos, ctx.count, duration);
|
2014-11-14 20:04:09 -05:00
|
|
|
|
2015-05-28 08:41:17 -04:00
|
|
|
pl->clear_changes ();
|
2015-05-28 07:18:59 -04:00
|
|
|
pl->clear_owned_changes ();
|
Ripple mode: basic implementation
Add a value for Ripple to EditMode enum.
Add Ripple edit mode to edit mode dropdown, by adding it to the
Editor::build_edit_mode_menu() helper function, and remove the old code that
added items to the (now unused) Editor::edit_mode_strings.
Add the regions that should be affected by the drag to RegionDrag::_views so
that the drag carries them along automatically.
Use a copy of the RegionList in Playlist::core_ripple(), since bad things
happen when iterating over regions and they get moved around in the list.
Handle rippling in removal of regions from playlist.
When dragging in ripple mode, exclude all regions that lie before the
original start position of the selected regions being dragged from
rippling: this is what Mixbus does.
Make editor dragging respect snap-to settings, by using the existing
compute_x_delta() function, which did almost the right thing. Move setting
of _last_frame_position out of that function so all ripple-dragged regions
can move.
Ripple when dragging from region list: even though Mixbus doesn't do this, it
seems like a good idea.
Prevent multi-track selection being dragged across tracks, by making
RegionMotionDrag::y_movement_allowed() virtual, and overriding it in
RegionRippleDrag to forbid dragging of selections containing regions on more
than one track to dofferent tracks in ripple mode.
Remember which TimeAxisView a ripple-mode drag that's allowed cross-track
drags started from, so that the effect of rippling regions after any region
that's dragged off that track can be undone.
2013-10-23 16:50:01 -04:00
|
|
|
if (Config->get_edit_mode() == Ripple) {
|
2017-09-18 12:39:17 -04:00
|
|
|
std::pair<samplepos_t, samplepos_t> extent = (*p)->get_extent_with_endspace();
|
|
|
|
samplecnt_t amount = extent.second - extent.first;
|
2014-12-06 12:20:52 -05:00
|
|
|
pl->ripple(pos, amount * ctx.times, boost::shared_ptr<Region>());
|
Ripple mode: basic implementation
Add a value for Ripple to EditMode enum.
Add Ripple edit mode to edit mode dropdown, by adding it to the
Editor::build_edit_mode_menu() helper function, and remove the old code that
added items to the (now unused) Editor::edit_mode_strings.
Add the regions that should be affected by the drag to RegionDrag::_views so
that the drag carries them along automatically.
Use a copy of the RegionList in Playlist::core_ripple(), since bad things
happen when iterating over regions and they get moved around in the list.
Handle rippling in removal of regions from playlist.
When dragging in ripple mode, exclude all regions that lie before the
original start position of the selected regions being dragged from
rippling: this is what Mixbus does.
Make editor dragging respect snap-to settings, by using the existing
compute_x_delta() function, which did almost the right thing. Move setting
of _last_frame_position out of that function so all ripple-dragged regions
can move.
Ripple when dragging from region list: even though Mixbus doesn't do this, it
seems like a good idea.
Prevent multi-track selection being dragged across tracks, by making
RegionMotionDrag::y_movement_allowed() virtual, and overriding it in
RegionRippleDrag to forbid dragging of selections containing regions on more
than one track to dofferent tracks in ripple mode.
Remember which TimeAxisView a ripple-mode drag that's allowed cross-track
drags started from, so that the effect of rippling regions after any region
that's dragged off that track can be undone.
2013-10-23 16:50:01 -04:00
|
|
|
}
|
2016-06-16 13:20:37 -04:00
|
|
|
pl->paste (*p, pos, ctx.times, sub_num);
|
2014-07-01 13:27:22 -04:00
|
|
|
|
|
|
|
vector<Command*> cmds;
|
|
|
|
pl->rdiff (cmds);
|
|
|
|
_session->add_commands (cmds);
|
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
_session->add_command (new StatefulDiffCommand (pl));
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-03-16 11:33:04 -04:00
|
|
|
struct PlaylistSorter {
|
2017-06-23 17:42:42 -04:00
|
|
|
bool operator() (boost::shared_ptr<Playlist> a, boost::shared_ptr<Playlist> b) const {
|
|
|
|
return a->sort_id() < b->sort_id();
|
|
|
|
}
|
2010-03-16 11:33:04 -04:00
|
|
|
};
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
void
|
2010-08-10 22:04:49 -04:00
|
|
|
RouteTimeAxisView::build_playlist_menu ()
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
2010-08-10 22:04:49 -04:00
|
|
|
if (!is_track()) {
|
2006-07-23 08:03:19 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-08-10 22:04:49 -04:00
|
|
|
delete playlist_action_menu;
|
|
|
|
playlist_action_menu = new Menu;
|
|
|
|
playlist_action_menu->set_name ("ArdourContextMenu");
|
|
|
|
|
|
|
|
MenuList& playlist_items = playlist_action_menu->items();
|
|
|
|
playlist_action_menu->set_name ("ArdourContextMenu");
|
2006-07-23 08:03:19 -04:00
|
|
|
playlist_items.clear();
|
|
|
|
|
2006-11-19 11:45:16 -05:00
|
|
|
RadioMenuItem::Group playlist_group;
|
2011-09-05 19:38:18 -04:00
|
|
|
boost::shared_ptr<Track> tr = track ();
|
2006-11-19 11:45:16 -05:00
|
|
|
|
2019-03-19 00:14:40 -04:00
|
|
|
vector<boost::shared_ptr<Playlist> > playlists_tr = _session->playlists()->playlists_for_track (tr);
|
2010-03-16 11:33:04 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
/* sort the playlists */
|
|
|
|
PlaylistSorter cmp;
|
|
|
|
sort (playlists_tr.begin(), playlists_tr.end(), cmp);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
/* add the playlists to the menu */
|
|
|
|
for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists_tr.begin(); i != playlists_tr.end(); ++i) {
|
|
|
|
playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name()));
|
|
|
|
RadioMenuItem *item = static_cast<RadioMenuItem*>(&playlist_items.back());
|
|
|
|
item->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::use_playlist), item, boost::weak_ptr<Playlist> (*i)));
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
if (tr->playlist()->id() == (*i)->id()) {
|
|
|
|
item->set_active();
|
2006-11-19 11:45:16 -05:00
|
|
|
}
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2006-11-19 11:45:16 -05:00
|
|
|
playlist_items.push_back (SeparatorElem());
|
2010-04-25 15:38:04 -04:00
|
|
|
playlist_items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteTimeAxisView::rename_current_playlist)));
|
2006-07-23 08:03:19 -04:00
|
|
|
playlist_items.push_back (SeparatorElem());
|
|
|
|
|
2016-06-05 15:54:37 -04:00
|
|
|
if (!route_group() || !route_group()->is_active() || !route_group()->enabled_property (ARDOUR::Properties::group_select.property_id)) {
|
2010-04-25 15:38:04 -04:00
|
|
|
playlist_items.push_back (MenuElem (_("New..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this)));
|
|
|
|
playlist_items.push_back (MenuElem (_("New Copy..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this)));
|
2008-10-06 14:04:12 -04:00
|
|
|
|
|
|
|
} else {
|
|
|
|
// Use a label which tells the user what is happening
|
2009-12-11 18:29:48 -05:00
|
|
|
playlist_items.push_back (MenuElem (_("New Take"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this)));
|
|
|
|
playlist_items.push_back (MenuElem (_("Copy Take"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this)));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-10-06 14:04:12 -04:00
|
|
|
}
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
playlist_items.push_back (SeparatorElem());
|
2009-12-11 18:29:48 -05:00
|
|
|
playlist_items.push_back (MenuElem (_("Clear Current"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::clear_playlists), this)));
|
2006-07-23 08:03:19 -04:00
|
|
|
playlist_items.push_back (SeparatorElem());
|
|
|
|
|
2015-11-29 14:17:11 -05:00
|
|
|
playlist_items.push_back (MenuElem(_("Select from All..."), sigc::mem_fun(*this, &RouteTimeAxisView::show_playlist_selector)));
|
2006-11-19 11:45:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-03-16 11:33:04 -04:00
|
|
|
RouteTimeAxisView::use_playlist (RadioMenuItem *item, boost::weak_ptr<Playlist> wpl)
|
2006-11-19 11:45:16 -05:00
|
|
|
{
|
|
|
|
assert (is_track());
|
|
|
|
|
2017-06-23 17:42:42 -04:00
|
|
|
// exit if we were triggered by deactivating the old playlist
|
|
|
|
if (!item->get_active()) {
|
|
|
|
return;
|
|
|
|
}
|
2010-03-16 11:33:04 -04:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
boost::shared_ptr<Playlist> pl (wpl.lock());
|
|
|
|
|
|
|
|
if (!pl) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-07-07 10:16:33 -04:00
|
|
|
if (track()->playlist() == pl) {
|
|
|
|
// exit when use_playlist is called by the creation of the playlist menu
|
|
|
|
// or the playlist choice is unchanged
|
|
|
|
return;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2017-03-31 11:28:14 -04:00
|
|
|
track()->use_playlist (track()->data_type(), pl);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-07 10:16:33 -04:00
|
|
|
RouteGroup* rg = route_group();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2016-06-05 15:54:37 -04:00
|
|
|
if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::group_select.property_id)) {
|
2011-07-07 10:16:33 -04:00
|
|
|
std::string group_string = "." + rg->name() + ".";
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-07 10:16:33 -04:00
|
|
|
std::string take_name = pl->name();
|
|
|
|
std::string::size_type idx = take_name.find(group_string);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-07 10:16:33 -04:00
|
|
|
if (idx == std::string::npos)
|
2008-10-06 14:04:12 -04:00
|
|
|
return;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-07 10:16:33 -04:00
|
|
|
take_name = take_name.substr(idx + group_string.length()); // find the bit containing the take number / name
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-07 10:16:33 -04:00
|
|
|
boost::shared_ptr<RouteList> rl (rg->route_list());
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-07 10:16:33 -04:00
|
|
|
for (RouteList::const_iterator i = rl->begin(); i != rl->end(); ++i) {
|
2012-06-11 07:26:42 -04:00
|
|
|
if ((*i) == this->route()) {
|
2011-07-07 10:16:33 -04:00
|
|
|
continue;
|
|
|
|
}
|
2012-06-11 07:26:42 -04:00
|
|
|
|
2011-07-07 10:16:33 -04:00
|
|
|
std::string playlist_name = (*i)->name()+group_string+take_name;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-07 10:16:33 -04:00
|
|
|
boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track>(*i);
|
|
|
|
if (!track) {
|
|
|
|
continue;
|
|
|
|
}
|
2012-06-11 07:26:42 -04:00
|
|
|
|
|
|
|
if (track->freeze_state() == Track::Frozen) {
|
|
|
|
/* Don't change playlists of frozen tracks */
|
|
|
|
continue;
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2019-03-19 00:14:40 -04:00
|
|
|
boost::shared_ptr<Playlist> ipl = session()->playlists()->by_name(playlist_name);
|
2011-07-07 10:16:33 -04:00
|
|
|
if (!ipl) {
|
|
|
|
// No playlist for this track for this take yet, make it
|
2017-07-25 11:27:18 -04:00
|
|
|
track->use_default_new_playlist();
|
2011-07-07 10:16:33 -04:00
|
|
|
track->playlist()->set_name(playlist_name);
|
|
|
|
} else {
|
2017-03-31 11:28:14 -04:00
|
|
|
track->use_playlist(track->data_type(), ipl);
|
2008-10-06 14:04:12 -04:00
|
|
|
}
|
|
|
|
}
|
2006-11-19 11:45:16 -05:00
|
|
|
}
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2012-06-11 19:15:17 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::update_playlist_tip ()
|
|
|
|
{
|
|
|
|
RouteGroup* rg = route_group ();
|
2016-06-05 15:54:37 -04:00
|
|
|
if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::group_select.property_id)) {
|
2012-06-11 19:15:17 -04:00
|
|
|
string group_string = "." + rg->name() + ".";
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-06-11 19:15:17 -04:00
|
|
|
string take_name = track()->playlist()->name();
|
|
|
|
string::size_type idx = take_name.find(group_string);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-06-11 19:15:17 -04:00
|
|
|
if (idx != string::npos) {
|
|
|
|
/* find the bit containing the take number / name */
|
|
|
|
take_name = take_name.substr (idx + group_string.length());
|
|
|
|
|
|
|
|
/* set the playlist button tooltip to the take name */
|
2015-01-05 00:32:14 -05:00
|
|
|
set_tooltip (
|
2012-06-12 10:19:35 -04:00
|
|
|
playlist_button,
|
2012-11-19 11:18:03 -05:00
|
|
|
string_compose(_("Take: %1.%2"),
|
2015-10-15 05:24:15 -04:00
|
|
|
Gtkmm2ext::markup_escape_text (rg->name()),
|
|
|
|
Gtkmm2ext::markup_escape_text (take_name))
|
2012-06-12 10:19:35 -04:00
|
|
|
);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-06-11 19:15:17 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set the playlist button tooltip to the playlist name */
|
2015-10-15 05:24:15 -04:00
|
|
|
set_tooltip (playlist_button, _("Playlist") + std::string(": ") + Gtkmm2ext::markup_escape_text (track()->playlist()->name()));
|
2012-06-11 19:15:17 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-23 08:03:19 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::show_playlist_selector ()
|
|
|
|
{
|
2009-01-01 19:17:55 -05:00
|
|
|
_editor.playlist_selector().show_for (this);
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::map_frozen ()
|
|
|
|
{
|
|
|
|
if (!is_track()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::map_frozen)
|
2006-07-23 08:03:19 -04:00
|
|
|
|
|
|
|
switch (track()->freeze_state()) {
|
|
|
|
case Track::Frozen:
|
|
|
|
playlist_button.set_sensitive (false);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
playlist_button.set_sensitive (true);
|
|
|
|
break;
|
|
|
|
}
|
2016-05-23 21:01:27 -04:00
|
|
|
RouteUI::map_frozen ();
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-06-15 18:08:27 -04:00
|
|
|
RouteTimeAxisView::color_handler ()
|
2006-07-23 08:03:19 -04:00
|
|
|
{
|
2007-06-15 18:08:27 -04:00
|
|
|
//case cTimeStretchOutline:
|
|
|
|
if (timestretch_rect) {
|
2015-01-02 09:44:54 -05:00
|
|
|
timestretch_rect->set_outline_color (UIConfiguration::instance().color ("time stretch outline"));
|
2007-06-15 18:08:27 -04:00
|
|
|
}
|
|
|
|
//case cTimeStretchFill:
|
|
|
|
if (timestretch_rect) {
|
2015-01-02 09:44:54 -05:00
|
|
|
timestretch_rect->set_fill_color (UIConfiguration::instance().color ("time stretch fill"));
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
2007-06-15 18:08:27 -04:00
|
|
|
|
2008-01-10 16:20:59 -05:00
|
|
|
reset_meter();
|
2006-07-23 08:03:19 -04:00
|
|
|
}
|
|
|
|
|
2010-01-08 21:36:47 -05:00
|
|
|
/** Toggle an automation track for a fully-specified Parameter (type,channel,id)
|
|
|
|
* Will add track if necessary.
|
|
|
|
*/
|
2007-06-27 11:51:50 -04:00
|
|
|
void
|
2010-01-08 21:36:47 -05:00
|
|
|
RouteTimeAxisView::toggle_automation_track (const Evoral::Parameter& param)
|
2007-06-27 11:51:50 -04:00
|
|
|
{
|
2010-05-25 10:50:45 -04:00
|
|
|
boost::shared_ptr<AutomationTimeAxisView> track = automation_child (param);
|
|
|
|
Gtk::CheckMenuItem* menu = automation_child_menu_item (param);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-05-25 10:50:45 -04:00
|
|
|
if (!track) {
|
2010-01-10 13:11:02 -05:00
|
|
|
/* it doesn't exist yet, so we don't care about the button state: just add it */
|
2010-01-08 21:36:47 -05:00
|
|
|
create_automation_child (param, true);
|
|
|
|
} else {
|
2010-05-25 10:50:45 -04:00
|
|
|
assert (menu);
|
|
|
|
bool yn = menu->get_active();
|
2011-07-06 20:37:13 -04:00
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
if ((changed = track->set_marked_for_display (menu->get_active())) && yn) {
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-01-10 13:11:02 -05:00
|
|
|
/* we made it visible, now trigger a redisplay. if it was hidden, then automation_track_hidden()
|
|
|
|
will have done that for us.
|
|
|
|
*/
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-07-06 20:37:13 -04:00
|
|
|
if (changed && !no_redraw) {
|
|
|
|
request_redraw ();
|
2011-06-01 13:00:29 -04:00
|
|
|
}
|
2007-06-27 11:51:50 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-30 16:24:18 -05:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::update_pan_track_visibility ()
|
|
|
|
{
|
|
|
|
bool const showit = pan_automation_item->get_active();
|
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
for (list<boost::shared_ptr<AutomationTimeAxisView> >::iterator i = pan_tracks.begin(); i != pan_tracks.end(); ++i) {
|
|
|
|
if ((*i)->set_marked_for_display (showit)) {
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (changed) {
|
|
|
|
_route->gui_changed (X_("visible_tracks"), (void *) 0); /* EMIT_SIGNAL */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::ensure_pan_views (bool show)
|
|
|
|
{
|
|
|
|
bool changed = false;
|
|
|
|
for (list<boost::shared_ptr<AutomationTimeAxisView> >::iterator i = pan_tracks.begin(); i != pan_tracks.end(); ++i) {
|
|
|
|
changed = true;
|
|
|
|
(*i)->set_marked_for_display (false);
|
|
|
|
}
|
|
|
|
if (changed) {
|
|
|
|
_route->gui_changed (X_("visible_tracks"), (void *) 0); /* EMIT_SIGNAL */
|
|
|
|
}
|
|
|
|
pan_tracks.clear();
|
|
|
|
|
|
|
|
if (!_route->panner()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
set<Evoral::Parameter> params = _route->panner()->what_can_be_automated();
|
|
|
|
set<Evoral::Parameter>::iterator p;
|
|
|
|
|
|
|
|
for (p = params.begin(); p != params.end(); ++p) {
|
|
|
|
boost::shared_ptr<ARDOUR::AutomationControl> pan_control = _route->pannable()->automation_control(*p);
|
|
|
|
|
|
|
|
if (pan_control->parameter().type() == NullAutomation) {
|
|
|
|
error << "Pan control has NULL automation type!" << endmsg;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (automation_child (pan_control->parameter ()).get () == 0) {
|
|
|
|
|
|
|
|
/* we don't already have an AutomationTimeAxisView for this parameter */
|
|
|
|
|
|
|
|
std::string const name = _route->panner()->describe_parameter (pan_control->parameter ());
|
|
|
|
|
|
|
|
boost::shared_ptr<AutomationTimeAxisView> t (
|
|
|
|
new AutomationTimeAxisView (_session,
|
|
|
|
_route,
|
|
|
|
_route->pannable(),
|
|
|
|
pan_control,
|
|
|
|
pan_control->parameter (),
|
|
|
|
_editor,
|
|
|
|
*this,
|
|
|
|
false,
|
|
|
|
parent_canvas,
|
|
|
|
name)
|
|
|
|
);
|
|
|
|
|
|
|
|
pan_tracks.push_back (t);
|
|
|
|
add_automation_child (*p, t, show);
|
|
|
|
} else {
|
|
|
|
pan_tracks.push_back (automation_child (pan_control->parameter ()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-27 11:51:50 -04:00
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
void
|
2011-03-07 08:04:36 -05:00
|
|
|
RouteTimeAxisView::show_all_automation (bool apply_to_selection)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2011-03-07 08:04:36 -05:00
|
|
|
if (apply_to_selection) {
|
|
|
|
_editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::show_all_automation, _1, false));
|
|
|
|
} else {
|
|
|
|
no_redraw = true;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2017-06-09 08:48:33 -04:00
|
|
|
StripableTimeAxisView::show_all_automation ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-03-07 08:04:36 -05:00
|
|
|
/* Show processor automation */
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-03-07 08:04:36 -05:00
|
|
|
for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
|
|
|
|
for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
|
|
|
|
if ((*ii)->view == 0) {
|
|
|
|
add_processor_automation_curve ((*i)->processor, (*ii)->what);
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
(*ii)->menu_item->set_active (true);
|
|
|
|
}
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-03-07 08:04:36 -05:00
|
|
|
no_redraw = false;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-03-07 08:04:36 -05:00
|
|
|
/* Redraw */
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-07-06 20:37:13 -04:00
|
|
|
request_redraw ();
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
void
|
2011-03-07 08:04:36 -05:00
|
|
|
RouteTimeAxisView::show_existing_automation (bool apply_to_selection)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2011-03-07 08:04:36 -05:00
|
|
|
if (apply_to_selection) {
|
|
|
|
_editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::show_existing_automation, _1, false));
|
|
|
|
} else {
|
|
|
|
no_redraw = true;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2017-06-09 08:48:33 -04:00
|
|
|
StripableTimeAxisView::show_existing_automation ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-03-07 08:04:36 -05:00
|
|
|
/* Show processor automation */
|
|
|
|
for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
|
|
|
|
for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
|
2016-06-04 12:52:57 -04:00
|
|
|
if ((*i)->processor->control((*ii)->what)->list()->size() > 0) {
|
2011-03-07 08:04:36 -05:00
|
|
|
(*ii)->menu_item->set_active (true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-03-07 08:04:36 -05:00
|
|
|
no_redraw = false;
|
2011-07-06 20:37:13 -04:00
|
|
|
request_redraw ();
|
2007-10-02 12:37:26 -04:00
|
|
|
}
|
2011-03-07 08:04:36 -05:00
|
|
|
}
|
2007-10-02 12:37:26 -04:00
|
|
|
|
2011-03-07 08:04:36 -05:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::hide_all_automation (bool apply_to_selection)
|
|
|
|
{
|
|
|
|
if (apply_to_selection) {
|
|
|
|
_editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::hide_all_automation, _1, false));
|
|
|
|
} else {
|
|
|
|
no_redraw = true;
|
2017-06-09 08:48:33 -04:00
|
|
|
StripableTimeAxisView::hide_all_automation ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-03-07 08:04:36 -05:00
|
|
|
/* Hide processor automation */
|
|
|
|
for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
|
|
|
|
for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
|
|
|
|
(*ii)->menu_item->set_active (false);
|
|
|
|
}
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-03-07 08:04:36 -05:00
|
|
|
no_redraw = false;
|
2011-07-06 20:37:13 -04:00
|
|
|
request_redraw ();
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::region_view_added (RegionView* rv)
|
|
|
|
{
|
2008-02-10 13:16:25 -05:00
|
|
|
/* XXX need to find out if automation children have automationstreamviews. If yes, no ghosts */
|
2010-12-30 13:35:16 -05:00
|
|
|
for (Children::iterator i = children.begin(); i != children.end(); ++i) {
|
|
|
|
boost::shared_ptr<AutomationTimeAxisView> atv;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-12-30 13:35:16 -05:00
|
|
|
if ((atv = boost::dynamic_pointer_cast<AutomationTimeAxisView> (*i)) != 0) {
|
|
|
|
atv->add_ghost(rv);
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-10 13:16:25 -05:00
|
|
|
for (UnderlayMirrorList::iterator i = _underlay_mirrors.begin(); i != _underlay_mirrors.end(); ++i) {
|
|
|
|
(*i)->add_ghost(rv);
|
|
|
|
}
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
RouteTimeAxisView::ProcessorAutomationInfo::~ProcessorAutomationInfo ()
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2007-06-30 14:41:50 -04:00
|
|
|
for (vector<ProcessorAutomationNode*>::iterator i = lines.begin(); i != lines.end(); ++i) {
|
2006-07-29 23:25:38 -04:00
|
|
|
delete *i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
RouteTimeAxisView::ProcessorAutomationNode::~ProcessorAutomationNode ()
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2007-06-30 14:41:50 -04:00
|
|
|
parent.remove_processor_automation_node (this);
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-06-30 14:41:50 -04:00
|
|
|
RouteTimeAxisView::remove_processor_automation_node (ProcessorAutomationNode* pan)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2007-06-30 14:41:50 -04:00
|
|
|
if (pan->view) {
|
|
|
|
remove_child (pan->view);
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
RouteTimeAxisView::ProcessorAutomationNode*
|
2008-09-29 18:47:40 -04:00
|
|
|
RouteTimeAxisView::find_processor_automation_node (boost::shared_ptr<Processor> processor, Evoral::Parameter what)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2007-06-30 14:41:50 -04:00
|
|
|
for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if ((*i)->processor == processor) {
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
|
2006-07-29 23:25:38 -04:00
|
|
|
if ((*ii)->what == what) {
|
|
|
|
return *ii;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-02 19:36:01 -04:00
|
|
|
/** Add an AutomationTimeAxisView to display automation for a processor's parameter */
|
2006-07-29 23:25:38 -04:00
|
|
|
void
|
2008-09-29 18:47:40 -04:00
|
|
|
RouteTimeAxisView::add_processor_automation_curve (boost::shared_ptr<Processor> processor, Evoral::Parameter what)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
|
|
|
string name;
|
2007-06-30 14:41:50 -04:00
|
|
|
ProcessorAutomationNode* pan;
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
if ((pan = find_processor_automation_node (processor, what)) == 0) {
|
2017-06-23 17:42:42 -04:00
|
|
|
/* session state may never have been saved with new plugin */
|
|
|
|
error << _("programming error: ")
|
2010-08-24 18:07:53 -04:00
|
|
|
<< string_compose (X_("processor automation curve for %1:%2/%3/%4 not registered with track!"),
|
2017-06-23 17:42:42 -04:00
|
|
|
processor->name(), what.type(), (int) what.channel(), what.id() )
|
2006-07-29 23:25:38 -04:00
|
|
|
<< endmsg;
|
2014-11-14 04:47:43 -05:00
|
|
|
abort(); /*NOTREACHED*/
|
2006-07-29 23:25:38 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
if (pan->view) {
|
2006-07-29 23:25:38 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-09-18 20:47:49 -04:00
|
|
|
boost::shared_ptr<AutomationControl> control
|
2011-06-11 11:35:34 -04:00
|
|
|
= boost::dynamic_pointer_cast<AutomationControl>(processor->control(what, true));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2009-07-09 13:58:13 -04:00
|
|
|
pan->view = boost::shared_ptr<AutomationTimeAxisView>(
|
2011-02-17 11:18:27 -05:00
|
|
|
new AutomationTimeAxisView (_session, _route, processor, control, control->parameter (),
|
2015-10-04 14:51:05 -04:00
|
|
|
_editor, *this, false, parent_canvas,
|
2011-06-11 11:35:34 -04:00
|
|
|
processor->describe_parameter (what), processor->name()));
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
pan->view->Hiding.connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), pan, processor));
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2011-06-11 11:35:34 -04:00
|
|
|
add_automation_child (control->parameter(), pan->view, pan->view->marked_for_display ());
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
if (_view) {
|
2009-12-11 18:29:48 -05:00
|
|
|
_view->foreach_regionview (sigc::mem_fun(*pan->view.get(), &TimeAxisView::add_ghost));
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-09-30 13:55:14 -04:00
|
|
|
RouteTimeAxisView::processor_automation_track_hidden (RouteTimeAxisView::ProcessorAutomationNode* pan, boost::shared_ptr<Processor>)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
|
|
|
if (!_hidden) {
|
2007-06-30 14:41:50 -04:00
|
|
|
pan->menu_item->set_active (false);
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
2010-01-10 13:11:02 -05:00
|
|
|
if (!no_redraw) {
|
2011-07-06 20:37:13 -04:00
|
|
|
request_redraw ();
|
2010-01-10 13:11:02 -05:00
|
|
|
}
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-12-16 18:21:01 -05:00
|
|
|
RouteTimeAxisView::add_existing_processor_automation_curves (boost::weak_ptr<Processor> p)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2008-12-16 18:21:01 -05:00
|
|
|
boost::shared_ptr<Processor> processor (p.lock ());
|
2011-06-11 11:35:34 -04:00
|
|
|
|
2011-07-02 19:36:01 -04:00
|
|
|
if (!processor || boost::dynamic_pointer_cast<Amp> (processor)) {
|
|
|
|
/* The Amp processor is a special case and is dealt with separately */
|
2008-12-16 18:21:01 -05:00
|
|
|
return;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-06-11 11:35:34 -04:00
|
|
|
set<Evoral::Parameter> existing;
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2011-06-11 11:35:34 -04:00
|
|
|
processor->what_has_data (existing);
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2011-06-11 11:35:34 -04:00
|
|
|
for (set<Evoral::Parameter>::iterator i = existing.begin(); i != existing.end(); ++i) {
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-06-11 11:35:34 -04:00
|
|
|
Evoral::Parameter param (*i);
|
|
|
|
boost::shared_ptr<AutomationLine> al;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-06-11 11:35:34 -04:00
|
|
|
if ((al = find_processor_automation_curve (processor, param)) != 0) {
|
2019-03-26 13:18:49 -04:00
|
|
|
#warning NOT REACHED -- bug?
|
2007-06-30 14:41:50 -04:00
|
|
|
al->queue_reset ();
|
2006-07-29 23:25:38 -04:00
|
|
|
} else {
|
2011-06-11 11:35:34 -04:00
|
|
|
add_processor_automation_curve (processor, param);
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-06-26 10:52:36 -04:00
|
|
|
RouteTimeAxisView::add_processor_to_subplugin_menu (boost::weak_ptr<Processor> p)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2008-12-16 18:21:01 -05:00
|
|
|
boost::shared_ptr<Processor> processor (p.lock ());
|
2009-06-26 09:26:08 -04:00
|
|
|
|
2009-11-18 15:01:37 -05:00
|
|
|
if (!processor || !processor->display_to_user ()) {
|
2008-12-16 18:21:01 -05:00
|
|
|
return;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-06-11 11:35:34 -04:00
|
|
|
/* we use this override to veto the Amp processor from the plugin menu,
|
|
|
|
as its automation lane can be accessed using the special "Fader" menu
|
|
|
|
option
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (boost::dynamic_pointer_cast<Amp> (processor) != 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
using namespace Menu_Helpers;
|
2007-06-30 14:41:50 -04:00
|
|
|
ProcessorAutomationInfo *rai;
|
|
|
|
list<ProcessorAutomationInfo*>::iterator x;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-09-29 18:47:40 -04:00
|
|
|
const std::set<Evoral::Parameter>& automatable = processor->what_can_be_automated ();
|
2006-07-29 23:25:38 -04:00
|
|
|
|
|
|
|
if (automatable.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
for (x = processor_automation.begin(); x != processor_automation.end(); ++x) {
|
|
|
|
if ((*x)->processor == processor) {
|
2006-07-29 23:25:38 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
if (x == processor_automation.end()) {
|
2007-06-30 14:41:50 -04:00
|
|
|
rai = new ProcessorAutomationInfo (processor);
|
2015-10-28 16:25:01 -04:00
|
|
|
processor_automation.push_back (rai);
|
2006-07-29 23:25:38 -04:00
|
|
|
} else {
|
|
|
|
rai = *x;
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
/* any older menu was deleted at the top of processors_changed()
|
2006-07-29 23:25:38 -04:00
|
|
|
when we cleared the subplugin menu.
|
|
|
|
*/
|
|
|
|
|
|
|
|
rai->menu = manage (new Menu);
|
|
|
|
MenuList& items = rai->menu->items();
|
|
|
|
rai->menu->set_name ("ArdourContextMenu");
|
|
|
|
|
|
|
|
items.clear ();
|
|
|
|
|
2011-06-11 11:35:34 -04:00
|
|
|
std::set<Evoral::Parameter> has_visible_automation;
|
|
|
|
AutomationTimeAxisView::what_has_visible_automation (processor, has_visible_automation);
|
|
|
|
|
2008-09-29 18:47:40 -04:00
|
|
|
for (std::set<Evoral::Parameter>::const_iterator i = automatable.begin(); i != automatable.end(); ++i) {
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
ProcessorAutomationNode* pan;
|
2013-07-11 15:32:31 -04:00
|
|
|
Gtk::CheckMenuItem* mitem;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
string name = processor->describe_parameter (*i);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2015-10-28 14:00:59 -04:00
|
|
|
if (name == X_("hidden")) {
|
2015-10-28 13:58:46 -04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
items.push_back (CheckMenuElem (name));
|
2013-07-11 15:32:31 -04:00
|
|
|
mitem = dynamic_cast<Gtk::CheckMenuItem*> (&items.back());
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2010-06-08 17:48:38 -04:00
|
|
|
_subplugin_menu_map[*i] = mitem;
|
2010-05-26 21:08:53 -04:00
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
if (has_visible_automation.find((*i)) != has_visible_automation.end()) {
|
|
|
|
mitem->set_active(true);
|
|
|
|
}
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
if ((pan = find_processor_automation_node (processor, *i)) == 0) {
|
2006-07-29 23:25:38 -04:00
|
|
|
|
|
|
|
/* new item */
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
pan = new ProcessorAutomationNode (*i, mitem, *this);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
rai->lines.push_back (pan);
|
2006-07-29 23:25:38 -04:00
|
|
|
|
|
|
|
} else {
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
pan->menu_item = mitem;
|
2006-07-29 23:25:38 -04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
mitem->signal_toggled().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_menu_item_toggled), rai, pan));
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
2015-10-28 16:25:01 -04:00
|
|
|
if (items.size() == 0) {
|
2015-10-28 13:58:46 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
/* add the menu for this processor, because the subplugin
|
|
|
|
menu is always cleared at the top of processors_changed().
|
2006-07-29 23:25:38 -04:00
|
|
|
this is the result of some poor design in gtkmm and/or
|
|
|
|
GTK+.
|
|
|
|
*/
|
|
|
|
|
2007-06-27 16:23:48 -04:00
|
|
|
subplugin_menu.items().push_back (MenuElem (processor->name(), *rai->menu));
|
2006-07-29 23:25:38 -04:00
|
|
|
rai->valid = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-06-30 14:41:50 -04:00
|
|
|
RouteTimeAxisView::processor_menu_item_toggled (RouteTimeAxisView::ProcessorAutomationInfo* rai,
|
|
|
|
RouteTimeAxisView::ProcessorAutomationNode* pan)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2007-06-30 14:41:50 -04:00
|
|
|
bool showit = pan->menu_item->get_active();
|
2006-07-29 23:25:38 -04:00
|
|
|
bool redraw = false;
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
if (pan->view == 0 && showit) {
|
|
|
|
add_processor_automation_curve (rai->processor, pan->what);
|
2006-07-29 23:25:38 -04:00
|
|
|
redraw = true;
|
|
|
|
}
|
|
|
|
|
2011-07-06 20:37:13 -04:00
|
|
|
if (pan->view && pan->view->set_marked_for_display (showit)) {
|
2006-07-29 23:25:38 -04:00
|
|
|
redraw = true;
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
if (redraw && !no_redraw) {
|
2011-07-06 20:37:13 -04:00
|
|
|
request_redraw ();
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-09 12:25:36 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::reread_midnam ()
|
|
|
|
{
|
|
|
|
boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (_route->the_instrument ());
|
|
|
|
assert (pi);
|
|
|
|
bool rv = pi->plugin ()->read_midnam();
|
|
|
|
|
|
|
|
if (rv && patch_change_dialog ()) {
|
|
|
|
patch_change_dialog ()->refresh ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::drop_instrument_ref ()
|
|
|
|
{
|
|
|
|
midnam_connection.drop_connections ();
|
|
|
|
}
|
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
void
|
2009-11-30 18:16:28 -05:00
|
|
|
RouteTimeAxisView::processors_changed (RouteProcessorChange c)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2017-09-09 12:25:36 -04:00
|
|
|
if (_route) {
|
|
|
|
boost::shared_ptr<Processor> the_instrument (_route->the_instrument());
|
|
|
|
boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (the_instrument);
|
|
|
|
if (pi && pi->plugin ()->has_midnam ()) {
|
|
|
|
midnam_connection.drop_connections ();
|
|
|
|
the_instrument->DropReferences.connect (midnam_connection, invalidator (*this),
|
|
|
|
boost::bind (&RouteTimeAxisView::drop_instrument_ref, this),
|
|
|
|
gui_context());
|
|
|
|
pi->plugin()->UpdateMidnam.connect (midnam_connection, invalidator (*this),
|
|
|
|
boost::bind (&RouteTimeAxisView::reread_midnam, this),
|
|
|
|
gui_context());
|
|
|
|
|
|
|
|
reread_midnam ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-30 18:16:28 -05:00
|
|
|
if (c.type == RouteProcessorChange::MeterPointChange) {
|
|
|
|
/* nothing to do if only the meter point has changed */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-07-29 23:25:38 -04:00
|
|
|
using namespace Menu_Helpers;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
|
2006-07-29 23:25:38 -04:00
|
|
|
(*i)->valid = false;
|
|
|
|
}
|
|
|
|
|
2011-07-02 19:36:01 -04:00
|
|
|
setup_processor_menu_and_curves ();
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2009-11-30 14:48:50 -05:00
|
|
|
bool deleted_processor_automation = false;
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ) {
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
list<ProcessorAutomationInfo*>::iterator tmp;
|
2006-07-29 23:25:38 -04:00
|
|
|
|
|
|
|
tmp = i;
|
|
|
|
++tmp;
|
|
|
|
|
|
|
|
if (!(*i)->valid) {
|
|
|
|
|
|
|
|
delete *i;
|
2007-06-27 16:23:48 -04:00
|
|
|
processor_automation.erase (i);
|
2009-11-30 14:48:50 -05:00
|
|
|
deleted_processor_automation = true;
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2006-07-29 23:25:38 -04:00
|
|
|
|
|
|
|
i = tmp;
|
|
|
|
}
|
|
|
|
|
2010-01-10 13:11:02 -05:00
|
|
|
if (deleted_processor_automation && !no_redraw) {
|
2011-07-06 20:37:13 -04:00
|
|
|
request_redraw ();
|
2009-11-30 14:48:50 -05:00
|
|
|
}
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
boost::shared_ptr<AutomationLine>
|
2008-09-29 18:47:40 -04:00
|
|
|
RouteTimeAxisView::find_processor_automation_curve (boost::shared_ptr<Processor> processor, Evoral::Parameter what)
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2007-06-30 14:41:50 -04:00
|
|
|
ProcessorAutomationNode* pan;
|
2006-07-29 23:25:38 -04:00
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
if ((pan = find_processor_automation_node (processor, what)) != 0) {
|
|
|
|
if (pan->view) {
|
|
|
|
pan->view->line();
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
2007-06-30 14:41:50 -04:00
|
|
|
return boost::shared_ptr<AutomationLine>();
|
2006-07-29 23:25:38 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-06-27 16:23:48 -04:00
|
|
|
RouteTimeAxisView::reset_processor_automation_curves ()
|
2006-07-29 23:25:38 -04:00
|
|
|
{
|
2007-06-30 14:41:50 -04:00
|
|
|
for (ProcessorAutomationCurves::iterator i = processor_automation_curves.begin(); i != processor_automation_curves.end(); ++i) {
|
2006-07-29 23:25:38 -04:00
|
|
|
(*i)->reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-27 09:08:38 -05:00
|
|
|
bool
|
|
|
|
RouteTimeAxisView::can_edit_name () const
|
|
|
|
{
|
|
|
|
/* we do not allow track name changes if it is record enabled
|
|
|
|
*/
|
2016-04-08 16:49:47 -04:00
|
|
|
boost::shared_ptr<Track> trk (boost::dynamic_pointer_cast<Track> (_route));
|
|
|
|
if (!trk) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return !trk->rec_enable_control()->get_value();
|
2012-12-27 09:08:38 -05:00
|
|
|
}
|
|
|
|
|
2007-04-29 13:23:11 -04:00
|
|
|
void
|
2014-08-22 12:45:34 -04:00
|
|
|
RouteTimeAxisView::blink_rec_display (bool onoff)
|
2007-04-29 13:23:11 -04:00
|
|
|
{
|
2014-08-22 12:45:34 -04:00
|
|
|
RouteUI::blink_rec_display (onoff);
|
2007-04-29 13:23:11 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-07-14 21:56:11 -04:00
|
|
|
void
|
2011-02-22 21:08:57 -05:00
|
|
|
RouteTimeAxisView::set_layer_display (LayerDisplay d, bool apply_to_selection)
|
2007-07-14 21:56:11 -04:00
|
|
|
{
|
2012-06-13 16:37:07 -04:00
|
|
|
if (_ignore_set_layer_display) {
|
|
|
|
return;
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-02-22 21:08:57 -05:00
|
|
|
if (apply_to_selection) {
|
|
|
|
_editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_layer_display, _1, d, false));
|
|
|
|
} else {
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-02-22 21:08:57 -05:00
|
|
|
if (_view) {
|
|
|
|
_view->set_layer_display (d);
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2016-08-30 08:36:45 -04:00
|
|
|
set_gui_property (X_("layer-display"), d);
|
2009-01-05 22:18:09 -05:00
|
|
|
}
|
2007-07-14 21:56:11 -04:00
|
|
|
}
|
2009-01-05 22:18:09 -05:00
|
|
|
|
|
|
|
LayerDisplay
|
|
|
|
RouteTimeAxisView::layer_display () const
|
|
|
|
{
|
|
|
|
if (_view) {
|
|
|
|
return _view->layer_display ();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we don't know, since we don't have a _view, so just return something */
|
|
|
|
return Overlaid;
|
|
|
|
}
|
|
|
|
|
2007-12-20 18:25:19 -05:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::fast_update ()
|
|
|
|
{
|
2008-09-10 11:03:30 -04:00
|
|
|
gm.get_level_meter().update_meters ();
|
2007-12-20 18:25:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::hide_meter ()
|
|
|
|
{
|
|
|
|
clear_meter ();
|
2008-09-10 11:03:30 -04:00
|
|
|
gm.get_level_meter().hide_meters ();
|
2007-12-20 18:25:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::show_meter ()
|
|
|
|
{
|
|
|
|
reset_meter ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::reset_meter ()
|
|
|
|
{
|
2015-01-02 09:44:54 -05:00
|
|
|
if (UIConfiguration::instance().get_show_track_meters()) {
|
2013-07-02 16:58:24 -04:00
|
|
|
int meter_width = 3;
|
|
|
|
if (_route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
|
|
|
|
meter_width = 6;
|
|
|
|
}
|
2013-07-03 01:36:15 -04:00
|
|
|
gm.get_level_meter().setup_meters (height - 9, meter_width);
|
2007-12-20 18:25:19 -05:00
|
|
|
} else {
|
|
|
|
hide_meter ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::clear_meter ()
|
|
|
|
{
|
2008-09-10 11:03:30 -04:00
|
|
|
gm.get_level_meter().clear_meters ();
|
2007-12-20 18:25:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-04-03 09:40:34 -04:00
|
|
|
RouteTimeAxisView::meter_changed ()
|
2007-12-20 18:25:19 -05:00
|
|
|
{
|
2010-04-03 09:40:34 -04:00
|
|
|
ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::meter_changed)
|
2007-12-20 18:25:19 -05:00
|
|
|
reset_meter();
|
2015-01-02 09:44:54 -05:00
|
|
|
if (_route && !no_redraw && UIConfiguration::instance().get_show_track_meters()) {
|
2013-07-05 00:33:28 -04:00
|
|
|
request_redraw ();
|
|
|
|
}
|
2013-11-20 12:54:34 -05:00
|
|
|
// reset peak when meter point changes
|
|
|
|
gm.reset_peak_display();
|
2007-12-20 18:25:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-07-21 11:55:17 -04:00
|
|
|
RouteTimeAxisView::io_changed (IOChange /*change*/, void */*src*/)
|
2007-12-20 18:25:19 -05:00
|
|
|
{
|
|
|
|
reset_meter ();
|
2013-07-10 14:48:42 -04:00
|
|
|
if (_route && !no_redraw) {
|
|
|
|
request_redraw ();
|
|
|
|
}
|
2007-12-20 18:25:19 -05:00
|
|
|
}
|
2008-02-10 13:16:25 -05:00
|
|
|
|
|
|
|
void
|
2010-01-04 19:48:00 -05:00
|
|
|
RouteTimeAxisView::build_underlay_menu(Gtk::Menu* parent_menu)
|
|
|
|
{
|
2008-02-10 13:16:25 -05:00
|
|
|
using namespace Menu_Helpers;
|
|
|
|
|
2010-01-04 19:48:00 -05:00
|
|
|
if (!_underlay_streams.empty()) {
|
2008-02-10 13:16:25 -05:00
|
|
|
MenuList& parent_items = parent_menu->items();
|
|
|
|
Menu* gs_menu = manage (new Menu);
|
|
|
|
gs_menu->set_name ("ArdourContextMenu");
|
|
|
|
MenuList& gs_items = gs_menu->items();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-02-10 13:16:25 -05:00
|
|
|
parent_items.push_back (MenuElem (_("Underlays"), *gs_menu));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-02-10 13:16:25 -05:00
|
|
|
for(UnderlayList::iterator it = _underlay_streams.begin(); it != _underlay_streams.end(); ++it) {
|
2009-07-09 13:58:13 -04:00
|
|
|
gs_items.push_back(MenuElem(string_compose(_("Remove \"%1\""), (*it)->trackview().name()),
|
2009-12-11 18:29:48 -05:00
|
|
|
sigc::bind(sigc::mem_fun(*this, &RouteTimeAxisView::remove_underlay), *it)));
|
2008-02-10 13:16:25 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2009-10-14 12:10:01 -04:00
|
|
|
RouteTimeAxisView::set_underlay_state()
|
2008-02-10 13:16:25 -05:00
|
|
|
{
|
2010-01-04 19:48:00 -05:00
|
|
|
if (!underlay_xml_node) {
|
2008-02-10 13:16:25 -05:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
XMLNodeList nlist = underlay_xml_node->children();
|
|
|
|
XMLNodeConstIterator niter;
|
|
|
|
XMLNode *child_node;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-02-10 13:16:25 -05:00
|
|
|
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
|
|
|
|
child_node = *niter;
|
|
|
|
|
2010-01-04 19:48:00 -05:00
|
|
|
if (child_node->name() != "Underlay") {
|
2008-02-10 13:16:25 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2016-05-04 23:09:37 -04:00
|
|
|
XMLProperty const * prop = child_node->property ("id");
|
2009-01-01 19:17:55 -05:00
|
|
|
if (prop) {
|
|
|
|
PBD::ID id (prop->value());
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2017-08-06 16:16:36 -04:00
|
|
|
StripableTimeAxisView* v = _editor.get_stripable_time_axis_by_id (id);
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2009-01-01 19:17:55 -05:00
|
|
|
if (v) {
|
2008-02-10 13:16:25 -05:00
|
|
|
add_underlay(v->view(), false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-09-30 13:55:14 -04:00
|
|
|
RouteTimeAxisView::add_underlay (StreamView* v, bool /*update_xml*/)
|
2008-02-10 13:16:25 -05:00
|
|
|
{
|
2010-01-04 19:48:00 -05:00
|
|
|
if (!v) {
|
2008-02-10 13:16:25 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-09 13:58:13 -04:00
|
|
|
RouteTimeAxisView& other = v->trackview();
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2010-01-04 19:48:00 -05:00
|
|
|
if (find(_underlay_streams.begin(), _underlay_streams.end(), v) == _underlay_streams.end()) {
|
|
|
|
if (find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this) != other._underlay_mirrors.end()) {
|
2008-02-10 13:16:25 -05:00
|
|
|
fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
|
2014-11-14 04:47:43 -05:00
|
|
|
abort(); /*NOTREACHED*/
|
2008-02-10 13:16:25 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
_underlay_streams.push_back(v);
|
2009-07-09 13:58:13 -04:00
|
|
|
other._underlay_mirrors.push_back(this);
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
v->foreach_regionview(sigc::mem_fun(*this, &RouteTimeAxisView::add_ghost));
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2011-07-06 20:37:13 -04:00
|
|
|
#ifdef GUI_OBJECT_STATE_FIX_REQUIRED
|
2010-01-04 19:48:00 -05:00
|
|
|
if (update_xml) {
|
|
|
|
if (!underlay_xml_node) {
|
2008-02-10 13:16:25 -05:00
|
|
|
underlay_xml_node = xml_node->add_child("Underlays");
|
|
|
|
}
|
|
|
|
|
|
|
|
XMLNode* node = underlay_xml_node->add_child("Underlay");
|
2016-05-04 23:09:37 -04:00
|
|
|
XMLProperty const * prop = node->add_property("id");
|
2009-07-09 13:58:13 -04:00
|
|
|
prop->set_value(v->trackview().route()->id().to_s());
|
2008-02-10 13:16:25 -05:00
|
|
|
}
|
2011-07-06 20:37:13 -04:00
|
|
|
#endif
|
2008-02-10 13:16:25 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-01-04 19:48:00 -05:00
|
|
|
RouteTimeAxisView::remove_underlay (StreamView* v)
|
2008-02-10 13:16:25 -05:00
|
|
|
{
|
2010-01-04 19:48:00 -05:00
|
|
|
if (!v) {
|
2008-02-10 13:16:25 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
UnderlayList::iterator it = find(_underlay_streams.begin(), _underlay_streams.end(), v);
|
2009-07-09 13:58:13 -04:00
|
|
|
RouteTimeAxisView& other = v->trackview();
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2010-01-04 19:48:00 -05:00
|
|
|
if (it != _underlay_streams.end()) {
|
2009-07-09 13:58:13 -04:00
|
|
|
UnderlayMirrorList::iterator gm = find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this);
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2010-01-04 19:48:00 -05:00
|
|
|
if (gm == other._underlay_mirrors.end()) {
|
2008-02-10 13:16:25 -05:00
|
|
|
fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
|
2014-11-14 04:47:43 -05:00
|
|
|
abort(); /*NOTREACHED*/
|
2008-02-10 13:16:25 -05:00
|
|
|
}
|
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
v->foreach_regionview(sigc::mem_fun(*this, &RouteTimeAxisView::remove_ghost));
|
2008-02-10 13:16:25 -05:00
|
|
|
|
|
|
|
_underlay_streams.erase(it);
|
2009-07-09 13:58:13 -04:00
|
|
|
other._underlay_mirrors.erase(gm);
|
2008-02-10 13:16:25 -05:00
|
|
|
|
2010-01-04 19:48:00 -05:00
|
|
|
if (underlay_xml_node) {
|
2009-07-09 13:58:13 -04:00
|
|
|
underlay_xml_node->remove_nodes_and_delete("id", v->trackview().route()->id().to_s());
|
2008-02-10 13:16:25 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-02-16 17:43:18 -05:00
|
|
|
|
2009-06-23 16:02:15 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::set_button_names ()
|
|
|
|
{
|
2016-04-08 16:49:47 -04:00
|
|
|
if (_route && _route->solo_safe_control()->solo_safe()) {
|
2013-07-10 20:31:30 -04:00
|
|
|
solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() | Gtkmm2ext::Insensitive));
|
|
|
|
} else {
|
|
|
|
solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() & ~Gtkmm2ext::Insensitive));
|
|
|
|
}
|
|
|
|
if (Config->get_solo_control_is_listen_control()) {
|
|
|
|
switch (Config->get_listen_position()) {
|
|
|
|
case AfterFaderListen:
|
2015-04-04 18:17:53 -04:00
|
|
|
solo_button->set_text (S_("AfterFader|A"));
|
2015-01-05 00:32:14 -05:00
|
|
|
set_tooltip (*solo_button, _("After-fade listen (AFL)"));
|
2013-07-10 20:31:30 -04:00
|
|
|
break;
|
|
|
|
case PreFaderListen:
|
2015-04-04 18:17:53 -04:00
|
|
|
solo_button->set_text (S_("PreFader|P"));
|
2015-01-05 00:32:14 -05:00
|
|
|
set_tooltip (*solo_button, _("Pre-fade listen (PFL)"));
|
2013-07-10 20:31:30 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
2015-04-04 18:17:53 -04:00
|
|
|
solo_button->set_text (S_("Solo|S"));
|
2015-01-05 00:32:14 -05:00
|
|
|
set_tooltip (*solo_button, _("Solo"));
|
2013-07-10 20:31:30 -04:00
|
|
|
}
|
2015-04-04 18:17:53 -04:00
|
|
|
mute_button->set_text (S_("Mute|M"));
|
2009-06-23 16:02:15 -04:00
|
|
|
}
|
2010-05-25 10:50:45 -04:00
|
|
|
|
|
|
|
Gtk::CheckMenuItem*
|
|
|
|
RouteTimeAxisView::automation_child_menu_item (Evoral::Parameter param)
|
|
|
|
{
|
2017-06-09 08:48:33 -04:00
|
|
|
Gtk::CheckMenuItem* rv = StripableTimeAxisView::automation_child_menu_item (param);
|
|
|
|
if (rv) {
|
|
|
|
return rv;
|
2010-06-08 17:48:38 -04:00
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2017-06-09 08:48:33 -04:00
|
|
|
ParameterMenuMap::iterator i = _subplugin_menu_map.find (param);
|
2010-06-08 17:48:38 -04:00
|
|
|
if (i != _subplugin_menu_map.end()) {
|
|
|
|
return i->second;
|
2010-05-25 10:50:45 -04:00
|
|
|
}
|
|
|
|
|
2010-06-08 17:48:38 -04:00
|
|
|
return 0;
|
2010-05-25 10:50:45 -04:00
|
|
|
}
|
2010-09-26 22:04:16 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::create_gain_automation_child (const Evoral::Parameter& param, bool show)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<AutomationControl> c = _route->gain_control();
|
|
|
|
if (!c) {
|
|
|
|
error << "Route has no gain automation, unable to add automation track view." << endmsg;
|
|
|
|
return;
|
|
|
|
}
|
2010-09-27 14:56:26 -04:00
|
|
|
|
2010-09-26 22:04:16 -04:00
|
|
|
gain_track.reset (new AutomationTimeAxisView (_session,
|
2011-02-17 11:18:27 -05:00
|
|
|
_route, _route->amp(), c, param,
|
2010-09-26 22:04:16 -04:00
|
|
|
_editor,
|
|
|
|
*this,
|
|
|
|
false,
|
|
|
|
parent_canvas,
|
|
|
|
_route->amp()->describe_parameter(param)));
|
2011-02-26 18:48:43 -05:00
|
|
|
|
|
|
|
if (_view) {
|
|
|
|
_view->foreach_regionview (sigc::mem_fun (*gain_track.get(), &TimeAxisView::add_ghost));
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-09-26 22:04:16 -04:00
|
|
|
add_automation_child (Evoral::Parameter(GainAutomation), gain_track, show);
|
|
|
|
}
|
2011-05-15 22:17:58 -04:00
|
|
|
|
2015-04-25 14:17:58 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::create_trim_automation_child (const Evoral::Parameter& param, bool show)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<AutomationControl> c = _route->trim()->gain_control();
|
|
|
|
if (!c || ! _route->trim()->active()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
trim_track.reset (new AutomationTimeAxisView (_session,
|
|
|
|
_route, _route->trim(), c, param,
|
|
|
|
_editor,
|
|
|
|
*this,
|
|
|
|
false,
|
|
|
|
parent_canvas,
|
|
|
|
_route->trim()->describe_parameter(param)));
|
|
|
|
|
|
|
|
if (_view) {
|
|
|
|
_view->foreach_regionview (sigc::mem_fun (*trim_track.get(), &TimeAxisView::add_ghost));
|
|
|
|
}
|
|
|
|
|
|
|
|
add_automation_child (Evoral::Parameter(TrimAutomation), trim_track, show);
|
|
|
|
}
|
|
|
|
|
2014-07-01 14:36:58 -04:00
|
|
|
void
|
|
|
|
RouteTimeAxisView::create_mute_automation_child (const Evoral::Parameter& param, bool show)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<AutomationControl> c = _route->mute_control();
|
|
|
|
if (!c) {
|
|
|
|
error << "Route has no mute automation, unable to add automation track view." << endmsg;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mute_track.reset (new AutomationTimeAxisView (_session,
|
|
|
|
_route, _route, c, param,
|
|
|
|
_editor,
|
|
|
|
*this,
|
|
|
|
false,
|
|
|
|
parent_canvas,
|
|
|
|
_route->describe_parameter(param)));
|
|
|
|
|
|
|
|
if (_view) {
|
|
|
|
_view->foreach_regionview (sigc::mem_fun (*mute_track.get(), &TimeAxisView::add_ghost));
|
|
|
|
}
|
|
|
|
|
|
|
|
add_automation_child (Evoral::Parameter(MuteAutomation), mute_track, show);
|
|
|
|
}
|
|
|
|
|
2011-05-15 22:17:58 -04:00
|
|
|
static
|
2012-01-27 11:29:01 -05:00
|
|
|
void add_region_to_list (RegionView* rv, RegionList* l)
|
2011-05-15 22:17:58 -04:00
|
|
|
{
|
|
|
|
l->push_back (rv->region());
|
|
|
|
}
|
|
|
|
|
2011-05-24 20:40:32 -04:00
|
|
|
RegionView*
|
2011-05-16 16:16:57 -04:00
|
|
|
RouteTimeAxisView::combine_regions ()
|
2011-05-15 22:17:58 -04:00
|
|
|
{
|
2011-05-30 07:57:12 -04:00
|
|
|
/* as of may 2011, we do not offer uncombine for MIDI tracks
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!is_audio_track()) {
|
|
|
|
return 0;
|
|
|
|
}
|
2011-05-15 22:17:58 -04:00
|
|
|
|
|
|
|
if (!_view) {
|
2011-05-24 20:40:32 -04:00
|
|
|
return 0;
|
2011-05-15 22:17:58 -04:00
|
|
|
}
|
|
|
|
|
2012-01-27 11:29:01 -05:00
|
|
|
RegionList selected_regions;
|
2011-05-16 16:16:57 -04:00
|
|
|
boost::shared_ptr<Playlist> playlist = track()->playlist();
|
2011-05-15 22:17:58 -04:00
|
|
|
|
2011-05-25 08:19:24 -04:00
|
|
|
_view->foreach_selected_regionview (sigc::bind (sigc::ptr_fun (add_region_to_list), &selected_regions));
|
2011-05-26 13:22:22 -04:00
|
|
|
|
|
|
|
if (selected_regions.size() < 2) {
|
|
|
|
return 0;
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-05-16 16:16:57 -04:00
|
|
|
playlist->clear_changes ();
|
2011-05-25 08:19:24 -04:00
|
|
|
boost::shared_ptr<Region> compound_region = playlist->combine (selected_regions);
|
2011-05-24 20:40:32 -04:00
|
|
|
|
2011-05-16 16:16:57 -04:00
|
|
|
_session->add_command (new StatefulDiffCommand (playlist));
|
2011-05-24 20:40:32 -04:00
|
|
|
/* make the new region be selected */
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-05-24 20:40:32 -04:00
|
|
|
return _view->find_view (compound_region);
|
2011-05-15 22:17:58 -04:00
|
|
|
}
|
2011-05-22 12:11:00 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::uncombine_regions ()
|
|
|
|
{
|
2011-05-30 07:57:12 -04:00
|
|
|
/* as of may 2011, we do not offer uncombine for MIDI tracks
|
|
|
|
*/
|
|
|
|
if (!is_audio_track()) {
|
|
|
|
return;
|
|
|
|
}
|
2011-05-22 12:11:00 -04:00
|
|
|
|
|
|
|
if (!_view) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-01-27 11:29:01 -05:00
|
|
|
RegionList selected_regions;
|
2011-05-22 12:11:00 -04:00
|
|
|
boost::shared_ptr<Playlist> playlist = track()->playlist();
|
|
|
|
|
|
|
|
/* have to grab selected regions first because the uncombine is going
|
|
|
|
* to change that in the middle of the list traverse
|
|
|
|
*/
|
|
|
|
|
2011-05-25 08:19:24 -04:00
|
|
|
_view->foreach_selected_regionview (sigc::bind (sigc::ptr_fun (add_region_to_list), &selected_regions));
|
2011-05-22 12:11:00 -04:00
|
|
|
|
|
|
|
playlist->clear_changes ();
|
|
|
|
|
2012-01-27 11:29:01 -05:00
|
|
|
for (RegionList::iterator i = selected_regions.begin(); i != selected_regions.end(); ++i) {
|
2011-05-22 12:11:00 -04:00
|
|
|
playlist->uncombine (*i);
|
|
|
|
}
|
|
|
|
|
|
|
|
_session->add_command (new StatefulDiffCommand (playlist));
|
|
|
|
}
|
|
|
|
|
2011-07-06 20:37:13 -04:00
|
|
|
string
|
|
|
|
RouteTimeAxisView::state_id() const
|
|
|
|
{
|
|
|
|
return string_compose ("rtav %1", _route->id().to_s());
|
|
|
|
}
|
2011-08-31 15:14:12 -04:00
|
|
|
|
2011-12-11 21:17:17 -05:00
|
|
|
|
|
|
|
void
|
|
|
|
RouteTimeAxisView::remove_child (boost::shared_ptr<TimeAxisView> c)
|
|
|
|
{
|
|
|
|
TimeAxisView::remove_child (c);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-12-11 21:17:17 -05:00
|
|
|
boost::shared_ptr<AutomationTimeAxisView> a = boost::dynamic_pointer_cast<AutomationTimeAxisView> (c);
|
|
|
|
if (a) {
|
|
|
|
for (AutomationTracks::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) {
|
|
|
|
if (i->second == a) {
|
|
|
|
_automation_tracks.erase (i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-06-02 08:54:33 -04:00
|
|
|
|
2016-06-05 15:39:22 -04:00
|
|
|
Gdk::Color
|
|
|
|
RouteTimeAxisView::color () const
|
|
|
|
{
|
|
|
|
return route_color ();
|
|
|
|
}
|
|
|
|
|
2016-06-05 15:19:54 -04:00
|
|
|
bool
|
|
|
|
RouteTimeAxisView::marked_for_display () const
|
|
|
|
{
|
|
|
|
return !_route->presentation_info().hidden();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
RouteTimeAxisView::set_marked_for_display (bool yn)
|
|
|
|
{
|
|
|
|
return RouteUI::mark_hidden (!yn);
|
|
|
|
}
|