X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fmixer_strip.cc;h=90d2a2912af334746fe771cf31e0df33b3204b4e;hb=25eb9f406960aa8e36ccd90e2cd4397f372bd0fa;hp=7012ad61f5060349fa5694fe7f0b6913be77dde0;hpb=1145f1ff6c02369808b7853385cdab0ca5ff2f11;p=ardour.git diff --git a/gtk2_ardour/mixer_strip.cc b/gtk2_ardour/mixer_strip.cc index 7012ad61f5..90d2a2912a 100644 --- a/gtk2_ardour/mixer_strip.cc +++ b/gtk2_ardour/mixer_strip.cc @@ -17,6 +17,7 @@ */ #include +#include #include #include @@ -24,6 +25,7 @@ #include "pbd/convert.h" #include "pbd/enumwriter.h" #include "pbd/replace_all.h" +#include "pbd/stacktrace.h" #include #include @@ -32,31 +34,28 @@ #include #include -#include "ardour/ardour.h" -#include "ardour/amp.h" -#include "ardour/session.h" +#include "ardour/audio_track.h" #include "ardour/audioengine.h" #include "ardour/internal_send.h" -#include "ardour/route.h" -#include "ardour/route_group.h" -#include "ardour/audio_track.h" #include "ardour/midi_track.h" #include "ardour/pannable.h" #include "ardour/panner.h" #include "ardour/panner_shell.h" -#include "ardour/send.h" -#include "ardour/processor.h" +#include "ardour/port.h" #include "ardour/profile.h" -#include "ardour/ladspa_plugin.h" +#include "ardour/route.h" +#include "ardour/route_group.h" +#include "ardour/send.h" +#include "ardour/session.h" +#include "ardour/types.h" #include "ardour/user_bundle.h" -#include "ardour/port.h" #include "ardour_ui.h" -#include "ardour_dialog.h" +#include "ardour_window.h" #include "mixer_strip.h" #include "mixer_ui.h" #include "keyboard.h" -#include "led.h" +#include "ardour_button.h" #include "public_editor.h" #include "send_ui.h" #include "io_selector.h" @@ -72,8 +71,6 @@ using namespace Gtk; using namespace Gtkmm2ext; using namespace std; -sigc::signal > MixerStrip::SwitchIO; - int MixerStrip::scrollbar_height = 0; PBD::Signal1 MixerStrip::CatchDeletion; @@ -85,12 +82,16 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, bool in_mixer) , processor_box (sess, boost::bind (&MixerStrip::plugin_selector, this), mx.selection(), this, in_mixer) , gpm (sess, 250) , panners (sess) + , button_size_group (Gtk::SizeGroup::create (Gtk::SIZE_GROUP_HORIZONTAL)) , button_table (3, 1) - , solo_led_table (2, 2) + , rec_solo_table (2, 2) + , top_button_table (1, 2) , middle_button_table (1, 2) , bottom_button_table (1, 2) - , meter_point_label (_("pre")) + , meter_point_button (_("pre")) , midi_input_enable_button (0) + , _comment_button (_("Comments")) + , _visibility (X_("mixer-strip-visibility")) { init (); @@ -108,14 +109,17 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, boost::shared_ptr rt , RouteUI (sess) , _mixer(mx) , _mixer_owned (in_mixer) - , processor_box (sess, sigc::mem_fun(*this, &MixerStrip::plugin_selector), mx.selection(), this, in_mixer) + , processor_box (sess, boost::bind (&MixerStrip::plugin_selector, this), mx.selection(), this, in_mixer) , gpm (sess, 250) , panners (sess) + , button_size_group (Gtk::SizeGroup::create (Gtk::SIZE_GROUP_HORIZONTAL)) , button_table (3, 1) , middle_button_table (1, 2) , bottom_button_table (1, 2) - , meter_point_label (_("pre")) + , meter_point_button (_("pre")) , midi_input_enable_button (0) + , _comment_button (_("Comments")) + , _visibility (X_("mixer-strip-visibility")) { init (); set_route (rt); @@ -138,36 +142,28 @@ MixerStrip::init () /* the length of this string determines the width of the mixer strip when it is set to `wide' */ longest_label = "longest label"; - Gtk::Image* img; - - img = manage (new Gtk::Image (::get_icon("strip_width"))); - img->show (); - - width_button.add (*img); - - img = manage (new Gtk::Image (::get_icon("hide"))); - img->show (); + string t = _("Click to toggle the width of this mixer strip."); + if (_mixer_owned) { + t += string_compose (_("\n%1-%2-click to toggle the width of all strips."), Keyboard::primary_modifier_name(), Keyboard::tertiary_modifier_name ()); + } + + width_button.set_image (::get_icon("strip_width")); + ARDOUR_UI::instance()->set_tip (width_button, t); - hide_button.add (*img); + hide_button.set_image(::get_icon("hide")); + ARDOUR_UI::instance()->set_tip (&hide_button, _("Hide this mixer strip")); - input_label.set_text (_("Input")); - ARDOUR_UI::instance()->set_tip (&input_button, _("Button 1 to choose inputs from a port matrix, button 3 to select inputs from a menu"), ""); - input_button.add (input_label); - input_button.set_name ("MixerIOButton"); - input_label.set_name ("MixerIOButtonLabel"); + input_button.set_text (_("Input")); + input_button.set_name ("mixer strip button"); + input_button.set_size_request (-1, 20); input_button_box.pack_start (input_button, true, true); - output_label.set_text (_("Output")); - ARDOUR_UI::instance()->set_tip (&output_button, _("Button 1 to choose outputs from a port matrix, button 3 to select inputs from a menu"), ""); - output_button.add (output_label); - output_button.set_name ("MixerIOButton"); - output_label.set_name ("MixerIOButtonLabel"); + output_button.set_text (_("Output")); + output_button.set_name ("mixer strip button"); Gtkmm2ext::set_size_request_to_display_given_text (output_button, longest_label.c_str(), 4, 4); - ARDOUR_UI::instance()->set_tip (&meter_point_button, _("Select metering point"), ""); - meter_point_button.add (meter_point_label); - meter_point_button.set_name ("MixerStripMeterPreButton"); - meter_point_label.set_name ("MixerStripMeterPreButton"); + ARDOUR_UI::instance()->set_tip (&meter_point_button, _("Click to select metering point"), ""); + meter_point_button.set_name ("mixer strip button"); /* TRANSLATORS: this string should be longest of the strings used to describe meter points. In english, it's "input". @@ -181,85 +177,98 @@ MixerStrip::init () hide_button.set_events (hide_button.get_events() & ~(Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK)); - mute_button->set_name ("MixerMuteButton"); - solo_button->set_name ("MixerSoloButton"); + monitor_input_button->set_diameter (3); + monitor_disk_button->set_diameter (3); - solo_isolated_led = manage (new LED); + solo_isolated_led = manage (new ArdourButton (ArdourButton::led_default_elements)); solo_isolated_led->show (); - solo_isolated_led->set_diameter (6); + solo_isolated_led->set_diameter (3); solo_isolated_led->set_no_show_all (true); - solo_isolated_led->set_name (X_("SoloIsolatedLED")); + solo_isolated_led->set_name (X_("solo isolate")); solo_isolated_led->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK); solo_isolated_led->signal_button_release_event().connect (sigc::mem_fun (*this, &RouteUI::solo_isolate_button_release)); UI::instance()->set_tip (solo_isolated_led, _("Isolate Solo"), ""); - solo_safe_led = manage (new LED); + solo_safe_led = manage (new ArdourButton (ArdourButton::led_default_elements)); solo_safe_led->show (); - solo_safe_led->set_diameter (6); + solo_safe_led->set_diameter (3); solo_safe_led->set_no_show_all (true); - solo_safe_led->set_name (X_("SoloSafeLED")); + solo_safe_led->set_name (X_("solo safe")); solo_safe_led->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK); solo_safe_led->signal_button_release_event().connect (sigc::mem_fun (*this, &RouteUI::solo_safe_button_release)); UI::instance()->set_tip (solo_safe_led, _("Lock Solo Status"), ""); - _iso_label = manage (new Label (_("iso"))); - _safe_label = manage (new Label (_("lock"))); + solo_safe_led->set_text (_("lock")); + solo_isolated_led->set_text (_("iso")); - _iso_label->set_name (X_("SoloLEDLabel")); - _safe_label->set_name (X_("SoloLEDLabel")); + top_button_table.set_homogeneous (true); + top_button_table.set_spacings (2); + top_button_table.attach (*monitor_input_button, 0, 1, 0, 1); + top_button_table.attach (*monitor_disk_button, 1, 2, 0, 1); + top_button_table.show (); - _iso_label->show (); - _safe_label->show (); + rec_solo_table.set_homogeneous (true); + rec_solo_table.set_row_spacings (2); + rec_solo_table.set_col_spacings (2); + rec_solo_table.attach (*solo_isolated_led, 1, 2, 0, 1); + rec_solo_table.attach (*solo_safe_led, 1, 2, 1, 2); + rec_solo_table.show (); - solo_led_table.set_spacings (0); - solo_led_table.set_border_width (1); - solo_led_table.attach (*_iso_label, 0, 1, 0, 1, Gtk::FILL, Gtk::FILL); - solo_led_table.attach (*solo_isolated_led, 1, 2, 0, 1, Gtk::FILL, Gtk::FILL); - solo_led_table.attach (*_safe_label, 0, 1, 1, 2, Gtk::FILL, Gtk::FILL); - solo_led_table.attach (*solo_safe_led, 1, 2, 1, 2, Gtk::FILL, Gtk::FILL); + button_table.set_homogeneous (false); + button_table.set_spacings (2); - solo_led_table.show (); - below_panner_box.set_border_width (2); - below_panner_box.set_spacing (2); - below_panner_box.pack_end (solo_led_table, false, false); - below_panner_box.show (); - - button_table.set_homogeneous (true); - button_table.set_spacings (0); + if (solo_isolated_led) { + button_size_group->add_widget (*solo_isolated_led); + } + if (solo_safe_led) { + button_size_group->add_widget (*solo_safe_led); + } + if (rec_enable_button) { + button_size_group->add_widget (*rec_enable_button); + } + if (monitor_disk_button) { + button_size_group->add_widget (*monitor_disk_button); + } + if (monitor_input_button) { + button_size_group->add_widget (*monitor_input_button); + } button_table.attach (name_button, 0, 1, 0, 1); button_table.attach (input_button_box, 0, 1, 1, 2); button_table.attach (_invert_button_box, 0, 1, 2, 3); middle_button_table.set_homogeneous (true); - middle_button_table.set_spacings (0); - middle_button_table.attach (*mute_button, 0, 1, 0, 1); - middle_button_table.attach (*solo_button, 1, 2, 0, 1); + middle_button_table.set_spacings (2); - bottom_button_table.set_col_spacings (0); + bottom_button_table.set_spacings (2); bottom_button_table.set_homogeneous (true); - bottom_button_table.attach (group_button, 0, 1, 0, 1); - - name_button.add (name_label); - name_button.set_name ("MixerNameButton"); +// bottom_button_table.attach (group_button, 0, 1, 0, 1); + bottom_button_table.attach (gpm.gain_automation_state_button, 0, 1, 0, 1); + + name_button.set_name ("mixer strip button"); + name_button.set_text (" "); /* non empty text, forces creation of the layout */ + name_button.set_text (""); /* back to empty */ + name_button.layout()->set_ellipsize (Pango::ELLIPSIZE_END); + name_button.signal_size_allocate().connect (sigc::mem_fun (*this, &MixerStrip::name_button_resized)); Gtkmm2ext::set_size_request_to_display_given_text (name_button, longest_label.c_str(), 2, 2); + name_button.set_size_request (-1, 20); - name_label.set_name ("MixerNameButtonLabel"); ARDOUR_UI::instance()->set_tip (&group_button, _("Mix group"), ""); - group_button.add (group_label); - group_button.set_name ("MixerGroupButton"); + group_button.set_name ("mixer strip button"); Gtkmm2ext::set_size_request_to_display_given_text (group_button, "Group", 2, 2); - group_label.set_name ("MixerGroupButtonLabel"); + + _comment_button.set_name (X_("mixer strip button")); + _comment_button.signal_clicked.connect (sigc::mem_fun (*this, &MixerStrip::toggle_comment_editor)); global_vpacker.set_border_width (0); global_vpacker.set_spacing (0); - width_button.set_name ("MixerWidthButton"); - hide_button.set_name ("MixerHideButton"); - top_event_box.set_name ("MixerTopEventBox"); + width_button.set_name ("mixer strip button"); + hide_button.set_name ("mixer strip button"); + top_event_box.set_name ("mixer strip button"); - width_button.signal_clicked().connect (sigc::mem_fun(*this, &MixerStrip::width_clicked)); - hide_button.signal_clicked().connect (sigc::mem_fun(*this, &MixerStrip::hide_clicked)); + width_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::width_button_pressed), false); + hide_button.signal_clicked.connect (sigc::mem_fun(*this, &MixerStrip::hide_clicked)); width_hide_box.pack_start (width_button, false, true); width_hide_box.pack_start (top_event_box, true, true); @@ -267,15 +276,18 @@ MixerStrip::init () whvbox.pack_start (width_hide_box, true, true); + global_vpacker.set_spacing (2); global_vpacker.pack_start (whvbox, Gtk::PACK_SHRINK); global_vpacker.pack_start (button_table, Gtk::PACK_SHRINK); global_vpacker.pack_start (processor_box, true, true); global_vpacker.pack_start (panners, Gtk::PACK_SHRINK); - global_vpacker.pack_start (below_panner_box, Gtk::PACK_SHRINK); + global_vpacker.pack_start (top_button_table, Gtk::PACK_SHRINK); + global_vpacker.pack_start (rec_solo_table, Gtk::PACK_SHRINK); global_vpacker.pack_start (middle_button_table, Gtk::PACK_SHRINK); global_vpacker.pack_start (gpm, Gtk::PACK_SHRINK); global_vpacker.pack_start (bottom_button_table, Gtk::PACK_SHRINK); global_vpacker.pack_start (output_button, Gtk::PACK_SHRINK); + global_vpacker.pack_start (_comment_button, Gtk::PACK_SHRINK); global_frame.add (global_vpacker); global_frame.set_shadow_type (Gtk::SHADOW_IN); @@ -297,12 +309,6 @@ MixerStrip::init () input_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::input_press), false); output_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::output_press), false); - /* we don't need this if its not an audio track, but we don't know that yet and it doesn't - hurt (much). - */ - - rec_enable_button->set_name ("MixerRecordEnableButton"); - /* ditto for this button and busses */ name_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::name_button_button_press), false); @@ -318,10 +324,11 @@ MixerStrip::init () in update_diskstream_display(). */ - if (is_midi_track()) + if (is_midi_track()) { set_name ("MidiTrackStripBase"); - else + } else { set_name ("AudioTrackStripBase"); + } add_events (Gdk::BUTTON_RELEASE_MASK| Gdk::ENTER_NOTIFY_MASK| @@ -331,11 +338,26 @@ MixerStrip::init () set_flags (get_flags() | Gtk::CAN_FOCUS); - SwitchIO.connect (sigc::mem_fun (*this, &MixerStrip::switch_io)); - AudioEngine::instance()->PortConnectedOrDisconnected.connect ( *this, invalidator (*this), boost::bind (&MixerStrip::port_connected_or_disconnected, this, _1, _3), gui_context () ); + + /* Add the widgets under visibility control to the VisibilityGroup; the names used here + must be the same as those used in RCOptionEditor so that the configuration changes + are recognised when they occur. + */ + _visibility.add (&_invert_button_box, X_("PhaseInvert"), _("Phase Invert")); + _visibility.add (solo_safe_led, X_("SoloSafe"), _("Solo Safe"), true, boost::bind (&MixerStrip::override_solo_visibility, this)); + _visibility.add (solo_isolated_led, X_("SoloIsolated"), _("Solo Isolated"), true, boost::bind (&MixerStrip::override_solo_visibility, this)); + _visibility.add (&_comment_button, X_("Comments"), _("Comments")); + _visibility.add (&group_button, X_("Group"), _("Group")); + _visibility.add (&meter_point_button, X_("MeterPoint"), _("Meter Point")); + + parameter_changed (X_("mixer-strip-visibility")); + + Config->ParameterChanged.connect (_config_connection, MISSING_INVALIDATOR, boost::bind (&MixerStrip::parameter_changed, this, _1), gui_context()); + + gpm.LevelMeterButtonPress.connect_same_thread (_level_meter_connection, boost::bind (&MixerStrip::level_meter_button_press, this, _1)); } MixerStrip::~MixerStrip () @@ -351,17 +373,20 @@ void MixerStrip::set_route (boost::shared_ptr rt) { if (rec_enable_button->get_parent()) { - below_panner_box.remove (*rec_enable_button); + rec_solo_table.remove (*rec_enable_button); } if (show_sends_button->get_parent()) { - below_panner_box.remove (*show_sends_button); + rec_solo_table.remove (*show_sends_button); } - processor_box.set_route (rt); - RouteUI::set_route (rt); + /* ProcessorBox needs access to _route so that it can read + GUI object state. + */ + processor_box.set_route (rt); + /* map the current state */ mute_changed (0); @@ -375,12 +400,39 @@ MixerStrip::set_route (boost::shared_ptr rt) revert_to_default_display (); + /* unpack these from the parent and stuff them into our own + table + */ + + if (gpm.peak_display.get_parent()) { + gpm.peak_display.get_parent()->remove (gpm.peak_display); + } + if (gpm.gain_display.get_parent()) { + gpm.gain_display.get_parent()->remove (gpm.gain_display); + } + + middle_button_table.attach (gpm.gain_display,0,1,1,2); + middle_button_table.attach (gpm.peak_display,1,2,1,2); + + if (solo_button->get_parent()) { + middle_button_table.remove (*solo_button); + } + + if (mute_button->get_parent()) { + middle_button_table.remove (*mute_button); + } + if (route()->is_master()) { + middle_button_table.attach (*mute_button, 0, 2, 0, 1); solo_button->hide (); - below_panner_box.hide (); + mute_button->show (); + rec_solo_table.hide (); } else { + middle_button_table.attach (*mute_button, 0, 1, 0, 1); + middle_button_table.attach (*solo_button, 1, 2, 0, 1); + mute_button->show (); solo_button->show (); - below_panner_box.show (); + rec_solo_table.show (); } if (_mixer_owned && (route()->is_master() || route()->is_monitor())) { @@ -396,12 +448,19 @@ MixerStrip::set_route (boost::shared_ptr rt) global_vpacker.pack_start (*spacer, false, false); } + if (is_track()) { + monitor_input_button->show (); + monitor_disk_button->show (); + } else { + monitor_input_button->hide(); + monitor_disk_button->hide (); + } + if (is_midi_track()) { if (midi_input_enable_button == 0) { - Image* img = manage (new Image (get_icon (X_("midi_socket_small")))); - midi_input_enable_button = manage (new StatefulToggleButton); - midi_input_enable_button->set_name ("MixerMidiInputEnableButton"); - midi_input_enable_button->set_image (*img); + midi_input_enable_button = manage (new ArdourButton); + midi_input_enable_button->set_name ("midi input button"); + midi_input_enable_button->set_image (::get_icon (X_("midi_socket_small"))); midi_input_enable_button->signal_button_press_event().connect (sigc::mem_fun (*this, &MixerStrip::input_active_button_press), false); midi_input_enable_button->signal_button_release_event().connect (sigc::mem_fun (*this, &MixerStrip::input_active_button_release), false); ARDOUR_UI::instance()->set_tip (midi_input_enable_button, _("Enable/Disable MIDI input")); @@ -426,15 +485,9 @@ MixerStrip::set_route (boost::shared_ptr rt) at->FreezeChange.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::map_frozen, this), gui_context()); } - if (has_audio_outputs ()) { - panners.show_all (); - } else { - panners.hide_all (); - } - if (is_track ()) { - below_panner_box.pack_start (*rec_enable_button); + rec_solo_table.attach (*rec_enable_button, 0, 1, 0, 2); rec_enable_button->set_sensitive (_session->writable()); rec_enable_button->show(); @@ -443,12 +496,12 @@ MixerStrip::set_route (boost::shared_ptr rt) /* non-master bus */ if (!_route->is_master()) { - below_panner_box.pack_start (*show_sends_button); + rec_solo_table.attach (*show_sends_button, 0, 1, 0, 2); show_sends_button->show(); } } - meter_point_label.set_text (meter_point_string (_route->meter_point())); + meter_point_button.set_text (meter_point_string (_route->meter_point())); delete route_ops_menu; route_ops_menu = 0; @@ -464,7 +517,8 @@ MixerStrip::set_route (boost::shared_ptr rt) audio_track()->DiskstreamChanged.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::diskstream_changed, this), gui_context()); } - _route->comment_changed.connect (route_connections, invalidator (*this), ui_bind (&MixerStrip::comment_changed, this, _1), gui_context()); + _route->comment_changed.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::comment_changed, this, _1), gui_context()); + _route->PropertyChanged.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::property_changed, this, _1), gui_context()); set_stuff_from_route (); @@ -479,6 +533,12 @@ MixerStrip::set_route (boost::shared_ptr rt) connect_to_pan (); panners.setup_pan (); + if (has_audio_outputs ()) { + panners.show_all (); + } else { + panners.hide_all (); + } + update_diskstream_display (); update_input_display (); update_output_display (); @@ -492,6 +552,10 @@ MixerStrip::set_route (boost::shared_ptr rt) hide_button.show(); } + gpm.reset_peak_display (); + gpm.gain_display.show (); + gpm.peak_display.show (); + width_button.show(); width_hide_box.show(); whvbox.show (); @@ -501,19 +565,15 @@ MixerStrip::set_route (boost::shared_ptr rt) middle_button_table.show(); bottom_button_table.show(); gpm.show_all (); - gain_unit_button.show(); - gain_unit_label.show(); meter_point_button.show(); - meter_point_label.show(); - diskstream_button.show(); - diskstream_label.show(); input_button_box.show_all(); output_button.show(); - output_label.show(); - name_label.show(); name_button.show(); + _comment_button.show(); group_button.show(); - group_label.show(); + gpm.gain_automation_state_button.show(); + + parameter_changed ("mixer-strip-visibility"); show (); } @@ -551,13 +611,15 @@ MixerStrip::set_width_enum (Width w, void* owner) switch (w) { case Wide: + if (show_sends_button) { - ((Gtk::Label*)show_sends_button->get_child())->set_text (_("Sends")); + show_sends_button->set_text (_("Aux\nSends")); + show_sends_button->layout()->set_alignment (Pango::ALIGN_CENTER); } - ((Gtk::Label*)gpm.gain_automation_style_button.get_child())->set_text ( + gpm.gain_automation_style_button.set_text ( gpm.astyle_string(gain_automation->automation_style())); - ((Gtk::Label*)gpm.gain_automation_state_button.get_child())->set_text ( + gpm.gain_automation_state_button.set_text ( gpm.astate_string(gain_automation->automation_state())); if (_route->panner()) { @@ -567,21 +629,20 @@ MixerStrip::set_width_enum (Width w, void* owner) panners.astate_string(_route->panner()->automation_state())); } - _iso_label->show (); - _safe_label->show (); - Gtkmm2ext::set_size_request_to_display_given_text (name_button, "long", 2, 2); + Gtkmm2ext::set_size_request_to_display_given_text (name_button, longest_label.c_str(), 2, 2); set_size_request (-1, -1); break; case Narrow: + if (show_sends_button) { - ((Gtk::Label*)show_sends_button->get_child())->set_text (_("Snd")); + show_sends_button->set_text (_("Snd")); } - ((Gtk::Label*)gpm.gain_automation_style_button.get_child())->set_text ( + gpm.gain_automation_style_button.set_text ( gpm.short_astyle_string(gain_automation->automation_style())); - ((Gtk::Label*)gpm.gain_automation_state_button.get_child())->set_text ( + gpm.gain_automation_state_button.set_text ( gpm.short_astate_string(gain_automation->automation_state())); if (_route->panner()) { @@ -591,10 +652,7 @@ MixerStrip::set_width_enum (Width w, void* owner) panners.short_astate_string(_route->panner()->automation_state())); } - _iso_label->hide (); - _safe_label->hide (); - - Gtkmm2ext::set_size_request_to_display_given_text (name_button, longest_label.c_str(), 2, 2); + Gtkmm2ext::set_size_request_to_display_given_text (name_button, "long", 2, 2); set_size_request (max (50, gpm.get_gm_width()), -1); break; } @@ -603,6 +661,7 @@ MixerStrip::set_width_enum (Width w, void* owner) update_input_display (); update_output_display (); + setup_comment_button (); route_group_changed (); name_changed (); WidthChanged (); @@ -651,7 +710,18 @@ MixerStrip::output_press (GdkEventButton *ev) output_menu_bundles.clear (); citems.push_back (MenuElem (_("Disconnect"), sigc::mem_fun (*(static_cast(this)), &RouteUI::disconnect_output))); + + for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) { + citems.push_back ( + MenuElem ( + string_compose ("Add %1 port", (*i).to_i18n_string()), + sigc::bind (sigc::mem_fun (*this, &MixerStrip::add_output_port), *i) + ) + ); + } + citems.push_back (SeparatorElem()); + uint32_t const n_with_separator = citems.size (); ARDOUR::BundleList current = _route->output()->bundles_connected (); @@ -678,7 +748,7 @@ MixerStrip::output_press (GdkEventButton *ev) maybe_add_bundle_to_output_menu ((*i)->input()->bundle(), current); } - if (citems.size() == 2) { + if (citems.size() == n_with_separator) { /* no routes added; remove the separator */ citems.pop_back (); } @@ -719,6 +789,8 @@ MixerStrip::edit_output_configuration () } else { output_selector->present (); } + + output_selector->set_keep_above (true); } void @@ -733,6 +805,8 @@ MixerStrip::edit_input_configuration () } else { input_selector->present (); } + + input_selector->set_keep_above (true); } gint @@ -762,7 +836,19 @@ MixerStrip::input_press (GdkEventButton *ev) case 3: { citems.push_back (MenuElem (_("Disconnect"), sigc::mem_fun (*(static_cast(this)), &RouteUI::disconnect_input))); + + for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) { + citems.push_back ( + MenuElem ( + string_compose ("Add %1 port", (*i).to_i18n_string()), + sigc::bind (sigc::mem_fun (*this, &MixerStrip::add_input_port), *i) + ) + ); + } + citems.push_back (SeparatorElem()); + uint32_t const n_with_separator = citems.size (); + input_menu_bundles.clear (); ARDOUR::BundleList current = _route->input()->bundles_connected (); @@ -790,7 +876,7 @@ MixerStrip::input_press (GdkEventButton *ev) maybe_add_bundle_to_input_menu ((*i)->output()->bundle(), current); } - if (citems.size() == 2) { + if (citems.size() == n_with_separator) { /* no routes added; remove the separator */ citems.pop_back (); } @@ -805,7 +891,7 @@ MixerStrip::input_press (GdkEventButton *ev) } void -MixerStrip::bundle_input_toggled (boost::shared_ptr c) +MixerStrip::bundle_input_chosen (boost::shared_ptr c) { if (ignore_toggle) { return; @@ -814,14 +900,14 @@ MixerStrip::bundle_input_toggled (boost::shared_ptr c) ARDOUR::BundleList current = _route->input()->bundles_connected (); if (std::find (current.begin(), current.end(), c) == current.end()) { - _route->input()->connect_ports_to_bundle (c, this); + _route->input()->connect_ports_to_bundle (c, true, this); } else { _route->input()->disconnect_ports_from_bundle (c, this); } } void -MixerStrip::bundle_output_toggled (boost::shared_ptr c) +MixerStrip::bundle_output_chosen (boost::shared_ptr c) { if (ignore_toggle) { return; @@ -830,18 +916,18 @@ MixerStrip::bundle_output_toggled (boost::shared_ptr c) ARDOUR::BundleList current = _route->output()->bundles_connected (); if (std::find (current.begin(), current.end(), c) == current.end()) { - _route->output()->connect_ports_to_bundle (c, this); + _route->output()->connect_ports_to_bundle (c, true, this); } else { _route->output()->disconnect_ports_from_bundle (c, this); } } void -MixerStrip::maybe_add_bundle_to_input_menu (boost::shared_ptr b, ARDOUR::BundleList const & current) +MixerStrip::maybe_add_bundle_to_input_menu (boost::shared_ptr b, ARDOUR::BundleList const& /*current*/) { using namespace Menu_Helpers; - if (b->ports_are_outputs() == false || b->nchannels() != _route->n_inputs()) { + if (b->ports_are_outputs() == false || b->nchannels() != _route->n_inputs() || *b == *_route->output()->bundle()) { return; } @@ -861,21 +947,15 @@ MixerStrip::maybe_add_bundle_to_input_menu (boost::shared_ptr b, ARDOUR: std::string n = b->name (); replace_all (n, "_", " "); - citems.push_back (CheckMenuElem (n, sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_input_toggled), b))); - - if (std::find (current.begin(), current.end(), b) != current.end()) { - ignore_toggle = true; - dynamic_cast (&citems.back())->set_active (true); - ignore_toggle = false; - } + citems.push_back (MenuElem (n, sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_input_chosen), b))); } void -MixerStrip::maybe_add_bundle_to_output_menu (boost::shared_ptr b, ARDOUR::BundleList const & current) +MixerStrip::maybe_add_bundle_to_output_menu (boost::shared_ptr b, ARDOUR::BundleList const& /*current*/) { using namespace Menu_Helpers; - if (b->ports_are_inputs() == false || b->nchannels() != _route->n_outputs()) { + if (b->ports_are_inputs() == false || b->nchannels() != _route->n_outputs() || *b == *_route->input()->bundle()) { return; } @@ -895,13 +975,7 @@ MixerStrip::maybe_add_bundle_to_output_menu (boost::shared_ptr b, ARDOUR std::string n = b->name (); replace_all (n, "_", " "); - citems.push_back (CheckMenuElem (n, sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_output_toggled), b))); - - if (std::find (current.begin(), current.end(), b) != current.end()) { - ignore_toggle = true; - dynamic_cast (&citems.back())->set_active (true); - ignore_toggle = false; - } + citems.push_back (MenuElem (n, sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_output_chosen), b))); } void @@ -986,7 +1060,7 @@ MixerStrip::update_io_button (boost::shared_ptr route, Width widt { uint32_t io_count; uint32_t io_index; - Port *port; + boost::shared_ptr port; vector port_connections; uint32_t total_connection_count = 0; @@ -1010,14 +1084,15 @@ MixerStrip::update_io_button (boost::shared_ptr route, Width widt ostringstream tooltip; char * tooltip_cstr; - tooltip << route->name(); - if (for_input) { io_count = route->n_inputs().n_total(); + tooltip << string_compose (_("INPUT to %1"), Glib::Markup::escape_text(route->name())); } else { io_count = route->n_outputs().n_total(); + tooltip << string_compose (_("OUTPUT from %1"), Glib::Markup::escape_text(route->name())); } + for (io_index = 0; io_index < io_count; ++io_index) { if (for_input) { port = route->input()->nth (io_index); @@ -1034,9 +1109,9 @@ MixerStrip::update_io_button (boost::shared_ptr route, Width widt string& connection_name (*i); if (io_connection_count == 0) { - tooltip << endl << port->name().substr(port->name().find("/") + 1) << " -> " << connection_name; + tooltip << endl << Glib::Markup::escape_text(port->name().substr(port->name().find("/") + 1)) << " -> " << Glib::Markup::escape_text(connection_name); } else { - tooltip << ", " << connection_name; + tooltip << ", " << Glib::Markup::escape_text(connection_name); } if (connection_name.find("ardour:") == 0) { @@ -1102,7 +1177,7 @@ MixerStrip::update_io_button (boost::shared_ptr route, Width widt } if (each_io_has_one_connection) { - if ((total_connection_count == ardour_connection_count)) { + if (total_connection_count == ardour_connection_count) { // all connections are to the same track in ardour // "ardour:Master/" -> "Master" string::size_type slash = ardour_track_name.find("/"); @@ -1136,7 +1211,7 @@ MixerStrip::update_io_button (boost::shared_ptr route, Width widt switch (width) { case Wide: - label_string = label.str().substr(0, 6); + label_string = label.str().substr(0, 7); break; case Narrow: label_string = label.str().substr(0, 3); @@ -1144,9 +1219,9 @@ MixerStrip::update_io_button (boost::shared_ptr route, Width widt } if (for_input) { - input_label.set_text (label_string); + input_button.set_text (label_string); } else { - output_label.set_text (label_string); + output_button.set_text (label_string); } } @@ -1155,6 +1230,13 @@ MixerStrip::update_input_display () { update_io_button (_route, _width, true); panners.setup_pan (); + + if (has_audio_outputs ()) { + panners.show_all (); + } else { + panners.hide_all (); + } + } void @@ -1163,6 +1245,12 @@ MixerStrip::update_output_display () update_io_button (_route, _width, false); gpm.setup_meters (); panners.setup_pan (); + + if (has_audio_outputs ()) { + panners.show_all (); + } else { + panners.hide_all (); + } } void @@ -1178,48 +1266,84 @@ MixerStrip::diskstream_changed () } void -MixerStrip::port_connected_or_disconnected (Port* a, Port* b) +MixerStrip::port_connected_or_disconnected (boost::weak_ptr wa, boost::weak_ptr wb) { - if (_route->input()->has_port (a) || _route->input()->has_port (b)) { + boost::shared_ptr a = wa.lock (); + boost::shared_ptr b = wb.lock (); + + if ((a && _route->input()->has_port (a)) || (b && _route->input()->has_port (b))) { update_input_display (); set_width_enum (_width, this); } - if (_route->output()->has_port (a) || _route->output()->has_port (b)) { + if ((a && _route->output()->has_port (a)) || (b && _route->output()->has_port (b))) { update_output_display (); set_width_enum (_width, this); } } void -MixerStrip::comment_editor_done_editing () +MixerStrip::setup_comment_button () { - ignore_toggle = true; - _comment_menu_item->set_active (false); - ignore_toggle = false; + switch (_width) { + + case Wide: + if (_route->comment().empty ()) { + _comment_button.unset_bg (STATE_NORMAL); + _comment_button.set_text (_("Comments")); + } else { + _comment_button.modify_bg (STATE_NORMAL, color ()); + _comment_button.set_text (_("*Comments*")); + } + break; + + case Narrow: + if (_route->comment().empty ()) { + _comment_button.unset_bg (STATE_NORMAL); + _comment_button.set_text (_("Cmt")); + } else { + _comment_button.modify_bg (STATE_NORMAL, color ()); + _comment_button.set_text (_("*Cmt*")); + } + break; + } + + ARDOUR_UI::instance()->set_tip ( + _comment_button, _route->comment().empty() ? _("Click to Add/Edit Comments") : _route->comment() + ); +} +void +MixerStrip::comment_editor_done_editing () +{ string const str = comment_area->get_buffer()->get_text(); if (str == _route->comment ()) { return; } _route->set_comment (str, this); + setup_comment_button (); } void -MixerStrip::toggle_comment () +MixerStrip::toggle_comment_editor () { if (ignore_toggle) { return; } - if (comment_window == 0) { - setup_comment_editor (); + if (comment_window && comment_window->is_visible ()) { + comment_window->hide (); + } else { + open_comment_editor (); } +} - if (comment_window->is_visible ()) { - comment_window->hide (); - return; +void +MixerStrip::open_comment_editor () +{ + if (comment_window == 0) { + setup_comment_editor (); } string title; @@ -1233,7 +1357,7 @@ MixerStrip::toggle_comment () void MixerStrip::setup_comment_editor () { - comment_window = new ArdourDialog ("", false); // title will be reset to show route + comment_window = new ArdourWindow (""); // title will be reset to show route comment_window->set_position (Gtk::WIN_POS_MOUSE); comment_window->set_skip_taskbar_hint (true); comment_window->signal_hide().connect (sigc::mem_fun(*this, &MixerStrip::comment_editor_done_editing)); @@ -1246,8 +1370,7 @@ MixerStrip::setup_comment_editor () comment_area->get_buffer()->set_text (_route->comment()); comment_area->show (); - comment_window->get_vbox()->pack_start (*comment_area); - comment_window->get_action_area()->hide(); + comment_window->add (*comment_area); } void @@ -1299,14 +1422,14 @@ MixerStrip::route_group_changed () RouteGroup *rg = _route->route_group(); if (rg) { - group_label.set_text (PBD::short_version (rg->name(), 5)); + group_button.set_text (PBD::short_version (rg->name(), 5)); } else { switch (_width) { case Wide: - group_label.set_text (_("Grp")); + group_button.set_text (_("Grp")); break; case Narrow: - group_label.set_text (_("~G")); + group_button.set_text (_("~G")); break; } } @@ -1335,11 +1458,13 @@ MixerStrip::build_route_ops_menu () MenuList& items = route_ops_menu->items(); - items.push_back (CheckMenuElem (_("Comments..."), sigc::mem_fun (*this, &MixerStrip::toggle_comment))); - _comment_menu_item = dynamic_cast (&items.back ()); - items.push_back (MenuElem (_("Save As Template..."), sigc::mem_fun(*this, &RouteUI::save_as_template))); + items.push_back (MenuElem (_("Comments..."), sigc::mem_fun (*this, &MixerStrip::open_comment_editor))); + if (!_route->is_master()) { + items.push_back (MenuElem (_("Save As Template..."), sigc::mem_fun(*this, &RouteUI::save_as_template))); + } items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteUI::route_rename))); rename_menu_item = &items.back(); + items.push_back (SeparatorElem()); items.push_back (CheckMenuElem (_("Active"))); CheckMenuItem* i = dynamic_cast (&items.back()); @@ -1367,15 +1492,16 @@ MixerStrip::build_route_ops_menu () gboolean MixerStrip::name_button_button_press (GdkEventButton* ev) { - if (ev->button == 3) { + /* show menu for either button 1 or 3, so as not to confuse people + and also not hide stuff from them. + */ + + if (ev->button == 3 || ev->button == 1) { list_route_operations (); /* do not allow rename if the track is record-enabled */ rename_menu_item->set_sensitive (!_route->record_enabled()); route_ops_menu->popup (1, ev->time); - - } else if (ev->button == 1) { - revert_to_default_display (); } return false; @@ -1402,30 +1528,66 @@ MixerStrip::set_selected (bool yn) global_frame.queue_draw (); } +void +MixerStrip::property_changed (const PropertyChange& what_changed) +{ + RouteUI::property_changed (what_changed); + + if (what_changed.contains (ARDOUR::Properties::name)) { + name_changed (); + } +} + void MixerStrip::name_changed () { switch (_width) { case Wide: - RouteUI::property_changed (PropertyChange (ARDOUR::Properties::name)); + name_button.set_text (_route->name()); break; case Narrow: - name_label.set_text (PBD::short_version (_route->name(), 5)); + name_button.set_text (PBD::short_version (_route->name(), 5)); break; } + + ARDOUR_UI::instance()->set_tip (name_button, _route->name()); } void -MixerStrip::width_clicked () +MixerStrip::name_button_resized (Gtk::Allocation& alloc) { - switch (_width) { - case Wide: - set_width_enum (Narrow, this); - break; - case Narrow: - set_width_enum (Wide, this); - break; + name_button.layout()->set_width (alloc.get_width() * PANGO_SCALE); +} + +bool +MixerStrip::width_button_pressed (GdkEventButton* ev) +{ + if (ev->button != 1) { + return false; } + + if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier | Keyboard::TertiaryModifier)) && _mixer_owned) { + switch (_width) { + case Wide: + _mixer.set_strip_width (Narrow); + break; + + case Narrow: + _mixer.set_strip_width (Wide); + break; + } + } else { + switch (_width) { + case Wide: + set_width_enum (Narrow, this); + break; + case Narrow: + set_width_enum (Wide, this); + break; + } + } + + return true; } void @@ -1534,11 +1696,6 @@ MixerStrip::reset_strip_style () } } -RouteGroup* -MixerStrip::route_group() const -{ - return _route->route_group(); -} void MixerStrip::engine_stopped () @@ -1553,71 +1710,86 @@ MixerStrip::engine_running () string MixerStrip::meter_point_string (MeterPoint mp) { - switch (mp) { - case MeterInput: - return _("in"); - break; - - case MeterPreFader: - return _("pre"); - break; - - case MeterPostFader: - return _("post"); - break; - - case MeterOutput: - return _("out"); + switch (_width) { + case Wide: + switch (mp) { + case MeterInput: + return _("in"); + break; + + case MeterPreFader: + return _("pre"); + break; + + case MeterPostFader: + return _("post"); + break; + + case MeterOutput: + return _("out"); + break; + + case MeterCustom: + default: + return _("custom"); + break; + } break; - - case MeterCustom: - default: - return _("custom"); + case Narrow: + switch (mp) { + case MeterInput: + return _("in"); + break; + + case MeterPreFader: + return _("pr"); + break; + + case MeterPostFader: + return _("po"); + break; + + case MeterOutput: + return _("o"); + break; + + case MeterCustom: + default: + return _("c"); + break; + } break; } + + return string(); } /** Called when the metering point has changed */ void MixerStrip::meter_changed () { - meter_point_label.set_text (meter_point_string (_route->meter_point())); + meter_point_button.set_text (meter_point_string (_route->meter_point())); gpm.setup_meters (); // reset peak when meter point changes gpm.reset_peak_display(); } +/** The bus that we are displaying sends to has changed, or been turned off. + * @param send_to New bus that we are displaying sends to, or 0. + */ void -MixerStrip::switch_io (boost::shared_ptr target) +MixerStrip::bus_send_display_changed (boost::shared_ptr send_to) { - /* don't respond to switch IO signal outside of the mixer window */ - - if (!_mixer_owned) { - return; - } - - if (_route == target || _route->is_master()) { - /* don't change the display for the target or the master bus */ - return; - } else if (!is_track() && show_sends_button) { - /* make sure our show sends button is inactive, and we no longer blink, - since we're not the target. - */ - send_blink_connection.disconnect (); - show_sends_button->set_active (false); - show_sends_button->set_state (STATE_NORMAL); - } - - if (!target) { - /* switch back to default */ - revert_to_default_display (); - return; - } + RouteUI::bus_send_display_changed (send_to); - boost::shared_ptr send = _route->internal_send_for (target); + if (send_to) { + boost::shared_ptr send = _route->internal_send_for (send_to); - if (send) { - show_send (send); + if (send) { + show_send (send); + } else { + revert_to_default_display (); + } } else { revert_to_default_display (); } @@ -1628,7 +1800,7 @@ MixerStrip::drop_send () { boost::shared_ptr current_send; - if (_current_delivery && (current_send = boost::dynamic_pointer_cast(_current_delivery))) { + if (_current_delivery && ((current_send = boost::dynamic_pointer_cast(_current_delivery)) != 0)) { current_send->set_metering (false); } @@ -1643,6 +1815,9 @@ MixerStrip::drop_send () rec_enable_button->set_sensitive (true); solo_isolated_led->set_sensitive (true); solo_safe_led->set_sensitive (true); + monitor_input_button->set_sensitive (true); + monitor_disk_button->set_sensitive (true); + _comment_button.set_sensitive (true); } void @@ -1670,6 +1845,14 @@ MixerStrip::show_send (boost::shared_ptr send) panner_ui().set_panner (_current_delivery->panner_shell(), _current_delivery->panner()); panner_ui().setup_pan (); + /* make sure the send has audio output */ + + if (_current_delivery->output() && _current_delivery->output()->n_ports().n_audio() > 0) { + panners.show_all (); + } else { + panners.hide_all (); + } + input_button.set_sensitive (false); group_button.set_sensitive (false); set_invert_sensitive (false); @@ -1679,6 +1862,9 @@ MixerStrip::show_send (boost::shared_ptr send) rec_enable_button->set_sensitive (false); solo_isolated_led->set_sensitive (false); solo_safe_led->set_sensitive (false); + monitor_input_button->set_sensitive (false); + monitor_disk_button->set_sensitive (false); + _comment_button.set_sensitive (false); if (boost::dynamic_pointer_cast(send)) { output_button.set_sensitive (false); @@ -1690,10 +1876,6 @@ MixerStrip::show_send (boost::shared_ptr send) void MixerStrip::revert_to_default_display () { - if (show_sends_button) { - show_sends_button->set_active (false); - } - drop_send (); set_current_delivery (_route->main_outs ()); @@ -1704,6 +1886,12 @@ MixerStrip::revert_to_default_display () panner_ui().set_panner (_route->main_outs()->panner_shell(), _route->main_outs()->panner()); panner_ui().setup_pan (); + if (has_audio_outputs ()) { + panners.show_all (); + } else { + panners.hide_all (); + } + reset_strip_style (); } @@ -1712,221 +1900,257 @@ MixerStrip::set_button_names () { switch (_width) { case Wide: - rec_enable_button_label.set_text (_("Rec")); - mute_button_label.set_text (_("Mute")); + rec_enable_button->set_text (_("Rec")); + mute_button->set_text (_("Mute")); + monitor_input_button->set_text (_("In")); + monitor_disk_button->set_text (_("Disk")); + if (_route && _route->solo_safe()) { - solo_button_label.set_text (X_("!")); + if (solo_safe_pixbuf == 0) { + solo_safe_pixbuf = ::get_icon("solo-safe-icon"); + } + solo_button->set_image (solo_safe_pixbuf); + solo_button->set_text (string()); } else { + solo_button->set_image (Glib::RefPtr()); if (!Config->get_solo_control_is_listen_control()) { - solo_button_label.set_text (_("Solo")); + solo_button->set_text (_("Solo")); } else { switch (Config->get_listen_position()) { case AfterFaderListen: - solo_button_label.set_text (_("AFL")); + solo_button->set_text (_("AFL")); break; case PreFaderListen: - solo_button_label.set_text (_("PFL")); + solo_button->set_text (_("PFL")); break; } } } + solo_isolated_led->set_text (_("iso")); + solo_safe_led->set_text (_("lock")); break; default: - rec_enable_button_label.set_text (_("R")); - mute_button_label.set_text (_("M")); + rec_enable_button->set_text (_("R")); + mute_button->set_text (_("M")); + monitor_input_button->set_text (_("I")); + monitor_disk_button->set_text (_("D")); if (_route && _route->solo_safe()) { - solo_button_label.set_text (X_("!")); + solo_button->remove (); + if (solo_safe_pixbuf == 0) { + solo_safe_pixbuf =::get_icon("solo-safe-icon"); + } + solo_button->set_image (solo_safe_pixbuf); + solo_button->set_text (string()); + } else { + solo_button->set_image (Glib::RefPtr()); if (!Config->get_solo_control_is_listen_control()) { - solo_button_label.set_text (_("S")); + solo_button->set_text (_("S")); } else { switch (Config->get_listen_position()) { case AfterFaderListen: - solo_button_label.set_text (_("A")); + solo_button->set_text (_("A")); break; case PreFaderListen: - solo_button_label.set_text (_("P")); + solo_button->set_text (_("P")); break; } } } + solo_isolated_led->set_text (_("i")); + solo_safe_led->set_text (_("L")); break; + } + if (_route) { + meter_point_button.set_text (meter_point_string (_route->meter_point())); + } else { + meter_point_button.set_text (""); } } -bool -MixerStrip::on_key_press_event (GdkEventKey* ev) +PluginSelector* +MixerStrip::plugin_selector() { - GdkEventButton fake; - fake.type = GDK_BUTTON_PRESS; - fake.button = 1; - fake.state = ev->state; + return _mixer.plugin_selector(); +} - switch (ev->keyval) { - case GDK_m: - mute_press (&fake); - return true; - break; +void +MixerStrip::hide_things () +{ + processor_box.hide_things (); +} - case GDK_s: - solo_press (&fake); - return true; - break; +bool +MixerStrip::input_active_button_press (GdkEventButton*) +{ + /* nothing happens on press */ + return true; +} - case GDK_r: - rec_enable_press (&fake); - return true; - break; +bool +MixerStrip::input_active_button_release (GdkEventButton* ev) +{ + boost::shared_ptr mt = midi_track (); - case GDK_e: - show_sends_press (&fake); + if (!mt) { return true; - break; + } - case GDK_g: - if (ev->state & Keyboard::PrimaryModifier) { - step_gain_down (); - } else { - step_gain_up (); - } - return true; - break; + boost::shared_ptr rl (new RouteList); - case GDK_0: - if (_route) { - _route->set_gain (1.0, this); - } - return true; + rl->push_back (route()); - default: - break; - } + _session->set_exclusive_input_active (rl, !mt->input_active(), + Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))); - return false; + return true; } - -bool -MixerStrip::on_key_release_event (GdkEventKey* ev) +void +MixerStrip::midi_input_status_changed () { - GdkEventButton fake; - fake.type = GDK_BUTTON_RELEASE; - fake.button = 1; - fake.state = ev->state; + if (midi_input_enable_button) { + boost::shared_ptr mt = midi_track (); + assert (mt); + midi_input_enable_button->set_active (mt->input_active ()); + } +} - switch (ev->keyval) { - case GDK_m: - mute_release (&fake); - return true; - break; +string +MixerStrip::state_id () const +{ + return string_compose ("strip %1", _route->id().to_s()); +} - case GDK_s: - solo_release (&fake); - return true; - break; +void +MixerStrip::parameter_changed (string p) +{ + if (p == _visibility.get_state_name()) { + /* The user has made changes to the mixer strip visibility, so get + our VisibilityGroup to reflect these changes in our widgets. + */ + _visibility.set_state (Config->get_mixer_strip_visibility ()); + } +} - case GDK_r: - rec_enable_release (&fake); - return true; - break; +/** Called to decide whether the solo isolate / solo lock button visibility should + * be overridden from that configured by the user. We do this for the master bus. + * + * @return optional value that is present if visibility state should be overridden. + */ +boost::optional +MixerStrip::override_solo_visibility () const +{ + if (_route && _route->is_master ()) { + return boost::optional (false); + } + + return boost::optional (); +} - case GDK_e: - show_sends_release (&fake); - return true; - break; +void +MixerStrip::add_input_port (DataType t) +{ + _route->input()->add_port ("", this, t); +} - case GDK_g: - return true; - break; +void +MixerStrip::add_output_port (DataType t) +{ + _route->output()->add_port ("", this, t); +} - default: - break; - } +void +MixerStrip::route_active_changed () +{ + reset_strip_style (); +} - return false; +void +MixerStrip::copy_processors () +{ + processor_box.processor_operation (ProcessorBox::ProcessorsCopy); } -bool -MixerStrip::on_enter_notify_event (GdkEventCrossing*) +void +MixerStrip::cut_processors () { - Keyboard::magic_widget_grab_focus (); - return false; + processor_box.processor_operation (ProcessorBox::ProcessorsCut); } -bool -MixerStrip::on_leave_notify_event (GdkEventCrossing* ev) +void +MixerStrip::paste_processors () { - switch (ev->detail) { - case GDK_NOTIFY_INFERIOR: - break; - default: - Keyboard::magic_widget_drop_focus (); - } + processor_box.processor_operation (ProcessorBox::ProcessorsPaste); +} - return false; +void +MixerStrip::select_all_processors () +{ + processor_box.processor_operation (ProcessorBox::ProcessorsSelectAll); } -PluginSelector* -MixerStrip::plugin_selector() +void +MixerStrip::delete_processors () { - return _mixer.plugin_selector(); + processor_box.processor_operation (ProcessorBox::ProcessorsDelete); } void -MixerStrip::hide_things () +MixerStrip::toggle_processors () { - processor_box.hide_things (); + processor_box.processor_operation (ProcessorBox::ProcessorsToggleActive); } -bool -MixerStrip::input_active_button_press (GdkEventButton* ev) +void +MixerStrip::ab_plugins () { - /* nothing happens on press */ - return true; + processor_box.processor_operation (ProcessorBox::ProcessorsAB); } bool -MixerStrip::input_active_button_release (GdkEventButton* ev) +MixerStrip::level_meter_button_press (GdkEventButton* ev) { - boost::shared_ptr mt = midi_track (); - - if (!mt) { + if (ev->button == 3) { + popup_level_meter_menu (ev); return true; } - if (mt->input_active()) { - if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) { - /* turn all other tracks using this input off */ - _session->set_exclusive_input_active (mt, false); - } else { - mt->set_input_active (false); - } + return false; +} - } else { - if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) { - /* turn all other tracks using this input on */ - _session->set_exclusive_input_active (mt, true); - } else { - mt->set_input_active (true); - } - } +void +MixerStrip::popup_level_meter_menu (GdkEventButton* ev) +{ + using namespace Gtk::Menu_Helpers; - return true; + Gtk::Menu* m = manage (new Menu); + MenuList& items = m->items (); + + RadioMenuItem::Group group; + + add_level_meter_item (items, group, _("Input"), MeterInput); + add_level_meter_item (items, group, _("Pre-fader"), MeterPreFader); + add_level_meter_item (items, group, _("Post-fader"), MeterPostFader); + add_level_meter_item (items, group, _("Output"), MeterOutput); + add_level_meter_item (items, group, _("Custom"), MeterCustom); + + m->popup (ev->button, ev->time); } void -MixerStrip::midi_input_status_changed () +MixerStrip::add_level_meter_item (Menu_Helpers::MenuList& items, RadioMenuItem::Group& group, string const & name, MeterPoint point) { - if (midi_input_enable_button) { - boost::shared_ptr mt = midi_track (); - assert (mt); - midi_input_enable_button->set_active (mt->input_active ()); - } + using namespace Menu_Helpers; + + items.push_back (RadioMenuElem (group, name, sigc::bind (sigc::mem_fun (*this, &MixerStrip::set_meter_point), point))); + RadioMenuItem* i = dynamic_cast (&items.back ()); + i->set_active (_route->meter_point() == point); } -string -MixerStrip::state_id () const +void +MixerStrip::set_meter_point (MeterPoint p) { - return string_compose ("strip %1", _route->id().to_s()); + _route->set_meter_point (p); }