X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Froute_ui.cc;h=cefe2ac517e4c84b72c860ef8021de5e735f4a47;hb=2e1332f74f803a1be4c8bb4911266aef4b63f145;hp=a838934b27343c4cf47631f9601abbecb99d13a0;hpb=c71fc0272da4196f4bc14060f2c6bddcce76f823;p=ardour.git diff --git a/gtk2_ardour/route_ui.cc b/gtk2_ardour/route_ui.cc index a838934b27..cefe2ac517 100644 --- a/gtk2_ardour/route_ui.cc +++ b/gtk2_ardour/route_ui.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2002 Paul Davis + Copyright (C) 2002-2006 Paul Davis 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 @@ -15,94 +15,200 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ #include #include #include -#include #include +#include +#include +#include #include +#include +#include +#include +#include #include "route_ui.h" #include "keyboard.h" #include "utils.h" #include "prompter.h" #include "gui_thread.h" +#include "ardour_dialog.h" +#include "latency_gui.h" +#include "automation_time_axis.h" #include +#include +#include #include -#include +#include +#include +#include +#include #include "i18n.h" using namespace sigc; using namespace Gtk; using namespace Gtkmm2ext; using namespace ARDOUR; +using namespace PBD; + +RouteUI::RouteUI (ARDOUR::Session& sess, const char* mute_name, const char* solo_name, const char* rec_name) + : AxisView(sess) +{ + init (); + set_button_names (mute_name, solo_name, rec_name); +} + +RouteUI::RouteUI (boost::shared_ptr rt, + ARDOUR::Session& sess, const char* mute_name, const char* solo_name, const char* rec_name) + : AxisView(sess) +{ + init (); + set_button_names (mute_name, solo_name, rec_name); + set_route (rt); +} + +RouteUI::~RouteUI() +{ + GoingAway (); /* EMIT SIGNAL */ + delete solo_menu; + delete mute_menu; + delete remote_control_menu; +} -RouteUI::RouteUI (ARDOUR::Route& rt, ARDOUR::Session& sess, const char* m_name, - const char* s_name, const char* r_name) - : AxisView(sess), - _route(rt), - mute_button(0), - solo_button(0), - rec_enable_button(0) +void +RouteUI::init () { xml_node = 0; mute_menu = 0; solo_menu = 0; + remote_control_menu = 0; ignore_toggle = false; wait_for_release = false; route_active_menu_item = 0; + was_solo_safe = false; + polarity_menu_item = 0; + denormal_menu_item = 0; + multiple_mute_change = false; + multiple_solo_change = false; + + mute_button = manage (new BindableToggleButton ("")); + mute_button->set_self_managed (true); + mute_button->set_name ("MuteButton"); + UI::instance()->set_tip (mute_button, _("Mute this track"), ""); + + solo_button = manage (new BindableToggleButton ("")); + solo_button->set_self_managed (true); + solo_button->set_name ("SoloButton"); + UI::instance()->set_tip (solo_button, _("Mute other (non-soloed) tracks"), ""); + + rec_enable_button = manage (new BindableToggleButton ("")); + rec_enable_button->set_name ("RecordEnableButton"); + rec_enable_button->set_self_managed (true); + UI::instance()->set_tip (rec_enable_button, _("Enable recording on this track"), ""); + + _session.SoloChanged.connect (mem_fun(*this, &RouteUI::solo_changed_so_update_mute)); +} + +void +RouteUI::reset () +{ + connections.clear (); + + delete solo_menu; + solo_menu = 0; + + delete mute_menu; + mute_menu = 0; + + if (xml_node) { + /* do not delete the node - its owned by the route */ + xml_node = 0; + } + + route_active_menu_item = 0; + polarity_menu_item = 0; + denormal_menu_item = 0; +} + +void +RouteUI::set_button_names (const char* mute, const char* solo, const char* rec) +{ + m_name = mute; + s_name = solo; + r_name = rec; +} + +void +RouteUI::set_route (boost::shared_ptr rp) +{ + reset (); + + _route = rp; if (set_color_from_route()) { set_color (unique_random_color()); } - _route.GoingAway.connect (mem_fun (*this, &RouteUI::route_removed)); - _route.active_changed.connect (mem_fun (*this, &RouteUI::route_active_changed)); + /* no, there is no memory leak here. This object cleans itself (and other stuff) + up when the route is destroyed. + */ - mute_button = manage (new BindableToggleButton (& _route.midi_mute_control(), m_name )); - mute_button->set_bind_button_state (2, GDK_CONTROL_MASK); - solo_button = manage (new BindableToggleButton (& _route.midi_solo_control(), s_name )); - solo_button->set_bind_button_state (2, GDK_CONTROL_MASK); + new PairedShiva (*_route, *this); + + mute_button->set_controllable (_route->mute_control()); + mute_button->set_label (m_name); + + solo_button->set_controllable (_route->solo_control()); + solo_button->set_label (s_name); + + connections.push_back (_route->active_changed.connect (mem_fun (*this, &RouteUI::route_active_changed))); + connections.push_back (_route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed))); + connections.push_back (_route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed))); + connections.push_back (_route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed))); + + /* when solo changes, update mute state too, in case the user wants us to display it */ - if (is_audio_track()) { - AudioTrack* at = dynamic_cast(&_route); + _session.SoloChanged.connect (mem_fun(*this, &RouteUI::solo_changed_so_update_mute)); + + if (is_track()) { + boost::shared_ptr t = boost::dynamic_pointer_cast(_route); - get_diskstream()->record_enable_changed.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed)); + connections.push_back (t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed))); + connections.push_back (_session.RecordStateChanged.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed))); - _session.RecordEnabled.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed)); - _session.RecordDisabled.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed)); + rec_enable_button->show(); + rec_enable_button->set_controllable (t->rec_enable_control()); + rec_enable_button->set_label (r_name); - rec_enable_button = manage (new BindableToggleButton (& at->midi_rec_enable_control(), r_name )); - rec_enable_button->set_bind_button_state (2, GDK_CONTROL_MASK); + update_rec_display (); + } - } else { - rec_enable_button = manage (new BindableToggleButton (0, r_name )); - } - mute_button->unset_flags (Gtk::CAN_FOCUS); solo_button->unset_flags (Gtk::CAN_FOCUS); - rec_enable_button->unset_flags (Gtk::CAN_FOCUS); + + mute_button->show(); + solo_button->show(); + + connections.push_back (_route->RemoteControlIDChanged.connect (mem_fun(*this, &RouteUI::refresh_remote_control_menu))); /* map the current state */ - update_rec_display (); map_frozen (); } -RouteUI::~RouteUI() -{ - delete mute_menu; -} - -gint +bool RouteUI::mute_press(GdkEventButton* ev) { + if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) { + return true; + } + multiple_mute_change = false; if (!ignore_toggle) { if (Keyboard::is_context_menu_event (ev)) { @@ -111,177 +217,240 @@ RouteUI::mute_press(GdkEventButton* ev) build_mute_menu(); } - mute_menu->popup(0,0); + mute_menu->popup(0,ev->time); } else { - if (ev->button == 2) { - // ctrl-button2 click is the midi binding click + if (Keyboard::is_button2_event (ev)) { + // Primary-button2 click is the midi binding click // button2-click is "momentary" - if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::Control))) { + if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier))) { wait_for_release = true; + } else { + return false; } } - if (ev->button == 1 || ev->button == 2) { + if (ev->button == 1 || Keyboard::is_button2_event (ev)) { - if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Shift))) { + if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { - /* ctrl-shift-click applies change to all routes */ + /* Primary-Tertiary-click applies change to all routes */ _session.begin_reversible_command (_("mute change")); - _session.add_undo (_session.global_mute_memento(this)); - _session.set_all_mute (!_route.muted()); - _session.add_redo_no_execute (_session.global_mute_memento(this)); + Session::GlobalMuteStateCommand *cmd = new Session::GlobalMuteStateCommand(_session, this); + _session.set_all_mute (!_route->muted()); + cmd->mark(); + _session.add_command(cmd); _session.commit_reversible_command (); + multiple_mute_change = true; - } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) { + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { - /* ctrl-click applies change to the mix group. - ctrl-button2 is MIDI learn. + /* Primary-button1 applies change to the mix group. + NOTE: Primary-button2 is MIDI learn. */ if (ev->button == 1) { - set_mix_group_mute (_route, !_route.muted()); + set_mix_group_mute (_route, !_route->muted()); } } else { /* plain click applies change to this route */ - - reversibly_apply_route_boolean ("mute change", &Route::set_mute, !_route.muted(), this); + if (wait_for_release) { + _route->set_mute (!_route->muted(), this); + } else { + reversibly_apply_route_boolean ("mute change", &Route::set_mute, !_route->muted(), this); + } } } } } - return stop_signal (*mute_button, "button-press-event"); + return true; } -gint +bool RouteUI::mute_release(GdkEventButton* ev) { if (!ignore_toggle) { if (wait_for_release){ wait_for_release = false; - // undo the last op - // because the press was the last undoable thing we did - _session.undo (1U); - stop_signal (*mute_button, "button-release-event"); + if (multiple_mute_change) { + multiple_mute_change = false; + // undo the last op + // because the press was the last undoable thing we did + _session.undo (1U); + } else { + _route->set_mute (!_route->muted(), this); + } } } - return TRUE; + return true; } -gint +bool RouteUI::solo_press(GdkEventButton* ev) { + /* ignore double/triple clicks */ + + if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) { + return true; + } + multiple_solo_change = false; if (!ignore_toggle) { if (Keyboard::is_context_menu_event (ev)) { - + if (solo_menu == 0) { build_solo_menu (); } - solo_menu->popup (1, 0); + solo_menu->popup (1, ev->time); } else { - if (ev->button == 2) { + if (Keyboard::is_button2_event (ev)) { - // ctrl-button2 click is the midi binding click + // Primary-button2 click is the midi binding click // button2-click is "momentary" - if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::Control))) { + if (!Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier))) { wait_for_release = true; + } else { + return false; } } - if (ev->button == 1 || ev->button == 2) { + if (ev->button == 1 || Keyboard::is_button2_event (ev)) { - if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Shift))) { - - /* ctrl-shift-click applies change to all routes */ + if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { + /* Primary-Tertiary-click applies change to all routes */ + bool was_not_latched = false; + if (!Config->get_solo_latched ()) { + was_not_latched = true; + /* + XXX it makes no sense to solo all tracks if we're + not in latched mode, but doing nothing feels like a bug, + so do it anyway + */ + Config->set_solo_latched (true); + } _session.begin_reversible_command (_("solo change")); - _session.add_undo (_session.global_solo_memento(this)); - _session.set_all_solo (!_route.soloed()); - _session.add_redo_no_execute (_session.global_solo_memento(this)); + Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand(_session, this); + _session.set_all_solo (!_route->soloed()); + cmd->mark(); + _session.add_command (cmd); _session.commit_reversible_command (); + multiple_solo_change = true; + if (was_not_latched) { + Config->set_solo_latched (false); + } - } else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Alt))) { + } else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) { - // ctrl-alt-click: exclusively solo this track, not a toggle */ + // Primary-Secondary-click: exclusively solo this track, not a toggle */ _session.begin_reversible_command (_("solo change")); - _session.add_undo (_session.global_solo_memento(this)); + Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand (_session, this); _session.set_all_solo (false); - _route.set_solo (true, this); - _session.add_redo_no_execute (_session.global_solo_memento(this)); + _route->set_solo (true, this); + cmd->mark(); + _session.add_command(cmd); _session.commit_reversible_command (); - } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) { + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) { // shift-click: set this route to solo safe - _route.set_solo_safe (!_route.solo_safe(), this); - wait_for_release = false; + if (Profile->get_sae() && ev->button == 1) { + // button 1 and shift-click: disables solo_latched for this click + if (!Config->get_solo_latched ()) { + Config->set_solo_latched (true); + reversibly_apply_route_boolean ("solo change", &Route::set_solo, !_route->soloed(), this); + Config->set_solo_latched (false); + } + } else { + _route->set_solo_safe (!_route->solo_safe(), this); + wait_for_release = false; + } - } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) { + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { - /* ctrl-click: solo mix group. - ctrl-button2 is MIDI learn. + /* Primary-button1: solo mix group. + NOTE: Primary-button2 is MIDI learn. */ if (ev->button == 1) { - set_mix_group_solo (_route, !_route.soloed()); + set_mix_group_solo (_route, !_route->soloed()); } } else { /* click: solo this route */ - - reversibly_apply_route_boolean ("solo change", &Route::set_solo, !_route.soloed(), this); + if (wait_for_release) { + _route->set_solo (!_route->soloed(), this); + } else { + reversibly_apply_route_boolean ("solo change", &Route::set_solo, !_route->soloed(), this); + } } } } } - return stop_signal (*solo_button, "button-press-event"); + return true; } -gint +bool RouteUI::solo_release(GdkEventButton* ev) { - if(!ignore_toggle){ - if (wait_for_release){ + if (!ignore_toggle) { + if (wait_for_release) { wait_for_release = false; - // undo the last op - // because the press was the last undoable thing we did - - _session.undo (1U); - - stop_signal (*solo_button, "button-release-event"); + if (multiple_solo_change) { + multiple_solo_change = false; + // undo the last op + // because the press was the last undoable thing we did + _session.undo (1U); + } else { + // we don't use "undo the last op" + // here because its expensive for the GUI + _route->set_solo (!_route->soloed(), this); + } } } - return TRUE; + + return true; } -gint +bool RouteUI::rec_enable_press(GdkEventButton* ev) { - if (!ignore_toggle && is_audio_track()) { + if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) { + return true; + } + + if (!_session.engine().connected()) { + MessageDialog msg (_("Not connected to JACK - cannot engage record")); + msg.run (); + return true; + } + + if (!ignore_toggle && is_track() && rec_enable_button) { + + if (Keyboard::is_button2_event (ev) && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { - if (ev->button == 2 && Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) { // do nothing on midi bind event - } - else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Shift))) { + return false; + + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) { _session.begin_reversible_command (_("rec-enable change")); - _session.add_undo (_session.global_record_enable_memento(this)); + Session::GlobalRecordEnableStateCommand *cmd = new Session::GlobalRecordEnableStateCommand(_session, this); if (rec_enable_button->get_active()) { _session.record_disenable_all (); @@ -289,31 +458,37 @@ RouteUI::rec_enable_press(GdkEventButton* ev) _session.record_enable_all (); } - _session.add_redo_no_execute (_session.global_record_enable_memento(this)); + cmd->mark(); + _session.add_command(cmd); _session.commit_reversible_command (); - } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) { + } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { - set_mix_group_rec_enable (_route, !_route.record_enabled()); + /* Primary-button1 applies change to the mix group. + NOTE: Primary-button2 is MIDI learn. + */ - } else { + set_mix_group_rec_enable (_route, !_route->record_enabled()); - reversibly_apply_audio_track_boolean ("rec-enable change", &AudioTrack::set_record_enable, !audio_track()->record_enabled(), this); + } else { - ignore_toggle = true; - rec_enable_button->set_active(audio_track()->record_enabled()); - ignore_toggle = false; + reversibly_apply_track_boolean ("rec-enable change", &Track::set_record_enable, !track()->record_enabled(), this); } - - stop_signal (*rec_enable_button, "button-press-event"); } - return TRUE; + return true; +} + +bool +RouteUI::rec_enable_release (GdkEventButton* ev) +{ + return true; } void RouteUI::solo_changed(void* src) { + Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_solo_display)); } @@ -321,22 +496,30 @@ void RouteUI::update_solo_display () { bool x; - - if (solo_button->get_active() != (x = _route.soloed())){ + vector fg_colors; + Gdk::Color c; + + if (solo_button->get_active() != (x = _route->soloed())){ ignore_toggle = true; solo_button->set_active(x); ignore_toggle = false; - } + } - /* show solo safe */ - - if (_route.solo_safe()){ - solo_button->set_name(safe_solo_button_name()); + if (_route->solo_safe()) { + solo_button->set_visual_state (2); + } else if (_route->soloed()) { + solo_button->set_visual_state (1); } else { - solo_button->set_name(solo_button_name()); + solo_button->set_visual_state (0); } } +void +RouteUI::solo_changed_so_update_mute () +{ + Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_mute_display)); +} + void RouteUI::mute_changed(void* src) { @@ -346,17 +529,42 @@ RouteUI::mute_changed(void* src) void RouteUI::update_mute_display () { - bool x; + bool model = _route->muted(); + bool view = mute_button->get_active(); - if (mute_button->get_active() != (x = _route.muted())){ + /* first make sure the button's "depressed" visual + is correct. + */ + + if (model != view) { ignore_toggle = true; - mute_button->set_active(x); + mute_button->set_active (model); ignore_toggle = false; } + + /* now attend to visual state */ + + if (Config->get_show_solo_mutes()) { + if (_route->muted()) { + mute_button->set_visual_state (2); + } else if (!_route->soloed() && _route->solo_muted()) { + + mute_button->set_visual_state (1); + } else { + mute_button->set_visual_state (0); + } + } else { + if (_route->muted()) { + mute_button->set_visual_state (2); + } else { + mute_button->set_visual_state (0); + } + } + } void -RouteUI::route_rec_enable_changed (void *src) +RouteUI::route_rec_enable_changed () { Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_rec_display)); } @@ -370,42 +578,103 @@ RouteUI::session_rec_enable_changed () void RouteUI::update_rec_display () { - bool model = _route.record_enabled(); + bool model = _route->record_enabled(); bool view = rec_enable_button->get_active(); /* first make sure the button's "depressed" visual is correct. */ - + if (model != view) { ignore_toggle = true; rec_enable_button->set_active (model); ignore_toggle = false; } - + /* now make sure its color state is correct */ if (model) { switch (_session.record_status ()) { + case Session::Recording: + rec_enable_button->set_visual_state (1); + break; + case Session::Disabled: case Session::Enabled: - if (rec_enable_button->get_state() != Gtk::STATE_ACTIVE) { - rec_enable_button->set_state (Gtk::STATE_ACTIVE); - } + rec_enable_button->set_visual_state (2); break; - case Session::Recording: - if (rec_enable_button->get_state() != Gtk::STATE_SELECTED) { - rec_enable_button->set_state (Gtk::STATE_SELECTED); - } - break; } } else { - if (rec_enable_button->get_state() != Gtk::STATE_NORMAL) { - rec_enable_button->set_state (Gtk::STATE_NORMAL); + rec_enable_button->set_visual_state (0); + } +} + +void +RouteUI::build_remote_control_menu () +{ + remote_control_menu = new Menu; + refresh_remote_control_menu (); +} + +void +RouteUI::refresh_remote_control_menu () +{ + ENSURE_GUI_THREAD (mem_fun (*this, &RouteUI::refresh_remote_control_menu)); + + // only refresh the menu if it has been instantiated + + if (remote_control_menu == 0) { + return; + } + + using namespace Menu_Helpers; + + RadioMenuItem::Group rc_group; + CheckMenuItem* rc_active; + uint32_t limit = _session.ntracks() + _session.nbusses(); + char buf[32]; + + MenuList& rc_items = remote_control_menu->items(); + rc_items.clear (); + + /* note that this menu list starts at zero, not 1, because zero + is a valid, if useless, ID. + */ + + limit += 4; /* leave some breathing room */ + + rc_items.push_back (RadioMenuElem (rc_group, _("None"))); + if (_route->remote_control_id() == 0) { + rc_active = dynamic_cast (&rc_items.back()); + rc_active->set_active (); + } + + for (uint32_t i = 1; i < limit; ++i) { + snprintf (buf, sizeof (buf), "%u", i); + rc_items.push_back (RadioMenuElem (rc_group, buf)); + rc_active = dynamic_cast(&rc_items.back()); + if (_route->remote_control_id() == i) { + rc_active = dynamic_cast (&rc_items.back()); + rc_active->set_active (); } + rc_active->signal_activate().connect (bind (mem_fun (*this, &RouteUI::set_remote_control_id), i, rc_active)); + } +} + +void +RouteUI::set_remote_control_id (uint32_t id, CheckMenuItem* item) +{ + /* this is called when the radio menu item is toggled, and so + is actually invoked twice per menu selection. we only + care about the invocation for the item that was being + marked active. + */ + + if (item->get_active()) { + _route->set_remote_control_id (id); } } @@ -420,14 +689,14 @@ RouteUI::build_solo_menu (void) CheckMenuItem* check; check = new CheckMenuItem(_("Solo-safe")); - check->set_active (_route.solo_safe()); + check->set_active (_route->solo_safe()); check->signal_toggled().connect (bind (mem_fun (*this, &RouteUI::toggle_solo_safe), check)); - _route.solo_safe_changed.connect(bind (mem_fun (*this, &RouteUI::solo_safe_toggle), check)); + _route->solo_safe_changed.connect(bind (mem_fun (*this, &RouteUI::solo_safe_toggle), check)); items.push_back (CheckMenuElem(*check)); check->show_all(); - items.push_back (SeparatorElem()); - items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn))); + //items.push_back (SeparatorElem()); + // items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn))); } @@ -444,39 +713,39 @@ RouteUI::build_mute_menu(void) check = new CheckMenuItem(_("Pre Fader")); init_mute_menu(PRE_FADER, check); check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), PRE_FADER, check)); - _route.pre_fader_changed.connect(bind (mem_fun (*this, &RouteUI::pre_fader_toggle), check)); + _route->pre_fader_changed.connect(bind (mem_fun (*this, &RouteUI::pre_fader_toggle), check)); items.push_back (CheckMenuElem(*check)); check->show_all(); check = new CheckMenuItem(_("Post Fader")); init_mute_menu(POST_FADER, check); check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), POST_FADER, check)); - _route.post_fader_changed.connect(bind (mem_fun (*this, &RouteUI::post_fader_toggle), check)); + _route->post_fader_changed.connect(bind (mem_fun (*this, &RouteUI::post_fader_toggle), check)); items.push_back (CheckMenuElem(*check)); check->show_all(); check = new CheckMenuItem(_("Control Outs")); init_mute_menu(CONTROL_OUTS, check); check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), CONTROL_OUTS, check)); - _route.control_outs_changed.connect(bind (mem_fun (*this, &RouteUI::control_outs_toggle), check)); + _route->control_outs_changed.connect(bind (mem_fun (*this, &RouteUI::control_outs_toggle), check)); items.push_back (CheckMenuElem(*check)); check->show_all(); check = new CheckMenuItem(_("Main Outs")); init_mute_menu(MAIN_OUTS, check); check->signal_toggled().connect(bind (mem_fun (*this, &RouteUI::toggle_mute_menu), MAIN_OUTS, check)); - _route.main_outs_changed.connect(bind (mem_fun (*this, &RouteUI::main_outs_toggle), check)); + _route->main_outs_changed.connect(bind (mem_fun (*this, &RouteUI::main_outs_toggle), check)); items.push_back (CheckMenuElem(*check)); check->show_all(); - items.push_back (SeparatorElem()); - items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn))); + //items.push_back (SeparatorElem()); + // items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn))); } void RouteUI::init_mute_menu(mute_type type, CheckMenuItem* check) { - if (_route.get_mute_config (type)) { + if (_route->get_mute_config (type)) { check->set_active (true); } } @@ -484,28 +753,29 @@ RouteUI::init_mute_menu(mute_type type, CheckMenuItem* check) void RouteUI::toggle_mute_menu(mute_type type, Gtk::CheckMenuItem* check) { - _route.set_mute_config(type, check->get_active(), this); + _route->set_mute_config(type, check->get_active(), this); } void RouteUI::toggle_solo_safe (Gtk::CheckMenuItem* check) { - _route.set_solo_safe (check->get_active(), this); + _route->set_solo_safe (check->get_active(), this); } void -RouteUI::set_mix_group_solo(Route& route, bool yn) +RouteUI::set_mix_group_solo(boost::shared_ptr route, bool yn) { RouteGroup* mix_group; - if((mix_group = route.mix_group()) != 0){ + if((mix_group = route->mix_group()) != 0){ _session.begin_reversible_command (_("mix group solo change")); - _session.add_undo (_session.global_solo_memento (this)); + Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand(_session, this); mix_group->apply(&Route::set_solo, yn, this); - _session.add_redo_no_execute (_session.global_solo_memento(this)); + cmd->mark(); + _session.add_command (cmd); _session.commit_reversible_command (); } else { - reversibly_apply_route_boolean ("solo change", &Route::set_solo, !route.soloed(), this); + reversibly_apply_route_boolean ("solo change", &Route::set_solo, !route->soloed(), this); } } @@ -513,49 +783,55 @@ void RouteUI::reversibly_apply_route_boolean (string name, void (Route::*func)(bool, void *), bool yn, void *arg) { _session.begin_reversible_command (name); - _session.add_undo (bind (mem_fun (_route, func), !yn, (void *) arg)); - _session.add_redo (bind (mem_fun (_route, func), yn, (void *) arg)); + XMLNode &before = _route->get_state(); + bind(mem_fun(*_route, func), yn, arg)(); + XMLNode &after = _route->get_state(); + _session.add_command (new MementoCommand(*_route, &before, &after)); _session.commit_reversible_command (); } void -RouteUI::reversibly_apply_audio_track_boolean (string name, void (AudioTrack::*func)(bool, void *), bool yn, void *arg) +RouteUI::reversibly_apply_track_boolean (string name, void (Track::*func)(bool, void *), bool yn, void *arg) { _session.begin_reversible_command (name); - _session.add_undo (bind (mem_fun (*audio_track(), func), !yn, (void *) arg)); - _session.add_redo (bind (mem_fun (*audio_track(), func), yn, (void *) arg)); + XMLNode &before = track()->get_state(); + bind (mem_fun (*track(), func), yn, arg)(); + XMLNode &after = track()->get_state(); + _session.add_command (new MementoCommand(*track(), &before, &after)); _session.commit_reversible_command (); } void -RouteUI::set_mix_group_mute(Route& route, bool yn) +RouteUI::set_mix_group_mute(boost::shared_ptr route, bool yn) { RouteGroup* mix_group; - if((mix_group = route.mix_group()) != 0){ + if((mix_group = route->mix_group()) != 0){ _session.begin_reversible_command (_("mix group mute change")); - _session.add_undo (_session.global_mute_memento (this)); + Session::GlobalMuteStateCommand *cmd = new Session::GlobalMuteStateCommand (_session, this); mix_group->apply(&Route::set_mute, yn, this); - _session.add_redo_no_execute (_session.global_mute_memento(this)); + cmd->mark(); + _session.add_command(cmd); _session.commit_reversible_command (); } else { - reversibly_apply_route_boolean ("mute change", &Route::set_mute, !route.muted(), this); + reversibly_apply_route_boolean ("mute change", &Route::set_mute, !route->muted(), this); } } void -RouteUI::set_mix_group_rec_enable(Route& route, bool yn) +RouteUI::set_mix_group_rec_enable(boost::shared_ptr route, bool yn) { RouteGroup* mix_group; - if((mix_group = route.mix_group()) != 0){ + if((mix_group = route->mix_group()) != 0){ _session.begin_reversible_command (_("mix group rec-enable change")); - _session.add_undo (_session.global_record_enable_memento (this)); + Session::GlobalRecordEnableStateCommand *cmd = new Session::GlobalRecordEnableStateCommand(_session, this); mix_group->apply (&Route::set_record_enable, yn, this); - _session.add_redo_no_execute (_session.global_record_enable_memento(this)); + cmd->mark(); + _session.add_command(cmd); _session.commit_reversible_command (); } else { - reversibly_apply_route_boolean ("rec-enable change", &Route::set_record_enable, !_route.record_enabled(), this); + reversibly_apply_route_boolean ("rec-enable change", &Route::set_record_enable, !_route->record_enabled(), this); } } @@ -565,14 +841,8 @@ RouteUI::choose_color() { bool picked; Gdk::Color color; - Gdk::Color current; - current.set_red ( _color.get_red() / 65535.0); - current.set_green (_color.get_green() / 65535.0); - current.set_blue (_color.get_blue() / 65535.0); - //current[3] = 1.0; - - color = Gtkmm2ext::UI::instance()->get_color (_("ardour: color selection"), picked, ¤t); + color = Gtkmm2ext::UI::instance()->get_color (_("ardour: color selection"), picked, &_color); if (picked) { set_color (color); @@ -582,7 +852,7 @@ RouteUI::choose_color() } void -RouteUI::set_color (Gdk::Color c) +RouteUI::set_color (const Gdk::Color & c) { char buf[64]; @@ -592,7 +862,7 @@ RouteUI::set_color (Gdk::Color c) snprintf (buf, sizeof (buf), "%d:%d:%d", c.get_red(), c.get_green(), c.get_blue()); xml_node->add_property ("color", buf); - _route.gui_changed ("color", (void *) 0); /* EMIT_SIGNAL */ + _route->gui_changed ("color", (void *) 0); /* EMIT_SIGNAL */ } @@ -600,26 +870,36 @@ void RouteUI::ensure_xml_node () { if (xml_node == 0) { - if ((xml_node = _route.extra_xml ("GUI")) == 0) { + if ((xml_node = _route->extra_xml ("GUI")) == 0) { xml_node = new XMLNode ("GUI"); - _route.add_extra_xml (*xml_node); + _route->add_extra_xml (*xml_node); } } } XMLNode* -RouteUI::get_child_xml_node (string childname) +RouteUI::get_automation_child_xml_node (Evoral::Parameter param) { - XMLNode* child; - ensure_xml_node (); - - if ((child = find_named_node (*xml_node, childname)) == 0) { - child = new XMLNode (childname); - xml_node->add_child_nocopy (*child); + XMLNodeList kids = xml_node->children(); + XMLNodeConstIterator iter; + + const string sym = ARDOUR::EventTypeMap::instance().to_symbol(param); + + for (iter = kids.begin(); iter != kids.end(); ++iter) { + if ((*iter)->name() == AutomationTimeAxisView::state_node_name) { + XMLProperty* type = (*iter)->property("automation-id"); + if (type && type->value() == sym) + return *iter; + } } + // Didn't find it, make a new one + XMLNode* child = new XMLNode (AutomationTimeAxisView::state_node_name); + child->add_property("automation-id", sym); + xml_node->add_child_nocopy (*child); + return child; } @@ -647,24 +927,19 @@ RouteUI::remove_this_route () vector choices; string prompt; - if (is_audio_track()) { - prompt = string_compose (_("Do you really want to remove track \"%1\" ?\nYou may also lose the playlist used by this track.\n(cannot be undone)"), _route.name()); + if (is_track()) { + prompt = string_compose (_("Do you really want to remove track \"%1\" ?\n\nYou may also lose the playlist used by this track.\n(cannot be undone)"), _route->name()); } else { - prompt = string_compose (_("Do you really want to remove bus \"%1\" ?\n(cannot be undone)"), _route.name()); + prompt = string_compose (_("Do you really want to remove bus \"%1\" ?\n(cannot be undone)"), _route->name()); } - choices.push_back (_("Yes, remove it.")); choices.push_back (_("No, do nothing.")); + choices.push_back (_("Yes, remove it.")); Choice prompter (prompt, choices); - prompter.chosen.connect (Gtk::Main::quit.slot()); - prompter.show_all (); - - Gtk::Main::run (); - - if (prompter.get_choice() == 0) { - Glib::signal_idle().connect (bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route), this)); + if (prompter.run () == 1) { + Glib::signal_idle().connect (bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route), this)); } } @@ -672,15 +947,7 @@ gint RouteUI::idle_remove_this_route (RouteUI *rui) { rui->_session.remove_route (rui->_route); - return FALSE; -} - -void -RouteUI::route_removed () -{ - ENSURE_GUI_THREAD(mem_fun (*this, &RouteUI::route_removed)); - - delete this; + return false; } void @@ -688,17 +955,18 @@ RouteUI::route_rename () { ArdourPrompter name_prompter (true); string result; - name_prompter.set_prompt (_("new name: ")); - name_prompter.set_initial_text (_route.name()); + name_prompter.set_prompt (_("New Name: ")); + name_prompter.set_initial_text (_route->name()); + name_prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT); + name_prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false); name_prompter.show_all (); switch (name_prompter.run ()) { - case GTK_RESPONSE_ACCEPT: - name_prompter.get_result (result); - if (result.length()) { - strip_whitespace_edges (result); - _route.set_name (result, this); + case Gtk::RESPONSE_ACCEPT: + name_prompter.get_result (result); + if (result.length()) { + _route->set_name (result); } break; } @@ -708,11 +976,11 @@ RouteUI::route_rename () } void -RouteUI::name_changed (void *src) +RouteUI::name_changed () { - ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::name_changed), src)); - - name_label.set_text (_route.name()); + ENSURE_GUI_THREAD(sigc::mem_fun(*this, &RouteUI::name_changed)); + + name_label.set_text (_route->name()); } void @@ -721,8 +989,8 @@ RouteUI::toggle_route_active () bool yn; if (route_active_menu_item) { - if (route_active_menu_item->get_active() != (yn = _route.active())) { - _route.set_active (!yn); + if (route_active_menu_item->get_active() != (yn = _route->active())) { + _route->set_active (!yn); } } } @@ -731,14 +999,62 @@ void RouteUI::route_active_changed () { if (route_active_menu_item) { - Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun (*route_active_menu_item, &CheckMenuItem::set_active), _route.active())); + Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun (*route_active_menu_item, &CheckMenuItem::set_active), _route->active())); + } +} + +void +RouteUI::toggle_polarity () +{ + if (polarity_menu_item) { + + bool x; + + ENSURE_GUI_THREAD(mem_fun (*this, &RouteUI::toggle_polarity)); + + if ((x = polarity_menu_item->get_active()) != _route->phase_invert()) { + _route->set_phase_invert (x, this); + if (x) { + name_label.set_text (X_("Ø ") + name_label.get_text()); + } else { + name_label.set_text (_route->name()); + } + } } } +void +RouteUI::polarity_changed () +{ + /* no signal for this yet */ +} + +void +RouteUI::toggle_denormal_protection () +{ + if (denormal_menu_item) { + + bool x; + + ENSURE_GUI_THREAD(mem_fun (*this, &RouteUI::toggle_denormal_protection)); + + if ((x = denormal_menu_item->get_active()) != _route->denormal_protection()) { + _route->set_denormal_protection (x, this); + } + } +} + +void +RouteUI::denormal_protection_changed () +{ + /* no signal for this yet */ +} + + void RouteUI::solo_safe_toggle(void* src, Gtk::CheckMenuItem* check) { - bool yn = _route.solo_safe (); + bool yn = _route->solo_safe (); if (check->get_active() != yn) { check->set_active (yn); @@ -749,7 +1065,7 @@ RouteUI::pre_fader_toggle(void* src, Gtk::CheckMenuItem* check) { ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::pre_fader_toggle), src, check)); - bool yn = _route.get_mute_config(PRE_FADER); + bool yn = _route->get_mute_config(PRE_FADER); if (check->get_active() != yn) { check->set_active (yn); } @@ -760,7 +1076,7 @@ RouteUI::post_fader_toggle(void* src, Gtk::CheckMenuItem* check) { ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::post_fader_toggle), src, check)); - bool yn = _route.get_mute_config(POST_FADER); + bool yn = _route->get_mute_config(POST_FADER); if (check->get_active() != yn) { check->set_active (yn); } @@ -771,7 +1087,7 @@ RouteUI::control_outs_toggle(void* src, Gtk::CheckMenuItem* check) { ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::control_outs_toggle), src, check)); - bool yn = _route.get_mute_config(CONTROL_OUTS); + bool yn = _route->get_mute_config(CONTROL_OUTS); if (check->get_active() != yn) { check->set_active (yn); } @@ -782,7 +1098,7 @@ RouteUI::main_outs_toggle(void* src, Gtk::CheckMenuItem* check) { ENSURE_GUI_THREAD(bind (mem_fun (*this, &RouteUI::main_outs_toggle), src, check)); - bool yn = _route.get_mute_config(MAIN_OUTS); + bool yn = _route->get_mute_config(MAIN_OUTS); if (check->get_active() != yn) { check->set_active (yn); } @@ -791,42 +1107,67 @@ RouteUI::main_outs_toggle(void* src, Gtk::CheckMenuItem* check) void RouteUI::disconnect_input () { - _route.disconnect_inputs (this); + _route->disconnect_inputs (this); } void RouteUI::disconnect_output () { - _route.disconnect_outputs (this); + _route->disconnect_outputs (this); +} + +bool +RouteUI::is_track () const +{ + return boost::dynamic_pointer_cast(_route) != 0; +} + +boost::shared_ptr +RouteUI::track() const +{ + return boost::dynamic_pointer_cast(_route); } bool RouteUI::is_audio_track () const { - return dynamic_cast(&_route) != 0; + return boost::dynamic_pointer_cast(_route) != 0; +} + +boost::shared_ptr +RouteUI::audio_track() const +{ + return boost::dynamic_pointer_cast(_route); } -DiskStream* +bool +RouteUI::is_midi_track () const +{ + return boost::dynamic_pointer_cast(_route) != 0; +} + +boost::shared_ptr +RouteUI::midi_track() const +{ + return boost::dynamic_pointer_cast(_route); +} + +boost::shared_ptr RouteUI::get_diskstream () const { - AudioTrack *at; + boost::shared_ptr t; - if ((at = dynamic_cast(&_route)) != 0) { - return &at->disk_stream(); + if ((t = boost::dynamic_pointer_cast(_route)) != 0) { + return t->diskstream(); } else { - return 0; + return boost::shared_ptr ((Diskstream*) 0); } } -AudioTrack* -RouteUI::audio_track() const -{ - return dynamic_cast(&_route); -} string RouteUI::name() const { - return _route.name(); + return _route->name(); } void @@ -834,7 +1175,7 @@ RouteUI::map_frozen () { ENSURE_GUI_THREAD (mem_fun (*this, &RouteUI::map_frozen)); - AudioTrack* at = dynamic_cast(&_route); + AudioTrack* at = dynamic_cast(_route.get()); if (at) { switch (at->freeze_state()) { @@ -847,3 +1188,9 @@ RouteUI::map_frozen () } } } + +void +RouteUI::adjust_latency () +{ + LatencyDialog dialog (_route->name() + _("latency"), *(_route.get()), _session.frame_rate(), _session.engine().frames_per_cycle()); +}