*/
+#include <boost/algorithm/string.hpp>
+
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/choice.h>
#include <gtkmm2ext/doi.h>
#include "automation_time_axis.h"
#include "route_time_axis.h"
#include "group_tabs.h"
+#include "timers.h"
+#include "ui_config.h"
#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
#include "ardour/filename_extensions.h"
#include "ardour/midi_track.h"
#include "ardour/internal_send.h"
+#include "ardour/profile.h"
#include "ardour/send.h"
#include "ardour/route.h"
#include "ardour/session.h"
using namespace ARDOUR;
using namespace ARDOUR_UI_UTILS;
using namespace PBD;
+using namespace std;
uint32_t RouteUI::_max_invert_buttons = 3;
PBD::Signal1<void, boost::shared_ptr<Route> > RouteUI::BusSendDisplayChanged;
boost::weak_ptr<Route> RouteUI::_showing_sends_to;
-
-static const int _button_vpad = 2;
+std::string RouteUI::program_port_prefix;
RouteUI::RouteUI (ARDOUR::Session* sess)
: AxisView(sess)
, output_selector (0)
, _invert_menu(0)
{
+ if (program_port_prefix.empty()) {
+ // compare to gtk2_ardour/port_group.cc
+ string lpn (PROGRAM_NAME);
+ boost::to_lower (lpn);
+ program_port_prefix = lpn + ":"; // e.g. "ardour:"
+ }
if (sess) init ();
}
RouteUI::~RouteUI()
{
+ if (_route) {
+ gui_object_state().remove_node (route_state_id());
+ }
+
_route.reset (); /* drop reference to route, so that it can be cleaned up */
route_connections.drop_connections ();
delete input_selector;
delete output_selector;
delete _invert_menu;
-
+
send_blink_connection.disconnect ();
rec_blink_connection.disconnect ();
}
rec_enable_button = manage (new ArdourButton);
rec_enable_button->set_name ("record enable button");
- rec_enable_button->set_elements ((ArdourButton::Element)(ArdourButton::Edge|ArdourButton::Body|ArdourButton::RecButton));
+ rec_enable_button->set_icon (ArdourIcon::RecButton);
UI::instance()->set_tip (rec_enable_button, _("Enable recording on this track"), "");
- rec_blink_connection = ARDOUR_UI::instance()->Blink.connect (sigc::mem_fun (*this, &RouteUI::blink_rec_display));
+ if (UIConfiguration::instance().get_blink_rec_arm()) {
+ rec_blink_connection = Timers::blink_connect (sigc::mem_fun (*this, &RouteUI::blink_rec_display));
+ }
show_sends_button = manage (new ArdourButton);
show_sends_button->set_name ("send alert button");
monitor_input_button->set_text (_("In"));
UI::instance()->set_tip (monitor_input_button, _("Monitor input"), "");
monitor_input_button->set_no_show_all (true);
-
+
monitor_disk_button = manage (new ArdourButton (ArdourButton::default_elements));
monitor_disk_button->set_name ("monitor button");
monitor_disk_button->set_text (_("Disk"));
solo_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::solo_release), false);
mute_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::mute_press), false);
mute_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::mute_release), false);
-
+
monitor_input_button->set_distinct_led_click (false);
monitor_disk_button->set_distinct_led_click (false);
solo_button->set_controllable (_route->solo_control());
_route->active_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_active_changed, this), gui_context());
- _route->mute_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::mute_changed, this, _1), gui_context());
+ _route->mute_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_mute_display, this), gui_context());
_route->comment_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::comment_changed, this, _1), gui_context());
_route->solo_safe_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context());
_route->listen_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context());
_route->solo_isolated_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::update_solo_display, this), gui_context());
+ if (is_track()) {
+ track()->TrackModeChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::track_mode_changed, this), gui_context());
+ track_mode_changed();
+ }
- _route->phase_invert_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::polarity_changed, this), gui_context());
+ _route->phase_invert_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::polarity_changed, this), gui_context());
_route->PropertyChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::property_changed, this, _1), gui_context());
_route->io_changed.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::setup_invert_buttons, this), gui_context ());
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(_route);
t->RecordEnableChanged.connect (route_connections, invalidator (*this), boost::bind (&RouteUI::route_rec_enable_changed, this), gui_context());
-
+
rec_enable_button->show();
rec_enable_button->set_controllable (t->rec_enable_control());
boost::bind (&RouteUI::step_edit_changed, this, _1), gui_context());
}
- }
+ }
/* this will work for busses and tracks, and needs to be called to
set up the name entry/name label display.
update_mute_display ();
update_solo_display ();
+ if (!UIConfiguration::instance().get_blink_rec_arm()) {
+ blink_rec_display(true); // set initial rec-en button state
+ }
+
route_color_changed();
}
//if this is a binding action, let the ArdourButton handle it
if ( BindingProxy::is_bind_action(ev) )
return false;
-
+
multiple_mute_change = false;
if (Keyboard::is_context_menu_event (ev)) {
}
mute_menu->popup(0,ev->time);
-
+
return true;
} else {
* elements of the list we need to work
* on a copy.
*/
-
+
boost::shared_ptr<RouteList> copy (new RouteList);
*copy = *_session->get_routes ();
boost::shared_ptr<RouteList> rl;
- if (ev->button == 1) {
+ if (ev->button == 1) {
if (_route->route_group()) {
-
+
rl = _route->route_group()->route_list();
-
+
if (_mute_release) {
_mute_release->routes = rl;
}
boost::shared_ptr<RouteList> rl (new RouteList);
rl->push_back (_route);
-
+
if (_mute_release) {
_mute_release->routes = rl;
}
}
bool
-RouteUI::mute_release (GdkEventButton *ev)
+RouteUI::mute_release (GdkEventButton* /*ev*/)
{
if (_mute_release){
DisplaySuspender ds;
output_selector->present ();
}
- output_selector->set_keep_above (true);
+ //output_selector->set_keep_above (true);
}
void
input_selector->present ();
}
- input_selector->set_keep_above (true);
+ //input_selector->set_keep_above (true);
}
bool
//if this is a binding action, let the ArdourButton handle it
if ( BindingProxy::is_bind_action(ev) )
return false;
-
+
multiple_solo_change = false;
if (Keyboard::is_context_menu_event (ev)) {
DisplaySuspender ds;
if (Config->get_solo_control_is_listen_control()) {
- _session->set_listen (_session->get_routes(), !_route->listening_via_monitor(), Session::rt_cleanup, true);
+ _session->set_listen (_session->get_routes(), !_route->listening_via_monitor(), Session::rt_cleanup, false);
} else {
- _session->set_solo (_session->get_routes(), !_route->self_soloed(), Session::rt_cleanup, true);
+ _session->set_solo (_session->get_routes(), !_route->self_soloed(), Session::rt_cleanup, false);
}
} else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) {
boost::shared_ptr<RouteList> rl;
- if (ev->button == 1) {
+ if (ev->button == 1) {
+ if (ARDOUR::Profile->get_mixbus() && _route->route_group()) {
- if (_route->route_group()) {
-
rl = _route->route_group()->route_list();
-
+
if (_solo_release) {
_solo_release->routes = rl;
}
}
}
+ delete _solo_release;
+ _solo_release = 0;
+
} else {
/* click: solo this route */
}
bool
-RouteUI::solo_release (GdkEventButton *ev)
+RouteUI::solo_release (GdkEventButton* /*ev*/)
{
if (_solo_release) {
} else {
DisplaySuspender ds;
if (Config->get_solo_control_is_listen_control()) {
- _session->set_listen (_solo_release->routes, _solo_release->active, Session::rt_cleanup, true);
+ _session->set_listen (_solo_release->routes, _solo_release->active, Session::rt_cleanup, false);
} else {
- _session->set_solo (_solo_release->routes, _solo_release->active, Session::rt_cleanup, true);
+ _session->set_solo (_solo_release->routes, _solo_release->active, Session::rt_cleanup, false);
}
}
//if this is a binding action, let the ArdourButton handle it
if ( BindingProxy::is_bind_action(ev) )
return false;
-
+
if (!_session->engine().connected()) {
MessageDialog msg (_("Not connected to AudioEngine - cannot engage record"));
msg.run ();
return false;
}
- if (is_midi_track()) {
+ if (is_midi_track()) {
- /* rec-enable button exits from step editing */
+ /* rec-enable button exits from step editing */
- if (midi_track()->step_editing()) {
+ if (midi_track()->step_editing()) {
midi_track()->set_step_editing (false);
return false;
- }
- }
+ }
+ }
if (is_track() && rec_enable_button) {
if (Keyboard::is_button2_event (ev)) {
-
+
//rec arm does not have a momentary mode
return false;
if (ev->button == 1) {
boost::shared_ptr<RouteList> rl;
-
+
if (_route->route_group()) {
-
+
rl = _route->route_group()->route_list();
-
+
} else {
rl.reset (new RouteList);
rl->push_back (_route);
bool
RouteUI::monitor_release (GdkEventButton* ev, MonitorChoice monitor_choice)
-{
+{
if (ev->button != 1) {
return false;
}
MonitorChoice mc;
boost::shared_ptr<RouteList> rl;
-
- /* XXX for now, monitoring choices are orthogonal. cue monitoring
+
+ /* XXX for now, monitoring choices are orthogonal. cue monitoring
will follow in 3.X but requires mixing the input and playback (disk)
signal together, which requires yet more buffers.
*/
mc = monitor_choice;
}
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
+ if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
rl = _session->get_routes ();
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
}
DisplaySuspender ds;
- _session->set_monitoring (rl, mc, Session::rt_cleanup, true);
+ _session->set_monitoring (rl, mc, Session::rt_cleanup, true);
return false;
}
void
RouteUI::build_record_menu ()
{
- if (record_menu) {
- return;
- }
+ if (record_menu) {
+ return;
+ }
- /* no rec-button context menu for non-MIDI tracks
- */
+ /* no rec-button context menu for non-MIDI tracks
+ */
- if (is_midi_track()) {
- record_menu = new Menu;
- record_menu->set_name ("ArdourContextMenu");
+ if (is_midi_track()) {
+ record_menu = new Menu;
+ record_menu->set_name ("ArdourContextMenu");
- using namespace Menu_Helpers;
- MenuList& items = record_menu->items();
+ using namespace Menu_Helpers;
+ MenuList& items = record_menu->items();
- items.push_back (CheckMenuElem (_("Step Entry"), sigc::mem_fun (*this, &RouteUI::toggle_step_edit)));
- step_edit_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back());
+ items.push_back (CheckMenuElem (_("Step Entry"), sigc::mem_fun (*this, &RouteUI::toggle_step_edit)));
+ step_edit_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back());
- if (_route->record_enabled()) {
- step_edit_item->set_sensitive (false);
- }
+ if (_route->record_enabled()) {
+ step_edit_item->set_sensitive (false);
+ }
- step_edit_item->set_active (midi_track()->step_editing());
- }
+ step_edit_item->set_active (midi_track()->step_editing());
+ }
}
void
RouteUI::toggle_step_edit ()
{
- if (!is_midi_track() || _route->record_enabled()) {
- return;
- }
+ if (!is_midi_track() || _route->record_enabled()) {
+ return;
+ }
- midi_track()->set_step_editing (step_edit_item->get_active());
+ midi_track()->set_step_editing (step_edit_item->get_active());
}
void
RouteUI::step_edit_changed (bool yn)
{
- if (yn) {
- if (rec_enable_button) {
- rec_enable_button->set_active_state (Gtkmm2ext::ExplicitActive);
- }
+ if (yn) {
+ if (rec_enable_button) {
+ rec_enable_button->set_active_state (Gtkmm2ext::ExplicitActive);
+ }
- start_step_editing ();
+ start_step_editing ();
- if (step_edit_item) {
- step_edit_item->set_active (true);
- }
+ if (step_edit_item) {
+ step_edit_item->set_active (true);
+ }
- } else {
+ } else {
- if (rec_enable_button) {
- rec_enable_button->unset_active_state ();
- }
+ if (rec_enable_button) {
+ rec_enable_button->unset_active_state ();
+ }
- stop_step_editing ();
+ stop_step_editing ();
- if (step_edit_item) {
- step_edit_item->set_active (false);
- }
- }
+ if (step_edit_item) {
+ step_edit_item->set_active (false);
+ }
+ }
}
bool
RouteUI::rec_enable_release (GdkEventButton* ev)
{
- if (Keyboard::is_context_menu_event (ev)) {
- build_record_menu ();
- if (record_menu) {
- record_menu->popup (1, ev->time);
- }
- return false;
- }
+ if (Keyboard::is_context_menu_event (ev)) {
+ build_record_menu ();
+ if (record_menu) {
+ record_menu->popup (1, ev->time);
+ }
+ return false;
+ }
return false;
}
update_mute_display ();
}
-void
-RouteUI::mute_changed(void* /*src*/)
-{
- update_mute_display ();
-}
-
ActiveState
RouteUI::mute_active_state (Session* s, boost::shared_ptr<Route> r)
{
if (r->muted ()) {
/* full mute */
return Gtkmm2ext::ExplicitActive;
- } else if (!r->is_master() && s->soloing() && !r->soloed() && !r->solo_isolated()) {
- /* master is NEVER muted by others */
+ } else if (r->muted_by_others()) {
return Gtkmm2ext::ImplicitActive;
} else {
/* no mute at all */
void
RouteUI::session_rec_enable_changed ()
{
+ blink_rec_display(true); //this lets the button change "immediately" rather than wait for the next blink
update_monitoring_display ();
}
if (!rec_enable_button || !_route) {
return;
}
+ if (boost::dynamic_pointer_cast<Send>(_current_delivery)) {
+ return;
+ }
if (_route->record_enabled()) {
switch (_session->record_status ()) {
case Session::Disabled:
case Session::Enabled:
- if ( ARDOUR_UI::config()->get_blink_rec_arm() )
+ if ( UIConfiguration::instance().get_blink_rec_arm() )
rec_enable_button->set_active_state ( blinkOn ? Gtkmm2ext::ExplicitActive : Gtkmm2ext::Off );
else
rec_enable_button->set_active_state ( ImplicitActive );
/* disable isolate for all routes */
DisplaySuspender ds;
_session->set_solo_isolated (_session->get_routes(), false, Session::rt_cleanup, true);
+ } else {
+ /* enable isolate for all routes */
+ DisplaySuspender ds;
+ _session->set_solo_isolated (_session->get_routes(), true, Session::rt_cleanup, true);
}
} else {
+
if (model == view) {
/* flip just this route */
bool
RouteUI::solo_safe_button_release (GdkEventButton* ev)
{
+ if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS) {
+ return true;
+ }
+
+ bool view = solo_safe_led->active_state();
+ bool model = _route->solo_safe();
+
if (ev->button == 1) {
- _route->set_solo_safe (!solo_safe_led->active_state(), this);
+ if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
+ boost::shared_ptr<RouteList> rl (_session->get_routes());
+ if (model) {
+ /* disable solo safe for all routes */
+ DisplaySuspender ds;
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+ (*i)->set_solo_safe (false, this);
+ }
+ } else {
+ /* enable solo safe for all routes */
+ DisplaySuspender ds;
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+ (*i)->set_solo_safe (true, this);
+ }
+ }
+ }
+ else {
+ if (model == view) {
+ /* flip just this route */
+ _route->set_solo_safe (!view, this);
+ }
+ }
}
+
return false;
}
char buf[64];
_color = c;
snprintf (buf, sizeof (buf), "%d:%d:%d", c.get_red(), c.get_green(), c.get_blue());
-
+
/* note: we use the route state ID here so that color is the same for both
the time axis view and the mixer strip
*/
-
+
gui_object_state().set_property<string> (route_state_id(), X_("color"), buf);
_route->gui_changed ("color", (void *) 0); /* EMIT_SIGNAL */
}
return 0;
}
-void
-RouteUI::remove_this_route (bool apply_to_selection)
-{
- if (apply_to_selection) {
- ARDOUR_UI::instance()->the_editor().get_selection().tracks.foreach_route_ui (boost::bind (&RouteUI::remove_this_route, _1, false));
- } else {
- if ((route()->is_master() || route()->is_monitor()) &&
- !Config->get_allow_special_bus_removal()) {
- MessageDialog msg (_("That would be bad news ...."),
- false,
- Gtk::MESSAGE_INFO,
- Gtk::BUTTONS_OK);
- msg.set_secondary_text (string_compose (_(
-"Removing the master or monitor bus is such a bad idea\n\
-that %1 is not going to allow it.\n\
-\n\
-If you really want to do this sort of thing\n\
-edit your ardour.rc file to set the\n\
-\"allow-special-bus-removal\" option to be \"yes\""), PROGRAM_NAME));
-
- msg.present ();
- msg.run ();
- return;
- }
-
- vector<string> choices;
- string prompt;
-
- 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\n(This action cannot be undone, and the session file will be overwritten)"), _route->name());
- } else {
- prompt = string_compose (_("Do you really want to remove bus \"%1\" ?\n\n(This action cannot be undone, and the session file will be overwritten)"), _route->name());
- }
-
- choices.push_back (_("No, do nothing."));
- choices.push_back (_("Yes, remove it."));
-
- string title;
- if (is_track()) {
- title = _("Remove track");
- } else {
- title = _("Remove bus");
- }
-
- Choice prompter (title, prompt, choices);
-
- if (prompter.run () == 1) {
- Glib::signal_idle().connect (sigc::bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route), this));
- }
- }
-}
-
-gint
-RouteUI::idle_remove_this_route (RouteUI *rui)
-{
- DisplaySuspender ds;
- rui->_session->remove_route (rui->route());
- return false;
-}
-
/** @return true if this name should be used for the route, otherwise false */
bool
RouteUI::verify_new_route_name (const std::string& name)
if (name.find (':') == string::npos) {
return true;
}
-
+
MessageDialog colon_msg (
_("The use of colons (':') is discouraged in track and bus names.\nDo you want to use this new name?"),
false, MESSAGE_QUESTION, BUTTONS_NONE
);
-
+
colon_msg.add_button (_("Use the new name"), Gtk::RESPONSE_ACCEPT);
colon_msg.add_button (_("Re-edit the name"), Gtk::RESPONSE_CANCEL);
}
}
+void
+RouteUI::duplicate_selected_routes ()
+{
+ ARDOUR_UI::instance()->start_duplicate_routes();
+}
+
void
RouteUI::toggle_denormal_protection ()
{
LatencyDialog dialog (_route->name() + _(" latency"), *(_route->output()), _session->frame_rate(), AudioEngine::instance()->samples_per_cycle());
}
-void
-RouteUI::save_as_template ()
+bool
+RouteUI::process_save_template_prompter (ArdourPrompter& prompter, const std::string& dir)
{
std::string path;
std::string safe_name;
- string name;
+ std::string name;
- path = ARDOUR::user_route_template_directory ();
+ prompter.get_result (name, true);
- if (g_mkdir_with_parents (path.c_str(), 0755)) {
- error << string_compose (_("Cannot create route template directory %1"), path) << endmsg;
- return;
+ safe_name = legalize_for_path (name);
+ safe_name += template_suffix;
+
+ path = Glib::build_filename (dir, safe_name);
+
+ if (Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
+ bool overwrite = overwrite_file_dialog (prompter,
+ _("Confirm Template Overwrite"),
+ _("A template already exists with that name. Do you want to overwrite it?"));
+
+ if (!overwrite) {
+ return false;
+ }
}
- Prompter p (true); // modal
+ _route->save_as_template (path, name);
+
+ return true;
+}
- p.set_title (_("Save As Template"));
- p.set_prompt (_("Template name:"));
- p.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
- switch (p.run()) {
- case RESPONSE_ACCEPT:
- break;
- default:
+void
+RouteUI::save_as_template ()
+{
+ std::string dir;
+
+ dir = ARDOUR::user_route_template_directory ();
+
+ if (g_mkdir_with_parents (dir.c_str(), 0755)) {
+ error << string_compose (_("Cannot create route template directory %1"), dir) << endmsg;
return;
}
- p.hide ();
- p.get_result (name, true);
+ ArdourPrompter prompter (true); // modal
- safe_name = legalize_for_path (name);
- safe_name += template_suffix;
+ prompter.set_title (_("Save As Template"));
+ prompter.set_prompt (_("Template name:"));
+ prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
- path = Glib::build_filename (path, safe_name);
-
- _route->save_as_template (path, name);
+ bool finished = false;
+ while (!finished) {
+ switch (prompter.run()) {
+ case RESPONSE_ACCEPT:
+ finished = process_save_template_prompter (prompter, dir);
+ break;
+ default:
+ finished = true;
+ break;
+ }
+ }
}
void
set_button_names ();
} else if (p == "auto-input") {
update_monitoring_display ();
+ } else if (p == "blink-rec-arm") {
+ if (UIConfiguration::instance().get_blink_rec_arm()) {
+ rec_blink_connection.disconnect ();
+ rec_blink_connection = Timers::blink_connect (sigc::mem_fun (*this, &RouteUI::blink_rec_display));
+ } else {
+ rec_blink_connection.disconnect ();
+ RouteUI::blink_rec_display(false);
+ }
}
}
void
RouteUI::step_gain_up ()
{
- _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.1), this);
+ _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.1), Controllable::UseGroup);
}
void
RouteUI::page_gain_up ()
{
- _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.5), this);
+ _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.5), Controllable::UseGroup);
}
void
RouteUI::step_gain_down ()
{
- _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.1), this);
+ _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.1), Controllable::UseGroup);
}
void
RouteUI::page_gain_down ()
{
- _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.5), this);
+ _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.5), Controllable::UseGroup);
}
void
if (Config->get_remote_model() == UserOrdered) {
uint32_t const limit = _session->ntracks() + _session->nbusses () + 4;
-
+
HBox* hbox = manage (new HBox);
hbox->set_spacing (6);
hbox->pack_start (*manage (new Label (_("Remote control ID:"))));
spin->set_value (_route->remote_control_id());
hbox->pack_start (*spin);
dialog.get_vbox()->pack_start (*hbox);
-
+
dialog.add_button (Stock::CANCEL, RESPONSE_CANCEL);
dialog.add_button (Stock::APPLY, RESPONSE_ACCEPT);
} else {
if (_route->is_master() || _route->is_monitor()) {
l->set_markup (string_compose (_("The remote control ID of %1 is: %2\n\n\n"
"The remote control ID of %3 cannot be changed."),
- Glib::Markup::escape_text (_route->name()),
+ Gtkmm2ext::markup_escape_text (_route->name()),
_route->remote_control_id(),
(_route->is_master() ? _("the master bus") : _("the monitor bus"))));
} else {
_route->remote_control_id(),
"<span size=\"small\" style=\"italic\">",
"</span>",
- Glib::Markup::escape_text (_route->name()),
+ Gtkmm2ext::markup_escape_text (_route->name()),
PROGRAM_NAME));
}
dialog.get_vbox()->pack_start (*l);
*/
ArdourButton* b = _invert_buttons.front ();
-
+
if (_route->phase_invert().count() == _route->phase_invert().size()) {
b->set_active_state (Gtkmm2ext::ExplicitActive);
} else if (_route->phase_invert().any()) {
for (vector<ArdourButton*>::iterator i = _invert_buttons.begin(); i != _invert_buttons.end(); ++i, ++j) {
(*i)->set_active (_route->phase_invert (j));
}
-
+
}
}
*/
return false;
}
-
+
delete _invert_menu;
_invert_menu = new Menu;
_invert_menu->set_name ("ArdourContextMenu");
}
}
+void
+RouteUI::track_mode_changed (void)
+{
+ assert(is_track());
+ switch (track()->mode()) {
+ case ARDOUR::NonLayered:
+ case ARDOUR::Normal:
+ rec_enable_button->set_icon (ArdourIcon::RecButton);
+ break;
+ case ARDOUR::Destructive:
+ rec_enable_button->set_icon (ArdourIcon::RecTapeMode);
+ break;
+ }
+ rec_enable_button->queue_draw();
+}
+
/** @return the color that this route should use; it maybe its own,
or it maybe that of its route group.
*/
RouteUI::color () const
{
RouteGroup* g = _route->route_group ();
-
+
if (g && g->is_color()) {
Gdk::Color c;
set_color_from_rgba (c, GroupTabs::group_color (g));
{
if (_route == send_to) {
show_sends_button->set_active (true);
- send_blink_connection = ARDOUR_UI::instance()->Blink.connect (sigc::mem_fun (*this, &RouteUI::send_blink));
+ send_blink_connection = Timers::blink_connect (sigc::mem_fun (*this, &RouteUI::send_blink));
} else {
show_sends_button->set_active (false);
send_blink_connection.disconnect ();
projects / ardour.git / blobdiff