X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fpanner_ui.cc;h=c04ca055b26f1d599bcd78bab761c3911ed1d6de;hb=4b5426eddefd742caa13f9539260ab97bc528a68;hp=74d50aa993e107b3858ae3d2306d5fedbab1b109;hpb=99281692de9a8b5c5b8a903b75e0ffc9620db616;p=ardour.git diff --git a/gtk2_ardour/panner_ui.cc b/gtk2_ardour/panner_ui.cc index 74d50aa993..c04ca055b2 100644 --- a/gtk2_ardour/panner_ui.cc +++ b/gtk2_ardour/panner_ui.cc @@ -14,92 +14,70 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - - $Id$ */ #include -#include -#include +#include "ardour/io.h" +#include "ardour/dB.h" #include #include #include -#include -#include +#include "midi++/manager.h" +#include "pbd/fastlog.h" #include "ardour_ui.h" #include "panner_ui.h" #include "panner2d.h" #include "utils.h" +#include "panner.h" #include "gui_thread.h" -#include -#include -#include +#include "ardour/delivery.h" +#include "ardour/session.h" +#include "ardour/panner.h" +#include "ardour/route.h" #include "i18n.h" +using namespace std; using namespace ARDOUR; +using namespace PBD; using namespace Gtkmm2ext; using namespace Gtk; using namespace sigc; -/* XPM */ -static const gchar * forwdblarrow_xpm[] = { -"20 11 3 1", -" c None", -". c #000000", -"+ c #FFFFFF", -" .. ", -" .+. ", -" .++. ", -" ..............+++. ", -" .+++++++++++++++++.", -" ...................", -" .+++++++++++++++++.", -" ..............+++. ", -" .++. ", -" .+. ", -" .. "}; - -/* XPM */ -static const gchar * revdblarrow_xpm[] = { -"20 11 3 1", -" c None", -". c #000000", -"+ c #FFFFFF", -" .. ", -" .+. ", -" .++. ", -" ..............+++. ", -" .+++++++++++++++++.", -" ...................", -" .+++++++++++++++++.", -" .+++..............", -" .++. ", -" .+. ", -" .. "}; - - -PannerUI::PannerUI (IO& io, Session& s) - : _io (io), - _session (s), +const int PannerUI::pan_bar_height = 30; + +PannerUI::PannerUI (Session& s) + : _session (s), + _current_nouts (-1), hAdjustment(0.0, 0.0, 0.0), vAdjustment(0.0, 0.0, 0.0), panning_viewport(hAdjustment, vAdjustment), panning_up_arrow (Gtk::ARROW_UP, Gtk::SHADOW_OUT), panning_down_arrow (Gtk::ARROW_DOWN, Gtk::SHADOW_OUT), - panning_link_button (_("link")) - + panning_link_button (_("link")), + pan_automation_style_button (""), + pan_automation_state_button ("") { ignore_toggle = false; pan_menu = 0; + pan_astate_menu = 0; + pan_astyle_menu = 0; in_pan_update = false; - pan_bar_packer.set_size_request (-1, 61); - panning_viewport.set_size_request (61, 61); + pan_automation_style_button.set_name ("MixerAutomationModeButton"); + pan_automation_state_button.set_name ("MixerAutomationPlaybackButton"); + ARDOUR_UI::instance()->tooltips().set_tip (pan_automation_state_button, _("Pan automation mode")); + ARDOUR_UI::instance()->tooltips().set_tip (pan_automation_style_button, _("Pan automation type")); + + //set_size_request_to_display_given_text (pan_automation_state_button, X_("O"), 2, 2); + //set_size_request_to_display_given_text (pan_automation_style_button, X_("0"), 2, 2); + + pan_bar_packer.set_size_request (-1, 61); + panning_viewport.set_size_request (-1, 61); panning_viewport.set_name (X_("BaseFrame")); ARDOUR_UI::instance()->tooltips().set_tip (panning_link_button, @@ -107,25 +85,31 @@ PannerUI::PannerUI (IO& io, Session& s) ARDOUR_UI::instance()->tooltips().set_tip (panning_link_direction_button, _("panning link direction")); - panning_link_box.pack_start (panning_link_button, true, true); - panning_link_box.pack_start (panning_link_direction_button, true, true); + pan_automation_style_button.unset_flags (Gtk::CAN_FOCUS); + pan_automation_state_button.unset_flags (Gtk::CAN_FOCUS); + + pan_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &PannerUI::pan_automation_style_button_event), false); + pan_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &PannerUI::pan_automation_state_button_event), false); panning_link_button.set_name (X_("PanningLinkButton")); panning_link_direction_button.set_name (X_("PanningLinkDirectionButton")); + panning_link_box.pack_start (panning_link_button, true, true); + panning_link_box.pack_start (panning_link_direction_button, true, true); + panning_link_box.pack_start (pan_automation_state_button, true, true); + /* the pixmap will be reset at some point, but the key thing is that we need a pixmap in the button just to get started. */ - - panning_link_direction_button.add (*(manage (new Image (Gdk::Pixbuf::create_from_xpm_data(forwdblarrow_xpm))))); + panning_link_direction_button.add (*(manage (new Image (get_xpm("forwardblarrow.xpm"))))); panning_link_direction_button.signal_clicked().connect (mem_fun(*this, &PannerUI::panning_link_direction_clicked)); panning_link_button.signal_button_press_event().connect - (mem_fun(*this, &PannerUI::panning_link_button_press)); + (mem_fun(*this, &PannerUI::panning_link_button_press), false); panning_link_button.signal_button_release_event().connect - (mem_fun(*this, &PannerUI::panning_link_button_release)); + (mem_fun(*this, &PannerUI::panning_link_button_release), false); panning_up.set_border_width (3); panning_down.set_border_width (3); @@ -136,47 +120,139 @@ PannerUI::PannerUI (IO& io, Session& s) panning_up_arrow.set_name (X_("PanScrollerArrow")); panning_down_arrow.set_name (X_("PanScrollerArrow")); - pan_vbox.set_spacing (4); + pan_vbox.set_spacing (2); pan_vbox.pack_start (panning_viewport, Gtk::PACK_SHRINK); pan_vbox.pack_start (panning_link_box, Gtk::PACK_SHRINK); - pack_start (pan_vbox, true, false); + pack_start (pan_vbox, true, true); panner = 0; + big_window = 0; + + set_width(Narrow); +} + +void +PannerUI::set_panner (boost::shared_ptr p) +{ + connections.clear (); + + delete pan_astyle_menu; + pan_astyle_menu = 0; + + delete pan_astate_menu; + pan_astate_menu = 0; + + _panner = p; - _io.panner().Changed.connect (mem_fun(*this, &PannerUI::panner_changed)); - _io.panner().LinkStateChanged.connect (mem_fun(*this, &PannerUI::update_pan_linkage)); - _io.panner().StateChanged.connect (mem_fun(*this, &PannerUI::update_pan_state)); + delete panner; + panner = 0; + + if (!_panner) { + return; + } + + connections.push_back (_panner->Changed.connect (mem_fun(*this, &PannerUI::panner_changed))); + connections.push_back (_panner->LinkStateChanged.connect (mem_fun(*this, &PannerUI::update_pan_linkage))); + connections.push_back (_panner->StateChanged.connect (mem_fun(*this, &PannerUI::update_pan_state))); + + setup_pan (); pan_changed (0); update_pan_sensitive (); update_pan_linkage (); + pan_automation_state_changed (); + +#if WHERE_DOES_THIS_LIVE + pan_bar_packer.show(); + panning_viewport.show(); + panning_up.show(); + panning_up_arrow.show(); + panning_down.show(); + panning_down_arrow.show(); + pan_vbox.show(); + panning_link_button.show(); + panning_link_direction_button.show(); + panning_link_box.show(); + pan_automation_style_button.show(); + pan_automation_state_button.show(); + show(); +#endif } -gint -PannerUI::panning_link_button_press (GdkEventButton* ev) +void +PannerUI::build_astate_menu () { - return stop_signal (panning_link_button, "button-press-event"); + using namespace Menu_Helpers; + + if (pan_astate_menu == 0) { + pan_astate_menu = new Menu; + pan_astate_menu->set_name ("ArdourContextMenu"); + } else { + pan_astate_menu->items().clear (); + } + + pan_astate_menu->items().push_back (MenuElem (_("Manual"), bind ( + mem_fun (_panner.get(), &Panner::set_automation_state), + (AutoState) Off))); + pan_astate_menu->items().push_back (MenuElem (_("Play"), bind ( + mem_fun (_panner.get(), &Panner::set_automation_state), + (AutoState) Play))); + pan_astate_menu->items().push_back (MenuElem (_("Write"), bind ( + mem_fun (_panner.get(), &Panner::set_automation_state), + (AutoState) Write))); + pan_astate_menu->items().push_back (MenuElem (_("Touch"), bind ( + mem_fun (_panner.get(), &Panner::set_automation_state), + (AutoState) Touch))); + } -gint -PannerUI::panning_link_button_release (GdkEventButton* ev) +void +PannerUI::build_astyle_menu () +{ + using namespace Menu_Helpers; + + if (pan_astyle_menu == 0) { + pan_astyle_menu = new Menu; + pan_astyle_menu->set_name ("ArdourContextMenu"); + } else { + pan_astyle_menu->items().clear(); + } + + pan_astyle_menu->items().push_back (MenuElem (_("Trim"))); + pan_astyle_menu->items().push_back (MenuElem (_("Abs"))); +} + +boost::shared_ptr +PannerUI::get_controllable() +{ + return pan_bars[0]->get_controllable(); +} + +bool +PannerUI::panning_link_button_press (GdkEventButton*) +{ + return true; +} + +bool +PannerUI::panning_link_button_release (GdkEventButton*) { if (!ignore_toggle) { - _io.panner().set_linked (!_io.panner().linked()); + _panner->set_linked (!_panner->linked()); } - return TRUE; + return true; } void PannerUI::panning_link_direction_clicked() { - switch (_io.panner().link_direction()) { + switch (_panner->link_direction()) { case Panner::SameDirection: - _io.panner().set_link_direction (Panner::OppositeDirection); + _panner->set_link_direction (Panner::OppositeDirection); break; default: - _io.panner().set_link_direction (Panner::SameDirection); + _panner->set_link_direction (Panner::SameDirection); break; } } @@ -186,9 +262,9 @@ PannerUI::update_pan_linkage () { ENSURE_GUI_THREAD(mem_fun(*this, &PannerUI::update_pan_linkage)); - bool x = _io.panner().linked(); + bool x = _panner->linked(); bool bx = panning_link_button.get_active(); - + if (x != bx) { ignore_toggle = true; @@ -198,12 +274,12 @@ PannerUI::update_pan_linkage () panning_link_direction_button.set_sensitive (x); - switch (_io.panner().link_direction()) { + switch (_panner->link_direction()) { case Panner::SameDirection: - panning_link_direction_button.set_image (*(manage (new Image (Gdk::Pixbuf::create_from_xpm_data (forwdblarrow_xpm))))); + panning_link_direction_button.set_image (*(manage (new Image (get_xpm ("forwardblarrow.xpm"))))); break; default: - panning_link_direction_button.set_image (*(manage (new Image (Gdk::Pixbuf::create_from_xpm_data (revdblarrow_xpm))))); + panning_link_direction_button.set_image (*(manage (new Image (get_xpm("revdblarrow.xpm"))))); break; } } @@ -213,24 +289,10 @@ PannerUI::set_width (Width w) { switch (w) { case Wide: - panning_viewport.set_size_request (61, 61); - if (panner) { - panner->set_size_request (61, 61); - } - for (vector::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) { - (*i)->set_size_request (61, 15); - } - static_cast (panning_link_button.get_child())->set_text (_("link")); + panning_link_button.set_label (_("link")); break; case Narrow: - panning_viewport.set_size_request (31, 61); - if (panner) { - panner->set_size_request (31, 61); - } - for (vector::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) { - (*i)->set_size_request (31, 15); - } - static_cast (panning_link_button.get_child())->set_text (_("L")); + panning_link_button.set_label (_("L")); break; } @@ -244,18 +306,15 @@ PannerUI::~PannerUI () delete (*i); } - for (vector::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) { + for (vector::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) { delete (*i); } - if (panner) { - delete panner; - } - - if (pan_menu) { - delete pan_menu; - } - + delete panner; + delete big_window; + delete pan_menu; + delete pan_astyle_menu; + delete pan_astate_menu; } @@ -264,6 +323,7 @@ PannerUI::panner_changed () { ENSURE_GUI_THREAD (mem_fun(*this, &PannerUI::panner_changed)); setup_pan (); + pan_changed (0); } void @@ -276,7 +336,19 @@ PannerUI::update_pan_state () void PannerUI::setup_pan () { - uint32_t nouts = _io.n_outputs (); + if (!_panner) { + return; + } + + uint32_t nouts = _panner->nouts(); + + if (nouts == _current_nouts) { + return; + } + + _current_nouts = nouts; + + cout << "Setup pan for " << _panner->name() << endl; if (nouts == 0 || nouts == 1) { @@ -287,10 +359,17 @@ PannerUI::setup_pan () pan_adjustments.pop_back (); } + /* stick something into the panning viewport so that it redraws */ + + EventBox* eb = manage (new EventBox()); + panning_viewport.remove (); + panning_viewport.add (*eb); + panning_viewport.show_all (); + } else if (nouts == 2) { vector::size_type asz; - uint32_t npans = _io.panner().size(); + uint32_t npans = _panner->npanners(); while (!pan_adjustments.empty()) { delete pan_bars.back(); @@ -301,51 +380,56 @@ PannerUI::setup_pan () while ((asz = pan_adjustments.size()) < npans) { - float x; - BarController* bc; + float x, rx; + PannerBar* bc; - /* initialize adjustment with current value of panner */ + /* initialize adjustment with 0.0 (L) or 1.0 (R) for the first and second panners, + which serves as a default, otherwise use current value */ + + rx = _panner->pan_control( asz)->get_value(); + + if (npans == 1) { + x = 0.5; + } else if (asz == 0) { + x = 0.0; + } else if (asz == 1) { + x = 1.0; + } else { + x = rx; + } - _io.panner()[asz]->get_position (x); + pan_adjustments.push_back (new Adjustment (x, 0, 1.0, 0.005, 0.05)); + bc = new PannerBar (*pan_adjustments[asz], + boost::static_pointer_cast( _panner->pan_control( asz )) ); - pan_adjustments.push_back (new Adjustment (x, 0, 1.0, 0.05, 0.1)); + /* now set adjustment with current value of panner, then connect the signals */ + pan_adjustments.back()->set_value(rx); pan_adjustments.back()->signal_value_changed().connect (bind (mem_fun(*this, &PannerUI::pan_adjustment_changed), (uint32_t) asz)); - _io.panner()[asz]->Changed.connect (bind (mem_fun(*this, &PannerUI::pan_value_changed), (uint32_t) asz)); + _panner->pan_control( asz )->Changed.connect (bind (mem_fun(*this, &PannerUI::pan_value_changed), (uint32_t) asz)); - bc = new BarController (*pan_adjustments[asz], - &_io.panner()[asz]->midi_control(), - bind (mem_fun(*this, &PannerUI::pan_printer), pan_adjustments[asz])); - - if (_session.midi_port()) { - _io.panner()[asz]->reset_midi_control (_session.midi_port(), true); - } bc->set_name ("PanSlider"); bc->set_shadow_type (Gtk::SHADOW_NONE); - bc->set_style (BarController::Line); - - bc->StartGesture.connect (bind (mem_fun (_io, &IO::start_pan_touch), (uint32_t) asz)); - bc->StopGesture.connect (bind (mem_fun (_io, &IO::end_pan_touch), (uint32_t) asz)); + + boost::shared_ptr ac = _panner->pan_control (asz); + + if (asz) { + bc->StartGesture.connect (mem_fun (*ac, &AutomationControl::start_touch)); + bc->StopGesture.connect (mem_fun (*ac, &AutomationControl::stop_touch)); + } char buf[64]; - snprintf (buf, sizeof (buf), _("panner for channel %u"), asz + 1); + snprintf (buf, sizeof (buf), _("panner for channel %zu"), asz + 1); ARDOUR_UI::instance()->tooltips().set_tip (bc->event_widget(), buf); bc->event_widget().signal_button_release_event().connect (bind (mem_fun(*this, &PannerUI::pan_button_event), (uint32_t) asz)); - pan_bars.push_back (bc); - switch (_width) { - case Wide: - pan_bars.back()->set_size_request (61, 15); - break; - case Narrow: - pan_bars.back()->set_size_request (31, 15); - break; - } + bc->set_size_request (-1, pan_bar_height); - pan_bar_packer.pack_start (*pan_bars.back(), false, false); + pan_bars.push_back (bc); + pan_bar_packer.pack_start (*bc, false, false); } /* now that we actually have the pan bars, @@ -361,26 +445,21 @@ PannerUI::setup_pan () } else { - int w = 0; - - switch (_width) { - case Wide: - w = 61; - break; - case Narrow: - w = 31; - break; - } - - if (panner == 0) { - panner = new Panner2d (_io.panner(), w, 61); + if (!panner) { + panner = new Panner2d (_panner, 61); panner->set_name ("MixerPanZone"); panner->show (); + + panner->signal_button_press_event().connect + (bind (mem_fun(*this, &PannerUI::pan_button_event), (uint32_t) 0), false); } update_pan_sensitive (); - panner->reset (_io.n_inputs()); - panner->set_size_request (w, 61); + panner->reset (nouts); + if (big_window) { + big_window->reset (_panner->npanners()); + } + panner->set_size_request (-1, 61); /* and finally, add it to the panner frame */ @@ -390,10 +469,20 @@ PannerUI::setup_pan () } } -gint +bool PannerUI::pan_button_event (GdkEventButton* ev, uint32_t which) { switch (ev->button) { + case 1: + if (panner && ev->type == GDK_2BUTTON_PRESS) { + if (!big_window) { + big_window = new Panner2dWindow (_panner, 400, _panner->npanners()); + } + big_window->show (); + return true; + } + break; + case 3: if (pan_menu == 0) { pan_menu = manage (new Menu); @@ -401,13 +490,13 @@ PannerUI::pan_button_event (GdkEventButton* ev, uint32_t which) } build_pan_menu (which); pan_menu->popup (1, ev->time); - return TRUE; + return true; break; default: - return FALSE; + return false; } - return FALSE; // what's wrong with gcc? + return false; // what's wrong with gcc? } void @@ -422,7 +511,7 @@ PannerUI::build_pan_menu (uint32_t which) /* set state first, connect second */ - (dynamic_cast (&items.back()))->set_active (_io.panner()[which]->muted()); + (dynamic_cast (&items.back()))->set_active (_panner->streampanner(which).muted()); (dynamic_cast (&items.back()))->signal_toggled().connect (bind (mem_fun(*this, &PannerUI::pan_mute), which)); @@ -431,42 +520,49 @@ PannerUI::build_pan_menu (uint32_t which) /* set state first, connect second */ - bypass_menu_item->set_active (_io.panner().bypassed()); + bypass_menu_item->set_active (_panner->bypassed()); bypass_menu_item->signal_toggled().connect (mem_fun(*this, &PannerUI::pan_bypass_toggle)); - items.push_back (MenuElem (_("Reset"), mem_fun(*this, &PannerUI::pan_reset))); + items.push_back (MenuElem (_("Reset"), bind (mem_fun (*this, &PannerUI::pan_reset), which))); items.push_back (SeparatorElem()); - items.push_back (MenuElem (_("Reset all"))); + items.push_back (MenuElem (_("Reset all"), mem_fun (*this, &PannerUI::pan_reset_all))); } void PannerUI::pan_mute (uint32_t which) { - StreamPanner* sp = _io.panner()[which]; - sp->set_muted (!sp->muted()); + StreamPanner& sp = _panner->streampanner(which); + sp.set_muted (!sp.muted()); } void PannerUI::pan_bypass_toggle () { - if (bypass_menu_item && (_io.panner().bypassed() != bypass_menu_item->get_active())) { - _io.panner().set_bypassed (!_io.panner().bypassed()); + if (bypass_menu_item && (_panner->bypassed() != bypass_menu_item->get_active())) { + _panner->set_bypassed (!_panner->bypassed()); } } void -PannerUI::pan_reset () +PannerUI::pan_reset (uint32_t which) { + _panner->reset_streampanner (which); +} + +void +PannerUI::pan_reset_all () +{ + _panner->reset_to_default (); } void PannerUI::effective_pan_display () { - if (_io.panner().empty()) { + if (_panner->empty()) { return; } - switch (_io.n_outputs()) { + switch (_panner->nouts()) { case 0: case 1: /* relax */ @@ -477,7 +573,7 @@ PannerUI::effective_pan_display () break; default: - //panner->move_puck (pan_value (v, right), 0.5); + //panner->move_puck (pan_value (v, right), 0.5); break; } } @@ -489,18 +585,21 @@ PannerUI::pan_changed (void *src) return; } - switch (_io.panner().size()) { + switch (_panner->npanners()) { case 0: - panning_link_box.set_sensitive (false); + panning_link_direction_button.set_sensitive (false); + panning_link_button.set_sensitive (false); return; case 1: - panning_link_box.set_sensitive (false); + panning_link_direction_button.set_sensitive (false); + panning_link_button.set_sensitive (false); break; default: - panning_link_box.set_sensitive (true); + panning_link_direction_button.set_sensitive (true); + panning_link_button.set_sensitive (true); } - uint32_t nouts = _io.n_outputs(); + uint32_t nouts = _panner->nouts(); switch (nouts) { case 0: @@ -509,6 +608,7 @@ PannerUI::pan_changed (void *src) break; case 2: + /* bring pan bar state up to date */ update_pan_bars (false); break; @@ -521,11 +621,11 @@ PannerUI::pan_changed (void *src) void PannerUI::pan_adjustment_changed (uint32_t which) { - if (!in_pan_update && which < _io.panner().size()) { + if (!in_pan_update && which < _panner->npanners()) { float xpos; float val = pan_adjustments[which]->get_value (); - _io.panner()[which]->get_position (xpos); + xpos = _panner->pan_control( which )->get_value(); /* add a kinda-sorta detent for the middle */ @@ -542,7 +642,7 @@ PannerUI::pan_adjustment_changed (uint32_t which) if (!Panner::equivalent (val, xpos)) { - _io.panner()[which]->set_position (val); + _panner->streampanner(which).set_position (val); /* XXX the panner objects have no access to the session, so do this here. ick. @@ -557,11 +657,11 @@ PannerUI::pan_value_changed (uint32_t which) { ENSURE_GUI_THREAD (bind (mem_fun(*this, &PannerUI::pan_value_changed), which)); - if (_io.n_outputs() > 1 && which < _io.panner().size()) { + if (_panner->npanners() > 1 && which < _panner->npanners()) { float xpos; float val = pan_adjustments[which]->get_value (); - _io.panner()[which]->get_position (xpos); + _panner->streampanner(which).get_position (xpos); if (!Panner::equivalent (val, xpos)) { in_pan_update = true; @@ -587,14 +687,14 @@ PannerUI::update_pan_bars (bool only_if_aplay) float xpos, val; if (only_if_aplay) { - AutomationList& alist (_io.panner()[n]->automation()); + boost::shared_ptr alist (_panner->streampanner(n).pan_control()->alist()); - if (!alist.automation_playback()) { + if (!alist->automation_playback()) { continue; } } - _io.panner()[n]->get_effective_position (xpos); + _panner->streampanner(n).get_effective_position (xpos); val = (*i)->get_value (); if (!Panner::equivalent (val, xpos)) { @@ -606,33 +706,16 @@ PannerUI::update_pan_bars (bool only_if_aplay) } void -PannerUI::pan_printer (char *buf, uint32_t len, Adjustment* adj) +PannerUI::update_pan_sensitive () { - float val = adj->get_value(); + bool sensitive = !(_panner->automation_state() & Play); - if (val == 0.0f) { - snprintf (buf, len, X_("L")); - } else if (val == 1.0f) { - snprintf (buf, len, X_("R")); - } else if (Panner::equivalent (val, 0.5f)) { - snprintf (buf, len, X_("C")); - } else { - /* don't print anything */ - buf[0] = '\0'; - } -} - -void -PannerUI::update_pan_sensitive () -{ - bool sensitive = !(_io.panner().automation_state() & Play); - - switch (_io.n_outputs()) { + switch (_panner->nouts()) { case 0: case 1: break; case 2: - for (vector::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) { + for (vector::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) { (*i)->set_sensitive (sensitive); } break; @@ -640,7 +723,170 @@ PannerUI::update_pan_sensitive () if (panner) { panner->set_sensitive (sensitive); } + if (big_window) { + big_window->set_sensitive (sensitive); + } + break; + } +} + +gint +PannerUI::pan_automation_state_button_event (GdkEventButton *ev) +{ + using namespace Menu_Helpers; + + if (ev->type == GDK_BUTTON_RELEASE) { + return TRUE; + } + + switch (ev->button) { + case 1: + if (pan_astate_menu == 0) { + build_astate_menu (); + } + pan_astate_menu->popup (1, ev->time); + break; + default: + break; + } + + return TRUE; +} + +gint +PannerUI::pan_automation_style_button_event (GdkEventButton *ev) +{ + if (ev->type == GDK_BUTTON_RELEASE) { + return TRUE; + } + + switch (ev->button) { + case 1: + if (pan_astyle_menu == 0) { + build_astyle_menu (); + } + pan_astyle_menu->popup (1, ev->time); + break; + default: + break; + } + return TRUE; +} + +void +PannerUI::pan_automation_style_changed () +{ + ENSURE_GUI_THREAD(mem_fun(*this, &PannerUI::pan_automation_style_changed)); + + switch (_width) { + case Wide: + pan_automation_style_button.set_label (astyle_string(_panner->automation_style())); + break; + case Narrow: + pan_automation_style_button.set_label (short_astyle_string(_panner->automation_style())); + break; + } +} + +void +PannerUI::pan_automation_state_changed () +{ + ENSURE_GUI_THREAD(mem_fun(*this, &PannerUI::pan_automation_state_changed)); + + bool x; + + switch (_width) { + case Wide: + pan_automation_state_button.set_label (astate_string(_panner->automation_state())); break; + case Narrow: + pan_automation_state_button.set_label (short_astate_string(_panner->automation_state())); + break; + } + + /* when creating a new session, we get to create busses (and + sometimes tracks) with no outputs by the time they get + here. + */ + + if (_panner->empty()) { + return; + } + + x = (_panner->streampanner(0).pan_control()->alist()->automation_state() != Off); + + if (pan_automation_state_button.get_active() != x) { + ignore_toggle = true; + pan_automation_state_button.set_active (x); + ignore_toggle = false; + } + + update_pan_sensitive (); + + /* start watching automation so that things move */ + + pan_watching.disconnect(); + + if (x) { + pan_watching = ARDOUR_UI::RapidScreenUpdate.connect (mem_fun (*this, &PannerUI::effective_pan_display)); } } +string +PannerUI::astate_string (AutoState state) +{ + return _astate_string (state, false); +} + +string +PannerUI::short_astate_string (AutoState state) +{ + return _astate_string (state, true); +} + +string +PannerUI::_astate_string (AutoState state, bool shrt) +{ + string sstr; + + switch (state) { + case Off: + sstr = (shrt ? "M" : _("M")); + break; + case Play: + sstr = (shrt ? "P" : _("P")); + break; + case Touch: + sstr = (shrt ? "T" : _("T")); + break; + case Write: + sstr = (shrt ? "W" : _("W")); + break; + } + + return sstr; +} + +string +PannerUI::astyle_string (AutoStyle style) +{ + return _astyle_string (style, false); +} + +string +PannerUI::short_astyle_string (AutoStyle style) +{ + return _astyle_string (style, true); +} + +string +PannerUI::_astyle_string (AutoStyle style, bool shrt) +{ + if (style & Trim) { + return _("Trim"); + } else { + /* XXX it might different in different languages */ + + return (shrt ? _("Abs") : _("Abs")); + } +}