X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fpanner_ui.cc;h=af207c20c13a6a43cb0fbcf8c77a2e9f7bdeba1b;hb=1b0b7849eea034f8809dea31419159724386c2db;hp=850070fabf2d5cae8f85d506456789a6816ffd3e;hpb=8b320ba5c6a234f288a3d6089aea18de7429c197;p=ardour.git diff --git a/gtk2_ardour/panner_ui.cc b/gtk2_ardour/panner_ui.cc index 850070fabf..af207c20c1 100644 --- a/gtk2_ardour/panner_ui.cc +++ b/gtk2_ardour/panner_ui.cc @@ -14,256 +14,200 @@ 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 "gui_thread.h" +#include "stereo_panner.h" +#include "mono_panner.h" -#include -#include -#include +#include "ardour/delivery.h" +#include "ardour/session.h" +#include "ardour/panner.h" +#include "ardour/pannable.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; +const int PannerUI::pan_bar_height = 40; -PannerUI::PannerUI (IO& io, Session& s) - : _io (io), - _session (s), - 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")), - pan_automation_style_button (""), - pan_automation_state_button ("") +PannerUI::PannerUI (Session* s) + : _current_nouts (-1) + , _current_nins (-1) + , pan_automation_style_button ("") + , pan_automation_state_button ("") { + set_session (s); + ignore_toggle = false; pan_menu = 0; + pan_astate_menu = 0; + pan_astyle_menu = 0; in_pan_update = false; + _stereo_panner = 0; + _ignore_width_change = false; + _ignore_position_change = false; 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")); + ARDOUR_UI::instance()->set_tip (pan_automation_state_button, _("Pan automation mode")); + ARDOUR_UI::instance()->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 (61, 61); - - panning_viewport.set_name (X_("BaseFrame")); - - ARDOUR_UI::instance()->tooltips().set_tip (panning_link_button, - _("panning link control")); - ARDOUR_UI::instance()->tooltips().set_tip (panning_link_direction_button, - _("panning link direction")); - pan_automation_style_button.unset_flags (Gtk::CAN_FOCUS); pan_automation_state_button.unset_flags (Gtk::CAN_FOCUS); - using namespace Menu_Helpers; - pan_astate_menu.items().push_back (MenuElem (_("Off"), - bind (mem_fun (_io.panner(), &Panner::set_automation_state), (AutoState) Off))); - pan_astate_menu.items().push_back (MenuElem (_("Play"), - bind (mem_fun (_io.panner(), &Panner::set_automation_state), (AutoState) Play))); - pan_astate_menu.items().push_back (MenuElem (_("Write"), - bind (mem_fun (_io.panner(), &Panner::set_automation_state), (AutoState) Write))); - pan_astate_menu.items().push_back (MenuElem (_("Touch"), - bind (mem_fun (_io.panner(), &Panner::set_automation_state), (AutoState) Touch))); - - pan_astyle_menu.items().push_back (MenuElem (_("Trim"))); - pan_astyle_menu.items().push_back (MenuElem (_("Abs"))); + pan_automation_style_button.signal_button_press_event().connect (sigc::mem_fun(*this, &PannerUI::pan_automation_style_button_event), false); + pan_automation_state_button.signal_button_press_event().connect (sigc::mem_fun(*this, &PannerUI::pan_automation_state_button_event), false); - pan_astate_menu.set_name ("ArdourContextMenu"); - pan_astyle_menu.set_name ("ArdourContextMenu"); + pan_vbox.set_spacing (2); + pack_start (pan_vbox, true, true); - 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); + twod_panner = 0; + big_window = 0; - panning_link_button.set_name (X_("PanningLinkButton")); - panning_link_direction_button.set_name (X_("PanningLinkDirectionButton")); + set_width(Narrow); +} - 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); +void +PannerUI::set_panner (boost::shared_ptr p) +{ + connections.drop_connections (); - /* 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 (get_xpm("forwardblarrow.xpm"))))); + delete pan_astyle_menu; + pan_astyle_menu = 0; - panning_link_direction_button.signal_clicked().connect - (mem_fun(*this, &PannerUI::panning_link_direction_clicked)); + delete pan_astate_menu; + pan_astate_menu = 0; - panning_link_button.signal_button_press_event().connect - (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), false); + _panner = p; - panning_up.set_border_width (3); - panning_down.set_border_width (3); - panning_up.add (panning_up_arrow); - panning_down.add (panning_down_arrow); - panning_up.set_name (X_("PanScrollerBase")); - panning_down.set_name (X_("PanScrollerBase")); - panning_up_arrow.set_name (X_("PanScrollerArrow")); - panning_down_arrow.set_name (X_("PanScrollerArrow")); + delete twod_panner; + twod_panner = 0; - pan_vbox.set_spacing (4); - pan_vbox.pack_start (panning_viewport, Gtk::PACK_SHRINK); - pan_vbox.pack_start (panning_link_box, Gtk::PACK_SHRINK); + delete _stereo_panner; + _stereo_panner = 0; - pack_start (pan_vbox, true, false); + if (!_panner) { + return; + } - panner = 0; + _panner->Changed.connect (connections, invalidator (*this), boost::bind (&PannerUI::panner_changed, this, this), gui_context()); + _panner->StateChanged.connect (connections, invalidator (*this), boost::bind (&PannerUI::update_pan_state, this), gui_context()); - set_width(Narrow); + /* new panner object, force complete reset of panner GUI + */ - _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)); + _current_nouts = 0; + _current_nins = 0; - pan_changed (0); + panner_changed (0); update_pan_sensitive (); - update_pan_linkage (); pan_automation_state_changed (); + } -bool -PannerUI::panning_link_button_press (GdkEventButton* ev) +void +PannerUI::build_astate_menu () { - cerr << "link press\n"; - return true; + 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"), sigc::bind ( + sigc::mem_fun (_panner.get(), &Panner::set_automation_state), + (AutoState) Off))); + pan_astate_menu->items().push_back (MenuElem (_("Play"), sigc::bind ( + sigc::mem_fun (_panner.get(), &Panner::set_automation_state), + (AutoState) Play))); + pan_astate_menu->items().push_back (MenuElem (_("Write"), sigc::bind ( + sigc::mem_fun (_panner.get(), &Panner::set_automation_state), + (AutoState) Write))); + pan_astate_menu->items().push_back (MenuElem (_("Touch"), sigc::bind ( + sigc::mem_fun (_panner.get(), &Panner::set_automation_state), + (AutoState) Touch))); + } -bool -PannerUI::panning_link_button_release (GdkEventButton* ev) +void +PannerUI::build_astyle_menu () { - cerr << "link release\n"; - if (!ignore_toggle) { - _io.panner().set_linked (!_io.panner().linked()); + 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(); } - return true; + + pan_astyle_menu->items().push_back (MenuElem (_("Trim"))); + pan_astyle_menu->items().push_back (MenuElem (_("Abs"))); } -void -PannerUI::panning_link_direction_clicked() +boost::shared_ptr +PannerUI::get_controllable() { - switch (_io.panner().link_direction()) { - case Panner::SameDirection: - _io.panner().set_link_direction (Panner::OppositeDirection); - break; - default: - _io.panner().set_link_direction (Panner::SameDirection); - break; - } + assert (!pan_bars.empty()); + return pan_bars[0]->get_controllable(); } void -PannerUI::update_pan_linkage () -{ - ENSURE_GUI_THREAD(mem_fun(*this, &PannerUI::update_pan_linkage)); - - bool x = _io.panner().linked(); - bool bx = panning_link_button.get_active(); - - if (x != bx) { - - ignore_toggle = true; - panning_link_button.set_active (x); - ignore_toggle = false; - } - - panning_link_direction_button.set_sensitive (x); - - switch (_io.panner().link_direction()) { - case Panner::SameDirection: - panning_link_direction_button.set_image (*(manage (new Image (get_xpm ("forwardblarrow.xpm"))))); - break; - default: - panning_link_direction_button.set_image (*(manage (new Image (get_xpm("revdblarrow.xpm"))))); - break; - } +PannerUI::on_size_allocate (Allocation& a) +{ + HBox::on_size_allocate (a); } void 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); - } - 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); - } - panning_link_button.set_label (_("L")); - break; - } - _width = w; } - PannerUI::~PannerUI () { - for (vector::iterator i = pan_adjustments.begin(); i != pan_adjustments.end(); ++i) { + for (vector::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) { delete (*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 twod_panner; + delete big_window; + delete pan_menu; + delete pan_astyle_menu; + delete pan_astate_menu; + delete _stereo_panner; } void -PannerUI::panner_changed () +PannerUI::panner_changed (void* src) { - ENSURE_GUI_THREAD (mem_fun(*this, &PannerUI::panner_changed)); setup_pan (); } @@ -271,140 +215,155 @@ void PannerUI::update_pan_state () { /* currently nothing to do */ - // ENSURE_GUI_THREAD (mem_fun(*this, &PannerUI::update_panner_state)); } void PannerUI::setup_pan () { - uint32_t nouts = _io.n_outputs (); - - if (nouts == 0 || nouts == 1) { - - while (!pan_adjustments.empty()) { - delete pan_bars.back(); - pan_bars.pop_back (); - delete pan_adjustments.back(); - pan_adjustments.pop_back (); - } - - } else if (nouts == 2) { - - vector::size_type asz; - uint32_t npans = _io.panner().size(); - - while (!pan_adjustments.empty()) { - delete pan_bars.back(); - pan_bars.pop_back (); - delete pan_adjustments.back(); - pan_adjustments.pop_back (); - } + if (!_panner) { + return; + } + uint32_t const nouts = _panner->out().n_audio(); + uint32_t const nins = _panner->in().n_audio(); - while ((asz = pan_adjustments.size()) < npans) { + if (int32_t (nouts) == _current_nouts && int32_t (nins) == _current_nins) { + return; + } - float x; - BarController* bc; + container_clear (pan_vbox); - /* initialize adjustment with current value of panner */ + delete twod_panner; + twod_panner = 0; + delete _stereo_panner; + _stereo_panner = 0; + + if (nouts == 0 || nouts == 1) { - _io.panner()[asz]->get_position (x); + delete _stereo_panner; + delete twod_panner; - pan_adjustments.push_back (new Adjustment (x, 0, 1.0, 0.05, 0.1)); - pan_adjustments.back()->signal_value_changed().connect (bind (mem_fun(*this, &PannerUI::pan_adjustment_changed), (uint32_t) asz)); + /* stick something into the panning viewport so that it redraws */ - _io.panner()[asz]->Changed.connect (bind (mem_fun(*this, &PannerUI::pan_value_changed), (uint32_t) asz)); + EventBox* eb = manage (new EventBox()); + pan_vbox.pack_start (*eb, false, false); - 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)); - - char buf[64]; -#ifdef __APPLE__ - snprintf (buf, sizeof (buf), _("panner for channel %lu"), asz + 1); -#else - snprintf (buf, sizeof (buf), _("panner for channel %u"), asz + 1); -#endif - 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; - } - - pan_bar_packer.pack_start (*pan_bars.back(), false, false); - } - - /* now that we actually have the pan bars, - set their sensitivity based on current - automation state. - */ + } else if (nouts == 2) { - update_pan_sensitive (); + if (nins == 2) { + + /* add integrated 2in/2out panner GUI */ + + boost::shared_ptr pannable = _panner->pannable(); + + _stereo_panner = new StereoPanner (_panner); + _stereo_panner->set_size_request (-1, pan_bar_height); + pan_vbox.pack_start (*_stereo_panner, false, false); + + boost::shared_ptr ac; + + ac = pannable->pan_azimuth_control; + _stereo_panner->StartPositionGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch), + boost::weak_ptr (ac))); + _stereo_panner->StopPositionGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch), + boost::weak_ptr(ac))); + + ac = pannable->pan_width_control; + _stereo_panner->StartWidthGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch), + boost::weak_ptr (ac))); + _stereo_panner->StopWidthGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch), + boost::weak_ptr(ac))); + + } else if (nins == 1) { + /* 1-in/2out */ + + MonoPanner* mp; + boost::shared_ptr pannable = _panner->pannable(); + boost::shared_ptr ac = pannable->pan_azimuth_control; + + mp = new MonoPanner (ac); + + mp->StartGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch), + boost::weak_ptr (ac))); + mp->StopGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch), + boost::weak_ptr(ac))); + + mp->signal_button_release_event().connect (sigc::mem_fun(*this, &PannerUI::pan_button_event)); + + mp->set_size_request (-1, pan_bar_height); + + update_pan_sensitive (); + pan_vbox.pack_start (*mp, false, false); + + } else { + warning << string_compose (_("No panner user interface is currently available for %1-in/2out tracks/busses"), + nins) << endmsg; + } - panning_viewport.remove (); - panning_viewport.add (pan_bar_packer); - panning_viewport.show_all (); } else { - int w = 0; - - switch (_width) { - case Wide: - w = 61; - break; - case Narrow: - w = 31; - break; + if (!twod_panner) { + twod_panner = new Panner2d (_panner, 61); + twod_panner->set_name ("MixerPanZone"); + twod_panner->show (); + twod_panner->signal_button_press_event().connect (sigc::mem_fun(*this, &PannerUI::pan_button_event), false); } - if (panner == 0) { - panner = new Panner2d (_io.panner(), w, 61); - panner->set_name ("MixerPanZone"); - panner->show (); - } - update_pan_sensitive (); - panner->reset (_io.n_inputs()); - panner->set_size_request (w, 61); + twod_panner->reset (nins); + if (big_window) { + big_window->reset (nins); + } + twod_panner->set_size_request (-1, 61); /* and finally, add it to the panner frame */ - panning_viewport.remove (); - panning_viewport.add (*panner); - panning_viewport.show_all (); + pan_vbox.pack_start (*twod_panner, false, false); } + + pan_vbox.show_all (); +} + +void +PannerUI::start_touch (boost::weak_ptr wac) +{ + boost::shared_ptr ac = wac.lock(); + if (!ac) { + return; + } + ac->start_touch (ac->session().transport_frame()); +} + +void +PannerUI::stop_touch (boost::weak_ptr wac) +{ + boost::shared_ptr ac = wac.lock(); + if (!ac) { + return; + } + ac->stop_touch (false, ac->session().transport_frame()); } bool -PannerUI::pan_button_event (GdkEventButton* ev, uint32_t which) +PannerUI::pan_button_event (GdkEventButton* ev) { switch (ev->button) { + case 1: + if (twod_panner && ev->type == GDK_2BUTTON_PRESS) { + if (!big_window) { + big_window = new Panner2dWindow (_panner, 400, _panner->in().n_audio()); + } + big_window->show (); + return true; + } + break; + case 3: if (pan_menu == 0) { pan_menu = manage (new Menu); pan_menu->set_name ("ArdourContextMenu"); } - build_pan_menu (which); + build_pan_menu (); pan_menu->popup (1, ev->time); return true; break; @@ -416,240 +375,63 @@ PannerUI::pan_button_event (GdkEventButton* ev, uint32_t which) } void -PannerUI::build_pan_menu (uint32_t which) +PannerUI::build_pan_menu () { using namespace Menu_Helpers; MenuList& items (pan_menu->items()); items.clear (); - items.push_back (CheckMenuElem (_("Mute"))); - - /* set state first, connect second */ - - (dynamic_cast (&items.back()))->set_active (_io.panner()[which]->muted()); - (dynamic_cast (&items.back()))->signal_toggled().connect - (bind (mem_fun(*this, &PannerUI::pan_mute), which)); - - items.push_back (CheckMenuElem (_("Bypass"), mem_fun(*this, &PannerUI::pan_bypass_toggle))); + items.push_back (CheckMenuElem (_("Bypass"), sigc::mem_fun(*this, &PannerUI::pan_bypass_toggle))); bypass_menu_item = static_cast (&items.back()); /* set state first, connect second */ - bypass_menu_item->set_active (_io.panner().bypassed()); - bypass_menu_item->signal_toggled().connect (mem_fun(*this, &PannerUI::pan_bypass_toggle)); + bypass_menu_item->set_active (_panner->bypassed()); + bypass_menu_item->signal_toggled().connect (sigc::mem_fun(*this, &PannerUI::pan_bypass_toggle)); - items.push_back (MenuElem (_("Reset"), mem_fun(*this, &PannerUI::pan_reset))); - items.push_back (SeparatorElem()); - items.push_back (MenuElem (_("Reset all"))); -} - -void -PannerUI::pan_mute (uint32_t which) -{ - StreamPanner* sp = _io.panner()[which]; - sp->set_muted (!sp->muted()); + items.push_back (MenuElem (_("Reset"), sigc::mem_fun (*this, &PannerUI::pan_reset))); } 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 () { + _panner->reset (); } void PannerUI::effective_pan_display () { - if (_io.panner().empty()) { - return; - } - - switch (_io.n_outputs()) { - case 0: - case 1: - /* relax */ - break; - - case 2: - update_pan_bars (true); - break; - - default: - //panner->move_puck (pan_value (v, right), 0.5); - break; - } -} - -void -PannerUI::pan_changed (void *src) -{ - if (src == this) { - return; - } - - switch (_io.panner().size()) { - case 0: - panning_link_direction_button.set_sensitive (false); - panning_link_button.set_sensitive (false); - return; - case 1: - panning_link_direction_button.set_sensitive (false); - panning_link_button.set_sensitive (false); - break; - default: - panning_link_direction_button.set_sensitive (true); - panning_link_button.set_sensitive (true); - } - - uint32_t nouts = _io.n_outputs(); - - switch (nouts) { - case 0: - case 1: - /* relax */ - break; - - case 2: - update_pan_bars (false); - break; - - default: - // panner->move_puck (pan_value (pans[0], pans[1]), 0.5); - break; - } -} - -void -PannerUI::pan_adjustment_changed (uint32_t which) -{ - if (!in_pan_update && which < _io.panner().size()) { - - float xpos; - float val = pan_adjustments[which]->get_value (); - _io.panner()[which]->get_position (xpos); - - /* add a kinda-sorta detent for the middle */ - - if (val != 0.5 && Panner::equivalent (val, 0.5)) { - /* this is going to be reentrant, so just - return after it. - */ - - in_pan_update = true; - pan_adjustments[which]->set_value (0.5); - in_pan_update = false; - return; - } - - if (!Panner::equivalent (val, xpos)) { - - _io.panner()[which]->set_position (val); - /* XXX - the panner objects have no access to the session, - so do this here. ick. - */ - _session.set_dirty(); - } - } -} - -void -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()) { - float xpos; - float val = pan_adjustments[which]->get_value (); - - _io.panner()[which]->get_position (xpos); - - if (!Panner::equivalent (val, xpos)) { - in_pan_update = true; - pan_adjustments[which]->set_value (xpos); - in_pan_update = false; - } - } -} - -void -PannerUI::update_pan_bars (bool only_if_aplay) -{ - uint32_t n; - vector::iterator i; - - in_pan_update = true; - - /* this runs during automation playback, and moves the bar controllers - and/or pucks around. - */ - - for (i = pan_adjustments.begin(), n = 0; i != pan_adjustments.end(); ++i, ++n) { - float xpos, val; - - if (only_if_aplay) { - AutomationList& alist (_io.panner()[n]->automation()); - - if (!alist.automation_playback()) { - continue; - } - } - - _io.panner()[n]->get_effective_position (xpos); - val = (*i)->get_value (); - - if (!Panner::equivalent (val, xpos)) { - (*i)->set_value (xpos); - } - } - - in_pan_update = false; -} - -void -PannerUI::pan_printer (char *buf, uint32_t len, Adjustment* adj) -{ - float val = adj->get_value(); - - 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'; + if (_stereo_panner) { + _stereo_panner->queue_draw (); + } else if (twod_panner) { + twod_panner->queue_draw (); + } else { + for (vector::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) { + (*i)->queue_draw (); + } } } void PannerUI::update_pan_sensitive () { - bool sensitive = !(_io.panner().automation_state() & Play); + bool const sensitive = !(_panner->pannable()->automation_state() & Play); - switch (_io.n_outputs()) { - case 0: - case 1: - break; - case 2: - for (vector::iterator i = pan_bars.begin(); i != pan_bars.end(); ++i) { - (*i)->set_sensitive (sensitive); - } - break; - default: - if (panner) { - panner->set_sensitive (sensitive); - } - break; - } +#ifdef PANNER_HACKS + pan_vbox.set_sensitive (sensitive); +#endif + if (big_window) { + big_window->set_sensitive (sensitive); + } } gint @@ -663,7 +445,10 @@ PannerUI::pan_automation_state_button_event (GdkEventButton *ev) switch (ev->button) { case 1: - pan_astate_menu.popup (1, ev->time); + if (pan_astate_menu == 0) { + build_astate_menu (); + } + pan_astate_menu->popup (1, ev->time); break; default: break; @@ -681,7 +466,10 @@ PannerUI::pan_automation_style_button_event (GdkEventButton *ev) switch (ev->button) { case 1: - pan_astyle_menu.popup (1, ev->time); + if (pan_astyle_menu == 0) { + build_astyle_menu (); + } + pan_astyle_menu->popup (1, ev->time); break; default: break; @@ -692,14 +480,14 @@ PannerUI::pan_automation_style_button_event (GdkEventButton *ev) void PannerUI::pan_automation_style_changed () { - ENSURE_GUI_THREAD(mem_fun(*this, &PannerUI::pan_automation_style_changed)); - + ENSURE_GUI_THREAD (*this, &PannerUI::pan_automation_style_changed) + switch (_width) { case Wide: - pan_automation_style_button.set_label (astyle_string(_io.panner().automation_style())); + pan_automation_style_button.set_label (astyle_string(_panner->automation_style())); break; case Narrow: - pan_automation_style_button.set_label (short_astyle_string(_io.panner().automation_style())); + pan_automation_style_button.set_label (short_astyle_string(_panner->automation_style())); break; } } @@ -707,44 +495,33 @@ PannerUI::pan_automation_style_changed () void PannerUI::pan_automation_state_changed () { - ENSURE_GUI_THREAD(mem_fun(*this, &PannerUI::pan_automation_state_changed)); - - bool x; + boost::shared_ptr pannable (_panner->pannable()); switch (_width) { case Wide: - pan_automation_state_button.set_label (astate_string(_io.panner().automation_state())); + pan_automation_state_button.set_label (astate_string(pannable->automation_state())); break; case Narrow: - pan_automation_state_button.set_label (short_astate_string(_io.panner().automation_state())); + pan_automation_state_button.set_label (short_astate_string(pannable->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 (_io.panner().empty()) { - return; - } - - x = (_io.panner().front()->automation().automation_state() != Off); - + bool x = (pannable->automation_state() != Off); + if (pan_automation_state_button.get_active() != x) { - ignore_toggle = true; + 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)); + pan_watching = ARDOUR_UI::RapidScreenUpdate.connect (sigc::mem_fun (*this, &PannerUI::effective_pan_display)); } } @@ -767,7 +544,7 @@ PannerUI::_astate_string (AutoState state, bool shrt) switch (state) { case Off: - sstr = (shrt ? "O" : _("O")); + sstr = (shrt ? "M" : _("M")); break; case Play: sstr = (shrt ? "P" : _("P")); @@ -806,3 +583,23 @@ PannerUI::_astyle_string (AutoStyle style, bool shrt) return (shrt ? _("Abs") : _("Abs")); } } + +void +PannerUI::show_width () +{ +} + +void +PannerUI::width_adjusted () +{ +} + +void +PannerUI::show_position () +{ +} + +void +PannerUI::position_adjusted () +{ +}