#include "ardour_button.h"
#include "audio_streamview.h"
#include "debug.h"
+#include "enums_convert.h"
#include "route_time_axis.h"
#include "automation_time_axis.h"
#include "enums.h"
#include "ardour/track.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace ARDOUR;
using namespace ARDOUR_UI_UTILS;
using std::list;
RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session* sess, ArdourCanvas::Canvas& canvas)
- : AxisView(sess)
- , RouteUI(sess)
+ : RouteUI(sess)
, TimeAxisView(sess,ed,(TimeAxisView*) 0, canvas)
, _view (0)
, parent_canvas (canvas)
parameter_changed ("editor-stereo-only-meters");
}
+void
+RouteTimeAxisView::route_property_changed (const PBD::PropertyChange& what_changed)
+{
+ if (what_changed.contains (ARDOUR::Properties::name)) {
+ label_view ();
+ }
+}
+
void
RouteTimeAxisView::set_route (boost::shared_ptr<Route> rt)
{
gm.get_level_meter().setup_meters(50, meter_width);
gm.update_gain_sensitive ();
- string str = gui_property ("height");
- if (!str.empty()) {
- set_height (atoi (str));
+ uint32_t height;
+ if (get_gui_property ("height", height)) {
+ set_height (height);
} else {
set_height (preset_height (HeightNormal));
}
playlist_button.set_name ("route button");
automation_button.set_name ("route button");
- route_group_button.signal_button_release_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::route_group_click), false);
- playlist_button.signal_clicked.connect (sigc::mem_fun(*this, &RouteTimeAxisView::playlist_click));
- automation_button.signal_clicked.connect (sigc::mem_fun(*this, &RouteTimeAxisView::automation_click));
+ 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);
if (is_track()) {
controls_meters_size_group->add_widget (gm.get_level_meter());
}
+ if (_route->is_master()) {
+ route_group_button.set_sensitive(false);
+ }
+
_route->meter_change.connect (*this, invalidator (*this), bind (&RouteTimeAxisView::meter_changed, this), gui_context());
_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());
_y_position = -1;
_route->processors_changed.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::processors_changed, this, _1), gui_context());
- _route->PropertyChanged.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::route_property_changed, this, _1), gui_context());
if (is_track()) {
- str = gui_property ("layer-display");
- if (!str.empty()) {
- set_layer_display (LayerDisplay (string_2_enum (str, _view->layer_display ())));
+ LayerDisplay layer_display;
+ if (get_gui_property ("layer-display", layer_display)) {
+ set_layer_display (layer_display);
}
track()->FreezeChange.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::map_frozen, this), gui_context());
PropertyList* plist = new PropertyList();
- plist->add (ARDOUR::Properties::mute, true);
- plist->add (ARDOUR::Properties::solo, true);
+ plist->add (ARDOUR::Properties::group_mute, true);
+ plist->add (ARDOUR::Properties::group_solo, true);
route_group_menu = new RouteGroupMenu (_session, plist);
CatchDeletion (this);
}
+string
+RouteTimeAxisView::name() const
+{
+ if (_route) {
+ return _route->name();
+ }
+ return string();
+}
+
void
RouteTimeAxisView::post_construct ()
{
_route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_existing_processor_automation_curves));
}
-gint
+bool
RouteTimeAxisView::route_group_click (GdkEventButton *ev)
{
if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
r.push_back (route ());
route_group_menu->build (r);
- route_group_menu->menu()->popup (ev->button, ev->time);
+ 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);
+ }
- return false;
+ return true;
}
void
if (track_number == 0) {
number_label.set_text ("");
} else {
- number_label.set_text (PBD::to_string (abs(_route->track_number ()), std::dec));
+ number_label.set_text (PBD::to_string (abs(_route->track_number ())));
}
}
}
}
-void
-RouteTimeAxisView::route_property_changed (const PropertyChange& what_changed)
-{
- if (what_changed.contains (ARDOUR::Properties::name)) {
- label_view ();
- }
-}
-
void
RouteTimeAxisView::take_name_changed (void *src)
{
}
}
-void
-RouteTimeAxisView::playlist_click ()
+bool
+RouteTimeAxisView::playlist_click (GdkEventButton *ev)
{
+ if (ev->button != 1) {
+ return true;
+ }
+
build_playlist_menu ();
conditionally_add_to_selection ();
- playlist_action_menu->popup (1, gtk_get_current_event_time());
+ Gtkmm2ext::anchored_menu_popup(playlist_action_menu, &playlist_button,
+ "", 1, ev->time);
+ return true;
}
-void
-RouteTimeAxisView::automation_click ()
+bool
+RouteTimeAxisView::automation_click (GdkEventButton *ev)
{
+ if (ev->button != 1) {
+ return true;
+ }
+
conditionally_add_to_selection ();
build_automation_action_menu (false);
- automation_action_menu->popup (1, gtk_get_current_event_time());
+ Gtkmm2ext::anchored_menu_popup(automation_action_menu, &automation_button,
+ "", 1, ev->time);
+ return true;
}
void
automation_action_menu->set_name ("ArdourContextMenu");
items.push_back (MenuElem (_("Show All Automation"),
- sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_all_automation), for_selection)));
+ sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_all_automation), for_selection)));
items.push_back (MenuElem (_("Show Existing Automation"),
- sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_existing_automation), for_selection)));
+ sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_existing_automation), for_selection)));
items.push_back (MenuElem (_("Hide All Automation"),
- sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::hide_all_automation), for_selection)));
+ sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::hide_all_automation), for_selection)));
/* Attach the plugin submenu. It may have previously been used elsewhere,
so it was detached above
*/
+ bool single_track_selected = (!for_selection || _editor.get_selection().tracks.size() == 1);
+
if (!subplugin_menu.items().empty()) {
items.push_back (SeparatorElem ());
items.push_back (MenuElem (_("Processor automation"), subplugin_menu));
- items.back().set_sensitive (!for_selection || _editor.get_selection().tracks.size() == 1);;
+ items.back().set_sensitive (single_track_selected);
}
/* 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 ());
- gain_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) &&
- (gain_track && string_is_affirmative (gain_track->gui_property ("visible"))));
+ gain_automation_item->set_active (single_track_selected &&
+ string_to<bool>(gain_track->gui_property ("visible")));
_main_automation_menu_map[Evoral::Parameter(GainAutomation)] = gain_automation_item;
}
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 ());
- trim_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) &&
- (trim_track && string_is_affirmative (trim_track->gui_property ("visible"))));
+ trim_automation_item->set_active (single_track_selected &&
+ string_to<bool>(trim_track->gui_property ("visible")));
_main_automation_menu_map[Evoral::Parameter(TrimAutomation)] = trim_automation_item;
}
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 ());
- mute_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) &&
- (mute_track && string_is_affirmative (mute_track->gui_property ("visible"))));
+ mute_automation_item->set_active (single_track_selected &&
+ string_to<bool>(mute_track->gui_property ("visible")));
_main_automation_menu_map[Evoral::Parameter(MuteAutomation)] = mute_automation_item;
}
if (!pan_tracks.empty()) {
items.push_back (CheckMenuElem (_("Pan"), sigc::mem_fun (*this, &RouteTimeAxisView::update_pan_track_visibility)));
pan_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
- pan_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) &&
- (!pan_tracks.empty() && string_is_affirmative (pan_tracks.front()->gui_property ("visible"))));
+ pan_automation_item->set_active (single_track_selected &&
+ string_to<bool>(pan_tracks.front()->gui_property ("visible")));
set<Evoral::Parameter> const & params = _route->pannable()->what_can_be_automated ();
for (set<Evoral::Parameter>::const_iterator p = params.begin(); p != params.end(); ++p) {
int overlaid = 0;
int stacked = 0;
+ int unchangeable = 0;
TrackSelection const & s = _editor.get_selection().tracks;
+
for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) {
StreamView* v = (*i)->view ();
if (!v) {
continue;
}
- switch (v->layer_display ()) {
- case Overlaid:
- ++overlaid;
- break;
- case Stacked:
- case Expanded:
- ++stacked;
- break;
+ if (v->can_change_layer_display()) {
+ switch (v->layer_display ()) {
+ case Overlaid:
+ ++overlaid;
+ break;
+ case Stacked:
+ case Expanded:
+ ++stacked;
+ break;
+ }
+ } else {
+ unchangeable++;
}
}
i->set_inconsistent (overlaid != 0 && stacked != 0);
i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Overlaid, true));
+ if (unchangeable) {
+ i->set_sensitive (false);
+ }
+
layers_items.push_back (RadioMenuElem (layers_group, _("Stacked")));
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), Stacked, true));
+ if (unchangeable) {
+ i->set_sensitive (false);
+ }
+
_ignore_set_layer_display = false;
items.push_back (MenuElem (_("Layers"), *layers_menu));
/* show nothing */
}
+#ifdef XXX_OLD_DESTRUCTIVE_API_XXX
Menu* mode_menu = manage (new Menu);
MenuList& mode_items = mode_menu->items ();
mode_menu->set_name ("ArdourContextMenu");
i->set_inconsistent (non_layered != 0 && (normal != 0 || tape != 0));
items.push_back (MenuElem (_("Record Mode"), *mode_menu));
+#endif
items.push_back (SeparatorElem());
r.push_back (route ());
}
- route_group_menu->build (r);
- items.push_back (MenuElem (_("Group"), *route_group_menu->menu ()));
+ if (!_route->is_master()) {
+ route_group_menu->build (r);
+ items.push_back (MenuElem (_("Group"), *route_group_menu->menu ()));
+ }
build_automation_action_menu (true);
items.push_back (MenuElem (_("Automation"), *automation_action_menu));
items.push_back (MenuElem (_("Remove"), sigc::mem_fun(_editor, &PublicEditor::remove_tracks)));
}
+#ifdef XXX_OLD_DESTRUCTIVE_API_XXX
void
RouteTimeAxisView::set_track_mode (TrackMode mode, bool apply_to_selection)
{
track()->set_mode (mode);
}
}
+#endif
void
RouteTimeAxisView::show_timestretch (framepos_t start, framepos_t end, int layers, int layer)
prompter.set_title (_("Rename Playlist"));
prompter.set_prompt (_("New name for playlist:"));
- prompter.set_initial_text (pl->name());
prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
+ prompter.set_initial_text (pl->name());
prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
- switch (prompter.run ()) {
- case Gtk::RESPONSE_ACCEPT:
+ while (true) {
+ if (prompter.run () != Gtk::RESPONSE_ACCEPT) {
+ break;
+ }
prompter.get_result (name);
if (name.length()) {
- pl->set_name (name);
+ if (_session->playlists->by_name (name)) {
+ 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;
+ }
}
- break;
-
- default:
- break;
}
}
}
void
-RouteTimeAxisView::use_copy_playlist (bool prompt, vector<boost::shared_ptr<Playlist> > const & playlists_before_op)
+RouteTimeAxisView::use_new_playlist (bool prompt, vector<boost::shared_ptr<Playlist> > const & playlists_before_op, bool copy)
{
string name;
name = pl->name();
- if (route_group() && route_group()->is_active() && route_group()->enabled_property (ARDOUR::Properties::select.property_id)) {
- name = resolve_new_group_playlist_name(name, playlists_before_op);
+ if (route_group() && route_group()->is_active() && route_group()->enabled_property (ARDOUR::Properties::group_select.property_id)) {
+ name = resolve_new_group_playlist_name(name,playlists_before_op);
}
while (_session->playlists->by_name(name)) {
name = Playlist::bump_name (name, *_session);
}
- // TODO: The prompter "new" button should be de-activated if the user
- // specifies a playlist name which already exists in the session.
-
if (prompt) {
+ // TODO: The prompter "new" button should be de-activated if the user
+ // specifies a playlist name which already exists in the session.
ArdourPrompter prompter (true);
- prompter.set_title (_("New Copy Playlist"));
- prompter.set_prompt (_("Name for new playlist:"));
+ 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:"));
+ }
prompter.set_initial_text (name);
prompter.add_button (Gtk::Stock::NEW, Gtk::RESPONSE_ACCEPT);
prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, true);
prompter.show_all ();
- switch (prompter.run ()) {
- case Gtk::RESPONSE_ACCEPT:
+ while (true) {
+ if (prompter.run () != Gtk::RESPONSE_ACCEPT) {
+ return;
+ }
prompter.get_result (name);
- break;
-
- default:
- return;
+ if (name.length()) {
+ if (_session->playlists->by_name (name)) {
+ MessageDialog msg (_("Given playlist name is not unique."));
+ msg.run ();
+ prompter.set_initial_text (Playlist::bump_name (name, *_session));
+ } else {
+ break;
+ }
+ }
}
}
if (name.length()) {
- tr->use_copy_playlist ();
- tr->playlist()->set_name (name);
- }
-}
-
-void
-RouteTimeAxisView::use_new_playlist (bool prompt, vector<boost::shared_ptr<Playlist> > const & playlists_before_op)
-{
- string name;
-
- boost::shared_ptr<Track> tr = track ();
- if (!tr || tr->destructive()) {
- return;
- }
-
- boost::shared_ptr<const Playlist> pl = tr->playlist();
- if (!pl) {
- return;
- }
-
- name = pl->name();
-
- if (route_group() && route_group()->is_active() && route_group()->enabled_property (ARDOUR::Properties::select.property_id)) {
- name = resolve_new_group_playlist_name(name,playlists_before_op);
- }
-
- while (_session->playlists->by_name(name)) {
- name = Playlist::bump_name (name, *_session);
- }
-
-
- if (prompt) {
-
- ArdourPrompter prompter (true);
-
- prompter.set_title (_("New Playlist"));
- prompter.set_prompt (_("Name for new playlist:"));
- prompter.set_initial_text (name);
- prompter.add_button (Gtk::Stock::NEW, Gtk::RESPONSE_ACCEPT);
- prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, true);
-
- switch (prompter.run ()) {
- case Gtk::RESPONSE_ACCEPT:
- prompter.get_result (name);
- break;
-
- default:
- return;
+ if (copy) {
+ tr->use_copy_playlist ();
+ } else {
+ tr->use_new_playlist ();
}
- }
-
- if (name.length()) {
- tr->use_new_playlist ();
tr->playlist()->set_name (name);
}
}
return _route->route_group();
}
-string
-RouteTimeAxisView::name() const
-{
- return _route->name();
-}
-
boost::shared_ptr<Playlist>
RouteTimeAxisView::playlist () const
{
}
string x = str;
-
+
strip_whitespace_edges (x);
if (x.empty()) {
}
bool
-RouteTimeAxisView::paste (framepos_t pos, const Selection& selection, PasteContext& ctx)
+RouteTimeAxisView::paste (framepos_t pos, const Selection& selection, PasteContext& ctx, const int32_t sub_num)
{
if (!is_track()) {
return false;
framecnt_t amount = extent.second - extent.first;
pl->ripple(pos, amount * ctx.times, boost::shared_ptr<Region>());
}
- pl->paste (*p, pos, ctx.times);
+ pl->paste (*p, pos, ctx.times, sub_num);
vector<Command*> cmds;
pl->rdiff (cmds);
playlist_items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteTimeAxisView::rename_current_playlist)));
playlist_items.push_back (SeparatorElem());
- if (!route_group() || !route_group()->is_active() || !route_group()->enabled_property (ARDOUR::Properties::select.property_id)) {
+ if (!route_group() || !route_group()->is_active() || !route_group()->enabled_property (ARDOUR::Properties::group_select.property_id)) {
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)));
RouteGroup* rg = route_group();
- if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::select.property_id)) {
+ if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::group_select.property_id)) {
std::string group_string = "." + rg->name() + ".";
std::string take_name = pl->name();
RouteTimeAxisView::update_playlist_tip ()
{
RouteGroup* rg = route_group ();
- if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::select.property_id)) {
+ if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::group_select.property_id)) {
string group_string = "." + rg->name() + ".";
string take_name = track()->playlist()->name();
{
bool const showit = gain_automation_item->get_active();
- if (showit != string_is_affirmative (gain_track->gui_property ("visible"))) {
+ bool visible;
+ if (gain_track->get_gui_property ("visible", visible) && visible != showit) {
gain_track->set_marked_for_display (showit);
/* now trigger a redisplay */
{
bool const showit = trim_automation_item->get_active();
- if (showit != string_is_affirmative (trim_track->gui_property ("visible"))) {
+ bool visible;
+ if (trim_track->get_gui_property ("visible", visible) && visible != showit) {
trim_track->set_marked_for_display (showit);
/* now trigger a redisplay */
{
bool const showit = mute_automation_item->get_active();
- if (showit != string_is_affirmative (mute_track->gui_property ("visible"))) {
+ bool visible;
+ if (mute_track->get_gui_property ("visible", visible) && visible != showit) {
mute_track->set_marked_for_display (showit);
/* now trigger a redisplay */
_automation_tracks[param] = track;
/* existing state overrides "show" argument */
- string s = track->gui_property ("visible");
- if (!s.empty()) {
- show = string_is_affirmative (s);
+ bool visible;
+ if (track->get_gui_property ("visible", visible)) {
+ show = visible;
}
/* this might or might not change the visibility status, so don't rely on it */
_view->set_layer_display (d);
}
- set_gui_property (X_("layer-display"), enum_2_string (d));
+ set_gui_property (X_("layer-display"), d);
}
}
}
}
-PresentationInfo const &
-RouteTimeAxisView::presentation_info () const
+Gdk::Color
+RouteTimeAxisView::color () const
+{
+ return route_color ();
+}
+
+bool
+RouteTimeAxisView::marked_for_display () const
{
- return _route->presentation_info();
+ return !_route->presentation_info().hidden();
}
-boost::shared_ptr<Stripable>
-RouteTimeAxisView::stripable () const
+bool
+RouteTimeAxisView::set_marked_for_display (bool yn)
{
- return _route;
+ return RouteUI::mark_hidden (!yn);
}
projects / ardour.git / blobdiff