last_shuttle_request = last_peak_grab = 0; // get_microseconds();
- ARDOUR::Diskstream::DiskOverrun.connect (sigc::mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
- ARDOUR::Diskstream::DiskUnderrun.connect (sigc::mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
+ ARDOUR::Diskstream::DiskOverrun.connect (forever_connections, sigc::mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
+ ARDOUR::Diskstream::DiskUnderrun.connect (forever_connections, sigc::mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
/* handle dialog requests */
- ARDOUR::Session::Dialog.connect (sigc::mem_fun(*this, &ARDOUR_UI::session_dialog));
+ ARDOUR::Session::Dialog.connect (forever_connections, sigc::mem_fun(*this, &ARDOUR_UI::session_dialog));
/* handle pending state with a dialog */
- ARDOUR::Session::AskAboutPendingState.connect (sigc::mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
+ ARDOUR::Session::AskAboutPendingState.connect (forever_connections, sigc::mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
/* handle sr mismatch with a dialog */
- ARDOUR::Session::AskAboutSampleRateMismatch.connect (sigc::mem_fun(*this, &ARDOUR_UI::sr_mismatch_dialog));
+ ARDOUR::Session::AskAboutSampleRateMismatch.connect (forever_connections, sigc::mem_fun(*this, &ARDOUR_UI::sr_mismatch_dialog));
/* lets get this party started */
return -1;
}
- engine->Stopped.connect (sigc::mem_fun(*this, &ARDOUR_UI::engine_stopped));
- engine->Running.connect (sigc::mem_fun(*this, &ARDOUR_UI::engine_running));
- engine->Halted.connect (sigc::mem_fun(*this, &ARDOUR_UI::engine_halted));
- engine->SampleRateChanged.connect (sigc::mem_fun(*this, &ARDOUR_UI::update_sample_rate));
+ engine->Stopped.connect (forever_connections, sigc::mem_fun(*this, &ARDOUR_UI::engine_stopped));
+ engine->Running.connect (forever_connections, sigc::mem_fun(*this, &ARDOUR_UI::engine_running));
+ engine->Halted.connect (forever_connections, sigc::mem_fun(*this, &ARDOUR_UI::engine_halted));
+ engine->SampleRateChanged.connect (forever_connections, sigc::mem_fun(*this, &ARDOUR_UI::update_sample_rate));
post_engine ();
update_cpu_load ();
update_sample_rate (engine->frame_rate());
- Config->ParameterChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::parameter_changed));
+ Config->ParameterChanged.connect (forever_connections, sigc::mem_fun (*this, &ARDOUR_UI::parameter_changed));
boost::function<void (string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
Config->map_parameters (pc);
void platform_specific ();
void platform_setup ();
void fontconfig_dialog ();
+
+ PBD::ScopedConnectionList forever_connections;
};
#endif /* __ardour_gui_h__ */
Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::sync_blink));
Blink.connect (sigc::mem_fun(*this, &ARDOUR_UI::audition_blink));
- _session_connections.add_connection (_session->Xrun.connect (sigc::mem_fun(*this, &ARDOUR_UI::xrun_handler)));
- _session_connections.add_connection (_session->RecordStateChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::record_state_changed)));
- _session_connections.add_connection (_session->locations()->added.connect (sigc::mem_fun (*this, &ARDOUR_UI::handle_locations_change)));
- _session_connections.add_connection (_session->locations()->removed.connect (sigc::mem_fun (*this, &ARDOUR_UI::handle_locations_change)));
- _session_connections.add_connection (_session->TransportStateChange.connect (sigc::mem_fun(*this, &ARDOUR_UI::map_transport_state)));
- _session_connections.add_connection (_session->AuditionActive.connect (sigc::mem_fun(*this, &ARDOUR_UI::auditioning_changed)));
- _session_connections.add_connection (_session->SoloActive.connect (sigc::mem_fun(*this, &ARDOUR_UI::soloing_changed)));
- _session_connections.add_connection (_session->DirtyChanged.connect (sigc::mem_fun(*this, &ARDOUR_UI::update_autosave)));
-
+ _session->Xrun.connect (_session_connections, sigc::mem_fun(*this, &ARDOUR_UI::xrun_handler));
+ _session->RecordStateChanged.connect (_session_connections, sigc::mem_fun (*this, &ARDOUR_UI::record_state_changed));
+ _session->locations()->added.connect (_session_connections, sigc::mem_fun (*this, &ARDOUR_UI::handle_locations_change));
+ _session->locations()->removed.connect (_session_connections, sigc::mem_fun (*this, &ARDOUR_UI::handle_locations_change));
+ _session->TransportStateChange.connect (_session_connections, sigc::mem_fun(*this, &ARDOUR_UI::map_transport_state));
+ _session->AuditionActive.connect (_session_connections, sigc::mem_fun(*this, &ARDOUR_UI::auditioning_changed));
+ _session->SoloActive.connect (_session_connections, sigc::mem_fun(*this, &ARDOUR_UI::soloing_changed));
+ _session->DirtyChanged.connect (_session_connections, sigc::mem_fun(*this, &ARDOUR_UI::update_autosave));
/* Clocks are on by default after we are connected to a session, so show that here.
*/
void
ARDOUR_UI::setup_session_options ()
{
- _session->config.ParameterChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::parameter_changed));
+ _session->config.ParameterChanged.connect (_session_connections, sigc::mem_fun (*this, &ARDOUR_UI::parameter_changed));
boost::function<void (std::string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
_session->config.map_parameters (pc);
}
clock_base.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::SCROLL_MASK);
clock_base.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &AudioClock::field_button_release_event), Timecode_Hours));
- Session::TimecodeOffsetChanged.connect (sigc::mem_fun (*this, &AudioClock::timecode_offset_changed));
+ Session::TimecodeOffsetChanged.connect (_session_connections, sigc::mem_fun (*this, &AudioClock::timecode_offset_changed));
if (editable) {
setup_events ();
bounds_changed (Change (StartChanged|LengthChanged|PositionChanged|Region::SyncOffsetChanged));
gain_changed ();
- _region->StateChanged.connect (sigc::mem_fun(*this, &AudioRegionEditor::region_changed));
+ _region->StateChanged.connect (state_connection, sigc::mem_fun(*this, &AudioRegionEditor::region_changed));
spin_arrow_grab = false;
gain_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &AudioRegionEditor::gain_adjustment_changed));
audition_button.signal_toggled().connect (sigc::mem_fun(*this, &AudioRegionEditor::audition_button_toggled));
- _session->AuditionActive.connect (sigc::mem_fun(*this, &AudioRegionEditor::audition_state_changed));
+ _session->AuditionActive.connect (audition_connection, sigc::mem_fun(*this, &AudioRegionEditor::audition_state_changed));
}
void
#include <gtkmm/spinbutton.h>
#include <libgnomecanvas/libgnomecanvas.h>
-#include <sigc++/signal.h>
+
+#include "pbd/signals.h"
#include "audio_clock.h"
#include "ardour_dialog.h"
Gtk::VSeparator sep1;
Gtk::VSeparator sep2;
+ PBD::ScopedConnection state_connection;
+ PBD::ScopedConnection audition_connection;
+
void region_changed (ARDOUR::Change);
void bounds_changed (ARDOUR::Change);
void name_changed ();
ghost->set_colors();
ghosts.push_back (ghost);
- ghost->GoingAway.connect (boost::bind (&RegionView::remove_ghost, this, _1));
+ ghost->GoingAway.connect (*this, boost::bind (&RegionView::remove_ghost, this, _1));
return ghost;
}
use_rec_regions = tv.editor().show_waveforms_recording ();
- Config->ParameterChanged.connect (sigc::mem_fun (*this, &AudioStreamView::parameter_changed));
+ Config->ParameterChanged.connect (*this, sigc::mem_fun (*this, &AudioStreamView::parameter_changed));
}
AudioStreamView::~AudioStreamView ()
/* catch region going away */
- scoped_connect (r->GoingAway, boost::bind (&AudioStreamView::remove_region_view, this, boost::weak_ptr<Region> (r)));
+ r->GoingAway.connect (*this, boost::bind (&AudioStreamView::remove_region_view, this, boost::weak_ptr<Region> (r)));
RegionViewAdded (region_view);
{
ENSURE_GUI_THREAD (*this, &AudioStreamView::playlist_changed_weak, boost::weak_ptr<Diskstream> (ds));
+ playlist_connections.drop_connections ();
+
StreamView::playlist_changed(ds);
boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(ds->playlist());
if (apl) {
- playlist_connections.add_connection (apl->NewCrossfade.connect (boost::bind (&AudioStreamView::add_crossfade, this, _1)));
+ apl->NewCrossfade.connect (playlist_connections, boost::bind (&AudioStreamView::add_crossfade, this, _1));
}
}
region_color,
*lview, *rview);
cv->set_valid (true);
- crossfade->Invalidated.connect (sigc::mem_fun (*this, &AudioStreamView::remove_crossfade));
+ crossfade->Invalidated.connect (*this, sigc::mem_fun (*this, &AudioStreamView::remove_crossfade));
crossfade_views[cv->crossfade] = cv;
if (!_trackview.session()->config.get_xfades_visible() || !crossfades_visible) {
cv->hide ();
if (src) {
sources.push_back (src);
- rec_data_ready_connections.add_connection
- (src->PeakRangeReady.connect
- (boost::bind (&AudioStreamView::rec_peak_range_ready, this, _1, _2, boost::weak_ptr<Source>(src))));
+ (src->PeakRangeReady.connect (rec_data_ready_connections,
+ boost::bind (&AudioStreamView::rec_peak_range_ready,
+ this, _1, _2, boost::weak_ptr<Source>(src))));
}
}
}
if (_route->panner()) {
- _route->panner()->Changed.connect (sigc::bind (
- sigc::mem_fun(*this, &AudioTimeAxisView::ensure_pan_views),
- false));
+ _route->panner()->Changed.connect (*this, (boost::bind (&AudioTimeAxisView::ensure_pan_views, this, false)));
}
/* map current state of the route */
_screen_update_connection = ARDOUR_UI::RapidScreenUpdate.connect (
sigc::mem_fun (*this, &AutomationController::display_effective_value));
- ac->Changed.connect (sigc::mem_fun(*this, &AutomationController::value_changed));
+ ac->Changed.connect (_changed_connection, sigc::mem_fun(*this, &AutomationController::value_changed));
}
AutomationController::~AutomationController()
#include <boost/shared_ptr.hpp>
#include <gtkmm.h>
-#include <gtkmm2ext/barcontroller.h>
+
+#include "gtkmm2ext/barcontroller.h"
+#include "pbd/signals.h"
namespace ARDOUR {
class Session;
boost::shared_ptr<ARDOUR::AutomationControl> _controllable;
Gtk::Adjustment* _adjustment;
sigc::connection _screen_update_connection;
+ PBD::ScopedConnection _changed_connection;
};
line->signal_event().connect (sigc::mem_fun (*this, &AutomationLine::event_handler));
- alist->StateChanged.connect (sigc::mem_fun(*this, &AutomationLine::list_changed));
+ alist->StateChanged.connect (_state_connection, boost::bind (&AutomationLine::list_changed, this));
trackview.session()->register_with_memento_command_factory(alist->id(), this);
void reset_callback (const Evoral::ControlList&);
void list_changed ();
+ PBD::ScopedConnection _state_connection;
virtual bool event_handler (GdkEvent*);
virtual void add_model_point (ALPoints& tmp_points, double frame, double yfract);
set_height (trackview.current_height());
- _region->StateChanged.connect (sigc::mem_fun(*this, &AutomationRegionView::region_changed));
+ _region->StateChanged.connect (*this, boost::bind (&RegionView::region_changed, this, _1));
set_colors ();
display_region(region_view);
/* catch regionview going away */
- scoped_connect (region->GoingAway, boost::bind (&AutomationStreamView::remove_region_view, this, boost::weak_ptr<Region>(region)));
+ region->GoingAway.connect (*this, boost::bind (&AutomationStreamView::remove_region_view, this, boost::weak_ptr<Region>(region)));
RegionViewAdded (region_view);
assert(!_line);
assert(line->the_list() == _control->list());
- automation_connection = _control->alist()->automation_state_changed.connect
- (boost::bind (&AutomationTimeAxisView::automation_state_changed, this));
+ _control->alist()->automation_state_changed.connect (automation_connection, boost::bind (&AutomationTimeAxisView::automation_state_changed, this));
_line = line;
//_controller = AutomationController::create(_session, line->the_list(), _control);
(*i)[_list_model_columns.name] = u->name ();
(*i)[_list_model_columns.bundle] = u;
- u->Changed.connect (sigc::bind (sigc::mem_fun (*this, &BundleManager::bundle_changed), u));
+ u->Changed.connect (bundle_connections, boost::bind (&BundleManager::bundle_changed, this, _1, u));
}
void
ModelColumns _list_model_columns;
Gtk::Button edit_button;
Gtk::Button delete_button;
+ PBD::ScopedConnectionList bundle_connections;
};
class NameChannelDialog : public ArdourDialog
curve_select_clicked (In);
- xfade->StateChanged.connect (sigc::mem_fun(*this, &CrossfadeEditor::xfade_changed));
+ xfade->StateChanged.connect (state_connection, boost::bind (&CrossfadeEditor::xfade_changed, this, _1));
- _session_connections.add_connection (_session->AuditionActive.connect (sigc::mem_fun(*this, &CrossfadeEditor::audition_state_changed)));
+ _session->AuditionActive.connect (_session_connections, sigc::mem_fun(*this, &CrossfadeEditor::audition_state_changed));
show_all_children();
}
void set (const ARDOUR::AutomationList& alist, WhichFade);
- boost::signals2::scoped_connection peaks_ready_connection;
+ PBD::ScopedConnection peaks_ready_connection;
+ PBD::ScopedConnection state_connection;
void make_waves (boost::shared_ptr<ARDOUR::AudioRegion>, WhichFade);
void peaks_ready (boost::weak_ptr<ARDOUR::AudioRegion> r, WhichFade);
using namespace Gnome;
using namespace Canvas;
-boost::signals2::signal<void(CrossfadeView*)> CrossfadeView::GoingAway;
+PBD::Signal1<void,CrossfadeView*> CrossfadeView::GoingAway;
CrossfadeView::CrossfadeView (ArdourCanvas::Group *parent,
RouteTimeAxisView &tv,
crossfade_changed (Change (~0));
- crossfade->StateChanged.connect (sigc::mem_fun(*this, &CrossfadeView::crossfade_changed));
+ crossfade->StateChanged.connect (*this, sigc::mem_fun(*this, &CrossfadeView::crossfade_changed));
ColorsChanged.connect (sigc::mem_fun (*this, &CrossfadeView::color_handler));
}
#include <vector>
#include <libgnomecanvasmm.h>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include "ardour/crossfade.h"
#include "time_axis_view_item.h"
bool visible() const { return _visible; }
void set_valid (bool yn);
- static boost::signals2::signal<void(CrossfadeView*)> GoingAway;
+ static PBD::Signal1<void,CrossfadeView*> GoingAway;
AudioRegionView& upper_regionview () const;
_playlist_selector = new PlaylistSelector();
_playlist_selector->signal_delete_event().connect (sigc::bind (sigc::ptr_fun (just_hide_it), static_cast<Window *> (_playlist_selector)));
- scoped_connect (RegionView::RegionViewGoingAway, boost::bind (&Editor::catch_vanishing_regionview, this, _1));
+ RegionView::RegionViewGoingAway.connect (*this, boost::bind (&Editor::catch_vanishing_regionview, this, _1));
/* nudge stuff */
/* allow external control surfaces/protocols to do various things */
- ControlProtocol::ZoomToSession.connect (sigc::mem_fun (*this, &Editor::temporal_zoom_session));
- ControlProtocol::ZoomIn.connect (sigc::bind (sigc::mem_fun (*this, &Editor::temporal_zoom_step), false));
- ControlProtocol::ZoomOut.connect (sigc::bind (sigc::mem_fun (*this, &Editor::temporal_zoom_step), true));
- ControlProtocol::ScrollTimeline.connect (sigc::mem_fun (*this, &Editor::control_scroll));
- BasicUI::AccessAction.connect (sigc::mem_fun (*this, &Editor::access_action));
+ ControlProtocol::ZoomToSession.connect (*this, boost::bind (&Editor::temporal_zoom_session, this));
+ ControlProtocol::ZoomIn.connect (*this, boost::bind (&Editor::temporal_zoom_step, this, false));
+ ControlProtocol::ZoomOut.connect (*this, boost::bind (&Editor::temporal_zoom_step, this, true));
+ ControlProtocol::ScrollTimeline.connect (*this, boost::bind (&Editor::control_scroll, this, _1));
+ BasicUI::AccessAction.connect (*this, boost::bind (&Editor::access_action, this, _1, _2));
- Config->ParameterChanged.connect (sigc::mem_fun (*this, &Editor::parameter_changed));
+ Config->ParameterChanged.connect (*this, boost::bind (&Editor::parameter_changed, this, _1));
_last_normalization_value = 0;
update_title ();
- _session_connections.add_connection (_session->history().Changed.connect (boost::bind (&Editor::history_changed, this)));
+ _session->history().Changed.connect (_session_connections, boost::bind (&Editor::history_changed, this));
/* These signals can all be emitted by a non-GUI thread. Therefore the
handlers for them must not attempt to directly interact with the GUI,
but use Gtkmm2ext::UI::instance()->call_slot();
*/
- _session_connections.add_connection (_session->TransportStateChange.connect (boost::bind (&Editor::map_transport_state, this)));
- _session_connections.add_connection (_session->PositionChanged.connect (boost::bind (&Editor::map_position_change, this, _1)));
- _session_connections.add_connection (_session->RouteAdded.connect (boost::bind (&Editor::handle_new_route, this, _1)));
- _session_connections.add_connection (_session->DurationChanged.connect (boost::bind (&Editor::handle_new_duration, this)));
- _session_connections.add_connection (_session->DirtyChanged.connect (boost::bind (&Editor::update_title, this)));
- _session_connections.add_connection (_session->StateSaved.connect (boost::bind (&Editor::update_title, this)));
- _session_connections.add_connection (_session->AskAboutPlaylistDeletion.connect (boost::bind (&Editor::playlist_deletion_dialog, this, _1)));
- _session_connections.add_connection (_session->TimecodeOffsetChanged.connect (boost::bind (&Editor::update_just_timecode, this)));
- _session_connections.add_connection (_session->tempo_map().StateChanged.connect (boost::bind (&Editor::tempo_map_changed, this, _1)));
- _session_connections.add_connection (_session->Located.connect (boost::bind (&Editor::located, this)));
- _session_connections.add_connection (_session->config.ParameterChanged.connect (boost::bind (&Editor::parameter_changed, this, _1)));
+ _session->TransportStateChange.connect (_session_connections, boost::bind (&Editor::map_transport_state, this));
+ _session->PositionChanged.connect (_session_connections, boost::bind (&Editor::map_position_change, this, _1));
+ _session->RouteAdded.connect (_session_connections, boost::bind (&Editor::handle_new_route, this, _1));
+ _session->DurationChanged.connect (_session_connections, boost::bind (&Editor::handle_new_duration, this));
+ _session->DirtyChanged.connect (_session_connections, boost::bind (&Editor::update_title, this));
+ _session->StateSaved.connect (_session_connections, boost::bind (&Editor::update_title, this));
+ _session->AskAboutPlaylistDeletion.connect (_session_connections, boost::bind (&Editor::playlist_deletion_dialog, this, _1));
+ _session->TimecodeOffsetChanged.connect (_session_connections, boost::bind (&Editor::update_just_timecode, this));
+ _session->tempo_map().StateChanged.connect (_session_connections, boost::bind (&Editor::tempo_map_changed, this, _1));
+ _session->Located.connect (_session_connections, boost::bind (&Editor::located, this));
+ _session->config.ParameterChanged.connect (_session_connections, boost::bind (&Editor::parameter_changed, this, _1));
if (Profile->get_sae()) {
BBT_Time bbt;
/* static signal - no need to drop connection when session is deleted (XXX or we are?)*/
- _session->StateSaved.connect (sigc::mem_fun(*this, &Editor::session_state_saved));
+ _session->StateSaved.connect (*this, boost::bind (&Editor::session_state_saved, this, _1));
- _session_connections.add_connection (_session->locations()->added.connect (sigc::mem_fun(*this, &Editor::add_new_location)));
- _session_connections.add_connection (_session->locations()->removed.connect (sigc::mem_fun(*this, &Editor::location_gone)));
- _session_connections.add_connection (_session->locations()->changed.connect (sigc::mem_fun(*this, &Editor::refresh_location_display)));
- _session_connections.add_connection (_session->locations()->StateChanged.connect (sigc::mem_fun(*this, &Editor::refresh_location_display_s)));
- _session_connections.add_connection (_session->locations()->end_location()->changed.connect (sigc::mem_fun(*this, &Editor::end_location_changed)));
+ _session->locations()->added.connect (_session_connections, sigc::mem_fun(*this, &Editor::add_new_location));
+ _session->locations()->removed.connect (_session_connections, sigc::mem_fun(*this, &Editor::location_gone));
+ _session->locations()->changed.connect (_session_connections, sigc::mem_fun(*this, &Editor::refresh_location_display));
+ _session->locations()->StateChanged.connect (_session_connections, sigc::mem_fun(*this, &Editor::refresh_location_display_s));
+ _session->locations()->end_location()->changed.connect (_session_connections, sigc::mem_fun(*this, &Editor::end_location_changed));
handle_new_duration ();
delete selection;
}
-void
-Editor::store_state (State& state) const
-{
- *state.selection = *selection;
-}
-
-void
-Editor::restore_state (State *state)
-{
- if (*selection == *state->selection) {
- return;
- }
-
- *selection = *state->selection;
- time_selection_changed ();
- region_selection_changed ();
-
- /* XXX other selection change handlers? */
-}
-
void
Editor::begin_reversible_command (string name)
{
rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
rtv->view()->HeightChanged.connect (sigc::mem_fun (*this, &Editor::streamview_height_changed));
- scoped_connect (rtv->GoingAway, boost::bind (&Editor::remove_route, this, rtv));
+ rtv->GoingAway.connect (*this, boost::bind (&Editor::remove_route, this, rtv));
}
_routes->routes_added (new_views);
#include <gtkmm2ext/dndtreeview.h>
#include "pbd/stateful.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/import_status.h"
#include "ardour/tempo.h"
void set_length (double units);
void set_y_axis (double position);
- sigc::signal<void, nframes64_t> PositionChanged;
+ PBD::Signal1<void, nframes64_t> PositionChanged;
};
class Editor : public PublicEditor, public PBD::ScopedConnectionList, public ARDOUR::SessionHandlePtr
~State ();
};
- void store_state (State&) const;
- void restore_state (State *);
-
void instant_save ();
boost::shared_ptr<ARDOUR::AudioRegion> last_audition_region;
_primary (p),
_views (v)
{
- death_connection = RegionView::RegionViewGoingAway.connect (sigc::mem_fun (*this, &RegionDrag::region_going_away));
+ RegionView::RegionViewGoingAway.connect (death_connection, boost::bind (&RegionDrag::region_going_away, this, _1));
}
void
row[route_display_columns.tv] = iftav;
route_list_display.get_selection()->select (row);
- scoped_connect (iftav->GoingAway, boost::bind (&Editor::remove_route, this, (TimeAxisView*)iftav));
+ iftav->GoingAway.connect (*this, boost::bind (&Editor::remove_route, this, (TimeAxisView*)iftav));
iftav->gui_changed.connect(sigc::mem_fun(*this, &Editor::handle_gui_changes)) ;
}
row[route_display_columns.tv] = mta;
route_list_display.get_selection()->select (row);
- scoped_connect (mta->GoingAway, boost::bind (&Editor::remove_route, this, (TimeAxisView*)mta));
+ mta->GoingAway.connect (*this, boost::bind (&Editor::remove_route, this, (TimeAxisView*)mta));
}
lam->show ();
}
- location->start_changed.connect (sigc::mem_fun(*this, &Editor::location_changed));
- location->end_changed.connect (sigc::mem_fun(*this, &Editor::location_changed));
- location->changed.connect (sigc::mem_fun(*this, &Editor::location_changed));
- location->name_changed.connect (sigc::mem_fun(*this, &Editor::location_changed));
- location->FlagsChanged.connect (sigc::mem_fun(*this, &Editor::location_flags_changed));
+ location->start_changed.connect (*this, boost::bind (&Editor::location_changed, this, _1));
+ location->end_changed.connect (*this, boost::bind (&Editor::location_changed, this, _1));
+ location->changed.connect (*this, boost::bind (&Editor::location_changed, this, _1));
+ location->name_changed.connect (*this, boost::bind (&Editor::location_changed, this, _1));
+ location->FlagsChanged.connect (*this, boost::bind (&Editor::location_flags_changed, this, _1, _2));
pair<Location*,LocationMarkers*> newpair;
_session,
false);
current_mixer_strip->Hiding.connect (sigc::mem_fun(*this, &Editor::current_mixer_strip_hidden));
- scoped_connect (current_mixer_strip->GoingAway, boost::bind (&Editor::current_mixer_strip_removed, this));
+ current_mixer_strip->GoingAway.connect (*this, boost::bind (&Editor::current_mixer_strip_removed, this));
#ifdef GTKOSX
current_mixer_strip->WidthChanged.connect (sigc::mem_fun(*this, &Editor::ensure_all_elements_drawn));
#endif
//ARDOUR_UI::instance()->secondary_clock.mode_changed.connect (sigc::mem_fun(*this, &Editor::redisplay_regions));
ARDOUR_UI::instance()->secondary_clock.mode_changed.connect (sigc::mem_fun(*this, &EditorRegions::update_all_rows));
- ARDOUR::Region::RegionPropertyChanged.connect (sigc::mem_fun(*this, &EditorRegions::update_row));
+ ARDOUR::Region::RegionPropertyChanged.connect (region_property_connection, sigc::mem_fun(*this, &EditorRegions::update_row));
}
EditorComponent::set_session (s);
if (_session) {
- _session_connections.add_connection (_session->RegionsAdded.connect (boost::bind (&EditorRegions::handle_new_regions, this, _1)));
- _session_connections.add_connection (_session->RegionRemoved.connect (boost::bind (&EditorRegions::handle_region_removed, this, _1)));
- _session_connections.add_connection (_session->RegionHiddenChange.connect (boost::bind (&EditorRegions::region_hidden, this, _1)));
+ _session->RegionsAdded.connect (_session_connections, boost::bind (&EditorRegions::handle_new_regions, this, _1));
+ _session->RegionRemoved.connect (_session_connections, boost::bind (&EditorRegions::handle_region_removed, this, _1));
+ _session->RegionHiddenChange.connect (_session_connections, boost::bind (&EditorRegions::region_hidden, this, _1));
}
redisplay ();
Editing::RegionListSortType _sort_type;
bool _no_redisplay;
std::list<boost::shared_ptr<ARDOUR::Region> > tmp_region_list;
+ PBD::ScopedConnection region_property_connection;
};
#endif /* __gtk_ardour_editor_regions_h__ */
focus = true;
}
- group->FlagsChanged.connect (sigc::bind (sigc::mem_fun (*this, &EditorRouteGroups::flags_changed), group));
+ group->FlagsChanged.connect (flags_connection, boost::bind (&EditorRouteGroups::flags_changed, this, _1, group));
if (focus) {
TreeViewColumn* col = _display.get_column (0);
EditorComponent::set_session (s);
if (_session) {
- _session_connections.add_connection (_session->route_group_added.connect (boost::bind (&EditorRouteGroups::add, this, _1)));
- _session_connections.add_connection (_session->route_group_removed.connect (boost::bind (&EditorRouteGroups::groups_changed, this)));
+ _session->route_group_added.connect (_session_connections, boost::bind (&EditorRouteGroups::add, this, _1));
+ _session->route_group_removed.connect (_session_connections, boost::bind (&EditorRouteGroups::groups_changed, this));
}
groups_changed ();
Gtk::ScrolledWindow _scroller;
Gtk::VBox* _display_packer;
bool _in_row_change;
+ PBD::ScopedConnection flags_connection;
};
_model->signal_rows_reordered().connect (sigc::mem_fun (*this, &EditorRoutes::reordered));
_display.signal_button_press_event().connect (sigc::mem_fun (*this, &EditorRoutes::button_press), false);
- scoped_connect (Route::SyncOrderKeys, (sigc::mem_fun (*this, &EditorRoutes::sync_order_keys)));
+ Route::SyncOrderKeys.connect (*this, (sigc::mem_fun (*this, &EditorRoutes::sync_order_keys)));
}
void
initial_display ();
if (_session) {
- scoped_connect (_session->SoloChanged, (sigc::mem_fun (*this, &EditorRoutes::solo_changed_so_update_mute)));
+ _session->SoloChanged.connect (*this, (sigc::mem_fun (*this, &EditorRoutes::solo_changed_so_update_mute)));
}
}
boost::weak_ptr<Route> wr ((*x)->route());
- scoped_connect ((*x)->route()->gui_changed, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2));
- scoped_connect ((*x)->route()->NameChanged, boost::bind (&EditorRoutes::route_name_changed, this, wr));
- scoped_connect ((*x)->GoingAway, boost::bind (&EditorRoutes::route_removed, this, *x));
+ (*x)->route()->gui_changed.connect (*this, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2));
+ (*x)->route()->NameChanged.connect (*this, boost::bind (&EditorRoutes::route_name_changed, this, wr));
+ (*x)->GoingAway.connect (*this, boost::bind (&EditorRoutes::route_removed, this, *x));
if ((*x)->is_track()) {
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> ((*x)->route());
- scoped_connect (t->diskstream()->RecordEnableChanged, boost::bind (&EditorRoutes::update_rec_display, this));
+ t->diskstream()->RecordEnableChanged.connect (*this, boost::bind (&EditorRoutes::update_rec_display, this));
}
- scoped_connect ((*x)->route()->mute_changed, boost::bind (&EditorRoutes::update_mute_display, this));
- scoped_connect ((*x)->route()->solo_changed, boost::bind (&EditorRoutes::update_solo_display, this));
- scoped_connect ((*x)->route()->solo_isolated_changed, boost::bind (&EditorRoutes::update_solo_isolate_display, this));
+ (*x)->route()->mute_changed.connect (*this, boost::bind (&EditorRoutes::update_mute_display, this));
+ (*x)->route()->solo_changed.connect (*this, boost::bind (&EditorRoutes::update_solo_display, this));
+ (*x)->route()->solo_isolated_changed.connect (*this, boost::bind (&EditorRoutes::update_solo_isolate_display, this));
}
update_rec_display ();
#ifndef __ardour_gtk_editor_route_h__
#define __ardour_gtk_editor_route_h__
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "editor_component.h"
class EditorRoutes : public EditorComponent, public PBD::ScopedConnectionList
_zoom_dragging (false)
{
- Region::RegionPropertyChanged.connect (sigc::hide (sigc::mem_fun (*this, &EditorSummary::set_dirty)));
- _editor->playhead_cursor->PositionChanged.connect (sigc::mem_fun (*this, &EditorSummary::playhead_position_changed));
+ Region::RegionPropertyChanged.connect (region_property_connection, boost::bind (&CairoWidget::set_dirty, this));
+ _editor->playhead_cursor->PositionChanged.connect (position_connection, boost::bind (&EditorSummary::playhead_position_changed, this, _1));
}
/** Connect to a session.
set_dirty ();
if (_session) {
- _session_connections.add_connection (_session->RegionRemoved.connect (boost::bind (&EditorSummary::set_dirty, this)));
- _session_connections.add_connection (_session->StartTimeChanged.connect (boost::bind (&EditorSummary::set_dirty, this)));
- _session_connections.add_connection (_session->EndTimeChanged.connect (boost::bind (&EditorSummary::set_dirty, this)));
+ _session->RegionRemoved.connect (_session_connections, boost::bind (&EditorSummary::set_dirty, this));
+ _session->StartTimeChanged.connect (_session_connections, boost::bind (&EditorSummary::set_dirty, this));
+ _session->EndTimeChanged.connect (_session_connections, boost::bind (&EditorSummary::set_dirty, this));
}
}
bool _zoom_dragging;
bool _zoom_left;
+
+ PBD::ScopedConnectionList position_connection;
+ PBD::ScopedConnectionList region_property_connection;
};
#endif
timespan_selector->CriticalSelectionChanged.connect (sigc::mem_fun (*this, &ExportDialog::update_warnings));
channel_selector->CriticalSelectionChanged.connect (sigc::mem_fun (*this, &ExportDialog::update_warnings));
file_notebook->CriticalSelectionChanged.connect (sigc::mem_fun (*this, &ExportDialog::update_warnings));
- status->Aborting.connect (sigc::mem_fun (*this, &ExportDialog::notify_errors));
+ status->Aborting.connect (abort_connection, sigc::mem_fun (*this, &ExportDialog::notify_errors));
update_warnings ();
}
PublicEditor & editor;
StatusPtr status;
+ PBD::ScopedConnection abort_connection;
/*** GUI components ***/
tab_close_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*parent, &ExportFileNotebook::remove_file_page), this));
- profile_manager->FormatListChanged.connect (sigc::mem_fun (format_selector, &ExportFormatSelector::update_format_list));
+ profile_manager->FormatListChanged.connect (format_connection, boost::bind (&ExportFormatSelector::update_format_list, &format_selector));
format_selector.FormatEdited.connect (sigc::mem_fun (*this, &ExportFileNotebook::FilePage::save_format_to_manager));
format_selector.FormatRemoved.connect (sigc::mem_fun (*profile_manager, &ExportProfileManager::remove_format_profile));
Gtk::Label format_label;
Gtk::Alignment format_align;
ExportFormatSelector format_selector;
+ PBD::ScopedConnection format_connection;
Gtk::Label filename_label;
Gtk::Alignment filename_align;
close_button = add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_APPLY);
close_button->set_sensitive (false);
close_button->signal_clicked().connect (sigc::mem_fun (*this, &ExportFormatDialog::end_dialog));
- manager.CompleteChanged.connect (sigc::mem_fun (*close_button, &Gtk::Button::set_sensitive));
+ manager.CompleteChanged.connect (*this, sigc::mem_fun (close_button, &Gtk::Button::set_sensitive));
/* Load state before hooking up the rest of the signals */
row[compatibility_cols.label] = (*it)->name();
WeakCompatPtr ptr (*it);
- (*it)->SelectChanged.connect (sigc::bind (sigc::mem_fun (*this, &ExportFormatDialog::change_compatibility_selection), ptr));
+ (*it)->SelectChanged.connect (*this, boost::bind (&ExportFormatDialog::change_compatibility_selection, this, _1, ptr));
}
compatibility_view.append_column_editable ("", compatibility_cols.selected);
row[quality_cols.label] = (*it)->name();
WeakQualityPtr ptr (*it);
- (*it)->SelectChanged.connect (sigc::bind (sigc::mem_fun (*this, &ExportFormatDialog::change_quality_selection), ptr));
- (*it)->CompatibleChanged.connect (sigc::bind (sigc::mem_fun (*this, &ExportFormatDialog::change_quality_compatibility), ptr));
+ (*it)->SelectChanged.connect (*this, boost::bind (&ExportFormatDialog::change_quality_selection, this, _1, ptr));
+ (*it)->CompatibleChanged.connect (*this, boost::bind (&ExportFormatDialog::change_quality_compatibility, this, _1, ptr));
}
quality_view.append_column ("", quality_cols.label);
row[format_cols.label] = (*it)->name();
WeakFormatPtr ptr (*it);
- (*it)->SelectChanged.connect (sigc::bind (sigc::mem_fun (*this, &ExportFormatDialog::change_format_selection), ptr));
- (*it)->CompatibleChanged.connect (sigc::bind (sigc::mem_fun (*this, &ExportFormatDialog::change_format_compatibility), ptr));
+ (*it)->SelectChanged.connect (*this, boost::bind (&ExportFormatDialog::change_format_selection, this, _1, ptr));
+ (*it)->CompatibleChanged.connect (*this, boost::bind (&ExportFormatDialog::change_format_compatibility, this, _1, ptr));
/* Encoding options */
boost::shared_ptr<HasSampleFormat> hsf;
if (hsf = boost::dynamic_pointer_cast<HasSampleFormat> (*it)) {
- hsf->SampleFormatSelectChanged.connect (sigc::mem_fun (*this, &ExportFormatDialog::change_sample_format_selection));
- hsf->SampleFormatCompatibleChanged.connect (sigc::mem_fun (*this, &ExportFormatDialog::change_sample_format_compatibility));
+ hsf->SampleFormatSelectChanged.connect (*this, boost::bind (&ExportFormatDialog::change_sample_format_selection, this, _1, _2));
+ hsf->SampleFormatCompatibleChanged.connect (*this, boost::bind (&ExportFormatDialog::change_sample_format_compatibility, this, _1, _2));
- hsf->DitherTypeSelectChanged.connect (sigc::mem_fun (*this, &ExportFormatDialog::change_dither_type_selection));
- hsf->DitherTypeCompatibleChanged.connect (sigc::mem_fun (*this, &ExportFormatDialog::change_dither_type_compatibility));
+ hsf->DitherTypeSelectChanged.connect (*this, boost::bind (&ExportFormatDialog::change_dither_type_selection, this, _1, _2));
+ hsf->DitherTypeCompatibleChanged.connect (*this, boost::bind (&ExportFormatDialog::change_dither_type_compatibility, this, _1, _2));
}
}
row[sample_rate_cols.ptr] = *it;
row[sample_rate_cols.color] = "white";
row[sample_rate_cols.label] = (*it)->name();
-
+
WeakSampleRatePtr ptr (*it);
- (*it)->SelectChanged.connect (sigc::bind (sigc::mem_fun (*this, &ExportFormatDialog::change_sample_rate_selection), ptr));
- (*it)->CompatibleChanged.connect (sigc::bind (sigc::mem_fun (*this, &ExportFormatDialog::change_sample_rate_compatibility), ptr));
+ (*it)->SelectChanged.connect (*this, boost::bind (&ExportFormatDialog::change_sample_rate_selection, this, _1, ptr));
+ (*it)->CompatibleChanged.connect (*this, boost::bind (&ExportFormatDialog::change_sample_rate_compatibility, this, _1, ptr));
}
sample_rate_view.append_column ("", sample_rate_cols.label);
#include "ardour/export_formats.h"
#include "pbd/xml++.h"
+#include "pbd/signals.h"
#include "ardour_dialog.h"
#include "audio_clock.h"
#include <gtkmm.h>
-class ExportFormatDialog : public ArdourDialog {
+class ExportFormatDialog : public ArdourDialog, public PBD::ScopedConnectionList {
private:
typedef ARDOUR::ExportFormatManager::WeakCompatPtr WeakCompatPtr;
boost::shared_ptr<AutomationControl> gc = amp->gain_control();
- model_connections.add_connection (gc->alist()->automation_state_changed.connect (boost::bind (&GainMeter::gain_automation_state_changed, this)));
- model_connections.add_connection (gc->alist()->automation_style_changed.connect (boost::bind (&GainMeter::gain_automation_style_changed, this)));
+ gc->alist()->automation_state_changed.connect (model_connections, boost::bind (&GainMeter::gain_automation_state_changed, this));
+ gc->alist()->automation_style_changed.connect (model_connections, boost::bind (&GainMeter::gain_automation_style_changed, this));
gain_automation_state_changed ();
}
- model_connections.add_connection (amp->gain_control()->Changed.connect (boost::bind (&GainMeterBase::gain_changed, this)));
+ amp->gain_control()->Changed.connect (model_connections, boost::bind (&GainMeterBase::gain_changed, this));
gain_changed ();
show_gain ();
#include <gtkmm/drawingarea.h>
#include <gdkmm/colormap.h>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/types.h"
#include "ardour/session_handle.h"
main_contents.pack_start (hpacker, false, false);
}
- pi->ActiveChanged.connect (sigc::bind(sigc::mem_fun(*this, &GenericPluginUI::processor_active_changed),
- boost::weak_ptr<Processor>(pi)));
+ pi->ActiveChanged.connect (active_connection, boost::bind (&GenericPluginUI::processor_active_changed, this, boost::weak_ptr<Processor>(pi)));
bypass_button.set_active (!pi->active());
//control_ui->combo->set_value_in_list(true, false);
set_popdown_strings (*control_ui->combo, setup_scale_values(port_index, control_ui));
control_ui->combo->signal_changed().connect (sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::control_combo_changed), control_ui));
- mcontrol->Changed.connect (sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::parameter_changed), control_ui));
+ mcontrol->Changed.connect (control_connections, boost::bind (&GenericPluginUI::parameter_changed, this, control_ui));
control_ui->pack_start(control_ui->label, true, true);
control_ui->pack_start(*control_ui->combo, false, true);
//control_ui->combo->set_value_in_list(true, false);
set_popdown_strings (*control_ui->combo, setup_scale_values(port_index, control_ui));
control_ui->combo->signal_changed().connect (sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::control_combo_changed), control_ui));
- mcontrol->Changed.connect (sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::parameter_changed), control_ui));
+ mcontrol->Changed.connect (control_connections, boost::bind (&GenericPluginUI::parameter_changed, this, control_ui));
control_ui->pack_start(control_ui->label, true, true);
control_ui->pack_start(*control_ui->combo, false, true);
// control_ui->pack_start (control_ui->automate_button, false, false);
control_ui->button->signal_clicked().connect (sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::control_port_toggled), control_ui));
- mcontrol->Changed.connect (sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::toggle_parameter_changed), control_ui));
+ mcontrol->Changed.connect (control_connections, boost::bind (&GenericPluginUI::toggle_parameter_changed, this, control_ui));
if (plugin->get_parameter (port_index) > 0.5){
control_ui->button->set_active(true);
automation_state_changed (control_ui);
- mcontrol->Changed.connect (sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::parameter_changed), control_ui));
- mcontrol->alist()->automation_state_changed.connect
- (sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::automation_state_changed), control_ui));
+ mcontrol->Changed.connect (control_connections, boost::bind (&GenericPluginUI::parameter_changed, this, control_ui));
+ mcontrol->alist()->automation_state_changed.connect (control_connections, boost::bind (&GenericPluginUI::automation_state_changed, this, control_ui));
} else if (plugin->parameter_is_output (port_index)) {
output_controls.push_back (control_ui);
}
- mcontrol->Changed.connect (sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::parameter_changed), control_ui));
+ mcontrol->Changed.connect (control_connections, boost::bind (&GenericPluginUI::parameter_changed, this, control_ui));
return control_ui;
}
using namespace ArdourCanvas;
using namespace ARDOUR;
-boost::signals2::signal<void(GhostRegion*)> GhostRegion::GoingAway;
+PBD::Signal1<void,GhostRegion*> GhostRegion::GoingAway;
GhostRegion::GhostRegion (ArdourCanvas::Group* parent, TimeAxisView& tv, TimeAxisView& source_tv, double initial_pos)
: trackview (tv)
#include <vector>
#include <libgnomecanvasmm.h>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include "canvas.h"
namespace Gnome {
ArdourCanvas::Group* group;
ArdourCanvas::SimpleRect* base_rect;
- static boost::signals2::signal<void(GhostRegion*)> GoingAway;
+ static PBD::Signal1<void,GhostRegion*> GoingAway;
};
class AudioGhostRegion : public GhostRegion {
EditorComponent::set_session (s);
if (_session) {
- _session_connections.add_connection (_session->RouteGroupChanged.connect (boost::bind (&GroupTabs::set_dirty, this)));
+ _session->RouteGroupChanged.connect (_session_connections, boost::bind (&GroupTabs::set_dirty, this));
}
}
else
{
marker_time_axis_list.push_back(marker_track) ;
- scoped_connect (marker_track->GoingAway, boost::bind (&ImageFrameTimeAxis::remove_time_axis_view, this, marker_track, (void*)this));
+ marker_track->GoingAway.connect (*this, boost::bind (&ImageFrameTimeAxis::remove_time_axis_view, this, marker_track, (void*)this));
MarkerTimeAxisAdded(marker_track, src) ; /* EMIT_SIGNAL */
ret = true ;
imageframe_views.push_front(ifv) ;
- scoped_connect (ifv->GoingAway, boost::bind (&ImageFrameTimeAxisGroup::remove_imageframe_item, this, (void*)this));
+ ifv->GoingAway.connect (*this, boost::bind (&ImageFrameTimeAxisGroup::remove_imageframe_item, this, (void*)this));
ImageFrameAdded(ifv, src) ; /* EMIT_SIGNAL */
}
imageframe_groups.push_front(iftag) ;
- scoped_connect (iftag->GoingAway, boost::bind (&ImageFrameTimeAxisView::remove_imageframe_group, this, iftag, (void*)this)) ;
+ iftag->GoingAway.connect (*this, boost::bind (&ImageFrameTimeAxisView::remove_imageframe_group, this, iftag, (void*)this));
- ImageFrameGroupAdded(iftag, src) ; /* EMIT_SIGNAL */
+ ImageFrameGroupAdded(iftag, src) ; /* EMIT_SIGNAL */
}
return(iftag) ;
{
marker_view_list.push_back(item) ;
- scoped_connect (item->GoingAway, boost::bind (&ImageFrameView::remove_marker_view_item, this, (void*)this));
+ item->GoingAway.connect (*this, boost::bind (&ImageFrameView::remove_marker_view_item, this, (void*)this));
MarkerViewAdded(item, src) ; /* EMIT_SIGNAL */
}
signal_delete_event().connect (sigc::mem_fun (*this, &PortInsertWindow::wm_delete), false);
- going_away_connection = pi->GoingAway.connect (sigc::mem_fun (*this, &PortInsertWindow::plugin_going_away));
+ pi->GoingAway.connect (going_away_connection, boost::bind (&PortInsertWindow::plugin_going_away, this));
}
bool
{
set_session (s);
set_spacing (1);
- Config->ParameterChanged.connect (sigc::mem_fun (*this, &LevelMeter::parameter_changed));
+ Config->ParameterChanged.connect (_parameter_connection, boost::bind (&LevelMeter::parameter_changed, this, _1));
UI::instance()->theme_changed.connect (sigc::mem_fun(*this, &LevelMeter::on_theme_changed));
ColorsChanged.connect (sigc::mem_fun (*this, &LevelMeter::color_handler));
max_peak = minus_infinity();
_meter = meter;
if (_meter) {
- _configuration_connection = _meter->ConfigurationChanged.connect(boost::bind (&LevelMeter::configuration_changed, this, _1, _2));
+ _meter->ConfigurationChanged.connect (_configuration_connection, boost::bind (&LevelMeter::configuration_changed, this, _1, _2));
}
}
private:
ARDOUR::PeakMeter* _meter;
-
+
Width _width;
struct MeterInfo {
std::vector<MeterInfo> meters;
float max_peak;
- boost::signals2::scoped_connection _configuration_connection;
+ PBD::ScopedConnection _configuration_connection;
+ PBD::ScopedConnection _parameter_connection;
void hide_all_meters ();
gint meter_button_release (GdkEventButton*, uint32_t);
end_clock.set_sensitive (!location->locked());
length_clock.set_sensitive (!location->locked());
- connections.add_connection (location->start_changed.connect (boost::bind (&LocationEditRow::start_changed, this, _1)));
- connections.add_connection (location->end_changed.connect (boost::bind (&LocationEditRow::end_changed, this, _1)));
- connections.add_connection (location->name_changed.connect (boost::bind (&LocationEditRow::name_changed, this, _1)));
- connections.add_connection (location->changed.connect (boost::bind (&LocationEditRow::location_changed, this, _1)));
- connections.add_connection (location->FlagsChanged.connect (boost::bind (&LocationEditRow::flags_changed, this, _1, _2)));
+ location->start_changed.connect (connections, boost::bind (&LocationEditRow::start_changed, this, _1));
+ location->end_changed.connect (connections, boost::bind (&LocationEditRow::end_changed, this, _1));
+ location->name_changed.connect (connections, boost::bind (&LocationEditRow::name_changed, this, _1));
+ location->changed.connect (connections, boost::bind (&LocationEditRow::location_changed, this, _1));
+ location->FlagsChanged.connect (connections, boost::bind (&LocationEditRow::flags_changed, this, _1, _2));
}
void
SessionHandlePtr::set_session (s);
if (_session) {
- _session_connections.add_connection (_session->locations()->changed.connect (boost::bind (&LocationUI::refresh_location_list, this)));
- _session_connections.add_connection (_session->locations()->StateChanged.connect (boost::bind (&LocationUI::refresh_location_list, this)));
- _session_connections.add_connection (_session->locations()->added.connect (boost::bind (&LocationUI::location_added, this, _1)));
- _session_connections.add_connection (_session->locations()->removed.connect (boost::bind (&LocationUI::location_removed, this, _1)));
+ _session->locations()->changed.connect (_session_connections, boost::bind (&LocationUI::refresh_location_list, this));
+ _session->locations()->StateChanged.connect (_session_connections, boost::bind (&LocationUI::refresh_location_list, this));
+ _session->locations()->added.connect (_session_connections, boost::bind (&LocationUI::location_added, this, _1));
+ _session->locations()->removed.connect (_session_connections, boost::bind (&LocationUI::location_removed, this, _1));
}
refresh_location_list ();
#include <gtkmm/paned.h>
#include <gtkmm/scrolledwindow.h>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/location.h"
#include "ardour/session_handle.h"
}
}
- _lv2->ParameterChanged.connect(sigc::mem_fun(*this, &LV2PluginUI::parameter_changed));
+ _lv2->ParameterChanged.connect (parameter_connection, boost::bind (&LV2PluginUI::parameter_changed, this, _1, _2));
}
LV2PluginUI::~LV2PluginUI ()
virtual bool on_window_show(const Glib::ustring& title);
virtual void on_window_hide();
+
+ PBD::ScopedConnection parameter_connection;
};
#endif // HAVE_SLV2
ifv->add_marker_view_item(mv, src) ;
marker_view_list.push_front(mv) ;
- scoped_connect (mv->GoingAway, boost::bind (&MarkerTimeAxisView::remove_marker_view, this, (void*)this));
+ mv->GoingAway.connect (*this, boost::bind (&MarkerTimeAxisView::remove_marker_view, this, (void*)this));
MarkerViewAdded(mv,src) ; /* EMIT_SIGNAL */
{
_model = model;
content_connection.disconnect ();
- content_connection = _model->ContentsChanged.connect (boost::bind (&MidiRegionView::redisplay_model, this));
+ _model->ContentsChanged.connect (content_connection, boost::bind (&MidiRegionView::redisplay_model, this));
clear_events ();
}
}
- ghost->GoingAway.connect (boost::bind (&RegionView::remove_ghost, this, _1));
+ ghost->GoingAway.connect (*this, boost::bind (&RegionView::remove_ghost, this, _1));
return ghost;
}
display_region (region_view, wfd);
/* catch regionview going away */
- scoped_connect (region->GoingAway, boost::bind (&MidiStreamView::remove_region_view, this, region));
+ region->GoingAway.connect (*this, boost::bind (&MidiStreamView::remove_region_view, this, region));
RegionViewAdded (region_view);
sources.push_back(mds->write_source());
- rec_data_ready_connections.add_connection (mds->write_source()->ViewDataRangeReady.connect
- (boost::bind (&MidiStreamView::rec_data_range_ready, this,
- _1, _2, boost::weak_ptr<Source>(mds->write_source()))));
+ mds->write_source()->ViewDataRangeReady.connect
+ (rec_data_ready_connections, boost::bind (&MidiStreamView::rec_data_range_ready, this,
+ _1, _2, boost::weak_ptr<Source>(mds->write_source())));
// handle multi
set_state (*xml_node, Stateful::loading_state_version);
- _route->processors_changed.connect (sigc::mem_fun(*this, &MidiTimeAxisView::processors_changed));
+ _route->processors_changed.connect (*this, boost::bind (&MidiTimeAxisView::processors_changed, this, _1));
if (is_track()) {
_piano_roll_header = new PianoRollHeader(*midi_view());
_packed = false;
_embedded = false;
- _session->engine().Stopped.connect (sigc::mem_fun(*this, &MixerStrip::engine_stopped));
- _session->engine().Running.connect (sigc::mem_fun(*this, &MixerStrip::engine_running));
+ _session->engine().Stopped.connect (*this, boost::bind (&MixerStrip::engine_stopped, this));
+ _session->engine().Running.connect (*this, boost::bind (&MixerStrip::engine_running, this));
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);
boost::shared_ptr<AudioTrack> at = audio_track();
- connections.add_connection (at->FreezeChange.connect (sigc::mem_fun(*this, &MixerStrip::map_frozen)));
+ at->FreezeChange.connect (route_connections, boost::bind (&MixerStrip::map_frozen, this));
button_table.attach (*rec_enable_button, 0, 2, 2, 3);
rec_enable_button->set_sensitive (_session->writable());
_("Click to Add/Edit Comments"):
_route->comment());
- connections.add_connection (_route->meter_change.connect (sigc::mem_fun(*this, &MixerStrip::meter_changed)));
- connections.add_connection (_route->input()->changed.connect (sigc::mem_fun(*this, &MixerStrip::input_changed)));
- connections.add_connection (_route->output()->changed.connect (sigc::mem_fun(*this, &MixerStrip::output_changed)));
- connections.add_connection (_route->route_group_changed.connect (sigc::mem_fun(*this, &MixerStrip::route_group_changed)));
+ _route->meter_change.connect (route_connections, boost::bind (&MixerStrip::meter_changed, this, _1));
+ _route->input()->changed.connect (route_connections, boost::bind (&MixerStrip::input_changed, this, _1, _2));
+ _route->output()->changed.connect (route_connections, boost::bind (&MixerStrip::output_changed, this, _1, _2));
+ _route->route_group_changed.connect (route_connections, boost::bind (&MixerStrip::route_group_changed, this));
if (_route->panner()) {
- connections.add_connection (_route->panner()->Changed.connect (sigc::mem_fun(*this, &MixerStrip::connect_to_pan)));
+ _route->panner()->Changed.connect (route_connections, boost::bind (&MixerStrip::connect_to_pan, this));
}
if (is_audio_track()) {
- connections.add_connection (audio_track()->DiskstreamChanged.connect (sigc::mem_fun(*this, &MixerStrip::diskstream_changed)));
+ audio_track()->DiskstreamChanged.connect (route_connections, boost::bind (&MixerStrip::diskstream_changed, this));
}
- connections.add_connection (_route->NameChanged.connect (sigc::mem_fun(*this, &RouteUI::name_changed)));
- connections.add_connection (_route->comment_changed.connect (sigc::mem_fun(*this, &MixerStrip::comment_changed)));
- connections.add_connection (_route->gui_changed.connect (sigc::mem_fun(*this, &MixerStrip::route_gui_changed)));
+ _route->NameChanged.connect (route_connections, boost::bind (&RouteUI::name_changed, this));
+ _route->comment_changed.connect (route_connections, boost::bind (&MixerStrip::comment_changed, this, _1));
+ _route->gui_changed.connect (route_connections, boost::bind (&MixerStrip::route_gui_changed, this, _1, _2));
set_stuff_from_route ();
_route->panner()->data().control(Evoral::Parameter(PanAutomation)));
if (pan_control) {
- panstate_connection = pan_control->alist()->automation_state_changed.connect (sigc::mem_fun(panners, &PannerUI::pan_automation_state_changed));
- panstyle_connection = pan_control->alist()->automation_style_changed.connect (sigc::mem_fun(panners, &PannerUI::pan_automation_style_changed));
+ pan_control->alist()->automation_state_changed.connect (panstate_connection, boost::bind (&PannerUI::pan_automation_state_changed, &panners));
+ pan_control->alist()->automation_style_changed.connect (panstyle_connection, boost::bind (&PannerUI::pan_automation_style_changed, &panners));
}
panners.pan_changed (this);
_current_delivery = send;
send->set_metering (true);
- send_gone_connection = _current_delivery->GoingAway.connect (sigc::mem_fun (*this, &MixerStrip::revert_to_default_display));
+ _current_delivery->GoingAway.connect (send_gone_connection, boost::bind (&MixerStrip::revert_to_default_display, this));
gain_meter().set_controls (_route, send->meter(), send->amp());
gain_meter().setup_meters ();
strip_redisplay_does_not_sync_order_keys = false;
ignore_sync = false;
- Route::SyncOrderKeys.connect (sigc::mem_fun (*this, &Mixer_UI::sync_order_keys));
+ Route::SyncOrderKeys.connect (*this, boost::bind (&Mixer_UI::sync_order_keys, this, _1));
scroller_base.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
scroller_base.set_name ("MixerWindow");
route->set_order_key (N_("signal"), track_model->children().size()-1);
}
- route->NameChanged.connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::strip_name_changed), strip));
+ route->NameChanged.connect (*this, boost::bind (&Mixer_UI::strip_name_changed, this, strip));
- scoped_connect (strip->GoingAway, boost::bind (&Mixer_UI::remove_strip, this, strip));
+ strip->GoingAway.connect (*this, boost::bind (&Mixer_UI::remove_strip, this, strip));
strip->WidthChanged.connect (sigc::mem_fun(*this, &Mixer_UI::strip_width_changed));
strip->signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::strip_button_release_event), strip));
}
initial_track_display ();
- _session_connections.add_connection (_session->RouteAdded.connect (boost::bind (&Mixer_UI::add_strip, this, _1)));
- _session_connections.add_connection (_session->route_group_added.connect (boost::bind (&Mixer_UI::add_route_group, this, _1)));
- _session_connections.add_connection (_session->route_group_removed.connect (boost::bind (&Mixer_UI::route_groups_changed, this)));
- _session_connections.add_connection (_session->config.ParameterChanged.connect (boost::bind (&Mixer_UI::parameter_changed, this, _1)));
+ _session->RouteAdded.connect (_session_connections, boost::bind (&Mixer_UI::add_strip, this, _1));
+ _session->route_group_added.connect (_session_connections, boost::bind (&Mixer_UI::add_route_group, this, _1));
+ _session->route_group_removed.connect (_session_connections, boost::bind (&Mixer_UI::route_groups_changed, this));
+ _session->config.ParameterChanged.connect (_session_connections, boost::bind (&Mixer_UI::parameter_changed, this, _1));
route_groups_changed ();
focus = true;
}
- group->FlagsChanged.connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::group_flags_changed), group));
+ group->FlagsChanged.connect (*this, boost::bind (&Mixer_UI::group_flags_changed, this, _1, group));
if (focus) {
TreeViewColumn* col = group_display.get_column (0);
#include <gtkmm/treeview.h>
#include "pbd/stateful.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/ardour.h"
#include "ardour/session_handle.h"
show_all_children();
/* Watch out for changes to parameters */
- _config->ParameterChanged.connect (sigc::mem_fun (*this, &OptionEditor::parameter_changed));
+ _config->ParameterChanged.connect (config_connection, boost::bind (&OptionEditor::parameter_changed, this, _1));
}
OptionEditor::~OptionEditor ()
private:
void parameter_changed (std::string const &);
+ PBD::ScopedConnection config_connection;
Gtk::Notebook _notebook;
std::map<std::string, OptionEditorPage*> _pages;
allow_y = false;
allow_target = false;
- panner->StateChanged.connect (sigc::mem_fun(*this, &Panner2d::handle_state_change));
- panner->Changed.connect (sigc::mem_fun(*this, &Panner2d::handle_position_change));
+ panner->StateChanged.connect (state_connection, boost::bind (&Panner2d::handle_state_change, this));
+ panner->Changed.connect (change_connection, boost::bind (&Panner2d::handle_position_change, this));
drag_target = 0;
set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::POINTER_MOTION_MASK);
void toggle_bypass ();
void handle_state_change ();
void handle_position_change ();
+
+ PBD::ScopedConnection state_connection;
+ PBD::ScopedConnection change_connection;
};
class Panner2dWindow : public Gtk::Window
return;
}
- connections.add_connection (_panner->Changed.connect (sigc::mem_fun(*this, &PannerUI::panner_changed)));
- connections.add_connection (_panner->LinkStateChanged.connect (sigc::mem_fun(*this, &PannerUI::update_pan_linkage)));
- connections.add_connection (_panner->StateChanged.connect (sigc::mem_fun(*this, &PannerUI::update_pan_state)));
+ _panner->Changed.connect (connections, boost::bind (&PannerUI::panner_changed, this));
+ _panner->LinkStateChanged.connect (connections, boost::bind (&PannerUI::update_pan_linkage, this));
+ _panner->StateChanged.connect (connections, boost::bind (&PannerUI::update_pan_state, this));
setup_pan ();
pan_adjustments.back()->set_value(rx);
pan_adjustments.back()->signal_value_changed().connect (sigc::bind (sigc::mem_fun(*this, &PannerUI::pan_adjustment_changed), (uint32_t) asz));
- _panner->pan_control( asz )->Changed.connect (sigc::bind (sigc::mem_fun(*this, &PannerUI::pan_value_changed), (uint32_t) asz));
-
+ _panner->pan_control( asz )->Changed.connect (connections, boost::bind (&PannerUI::pan_value_changed, this, (uint32_t) asz));
bc->set_name ("PanSlider");
bc->set_shadow_type (Gtk::SHADOW_NONE);
// Connect the realtime signal collection callback
- _plugin_insert->AnalysisDataGathered.connect( sigc::mem_fun(*this, &PluginEqGui::signal_collect_callback ));
+ _plugin_insert->AnalysisDataGathered.connect (analysis_connection, boost::bind (&PluginEqGui::signal_collect_callback, this, _1, _2));
}
PluginEqGui::~PluginEqGui()
sigc::connection _update_connection;
sigc::connection _window_unmap_connection;
sigc::connection _window_map_connection;
+
+ PBD::ScopedConnection analysis_connection;
};
#endif
manager = mgr;
in_row_change = false;
- manager->PluginListChanged.connect (sigc::mem_fun (*this, &PluginSelector::build_plugin_menu));
+ manager->PluginListChanged.connect (plugin_list_changed_connection, boost::bind (&PluginSelector::build_plugin_menu, this));
build_plugin_menu ();
plugin_model = Gtk::ListStore::create (plugin_columns);
Gtk::Menu* create_by_creator_menu (ARDOUR::PluginInfoList&);
Gtk::Menu* create_by_category_menu (ARDOUR::PluginInfoList&);
void build_plugin_menu ();
+ PBD::ScopedConnection plugin_list_changed_connection;
};
#endif // __ardour_plugin_selector_h__
add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
signal_delete_event().connect (sigc::bind (sigc::ptr_fun (just_hide_it), reinterpret_cast<Window*> (this)), false);
- death_connection = insert->GoingAway.connect (sigc::mem_fun(*this, &PluginUIWindow::plugin_going_away));
+ insert->GoingAway.connect (death_connection, boost::bind (&PluginUIWindow::plugin_going_away, this));
gint h = _pluginui->get_preferred_height ();
gint w = _pluginui->get_preferred_width ();
save_button.set_name ("PluginSaveButton");
save_button.signal_clicked().connect(sigc::mem_fun(*this, &PlugUIBase::save_plugin_setting));
- insert->ActiveChanged.connect (sigc::bind(
- sigc::mem_fun(*this, &PlugUIBase::processor_active_changed),
- boost::weak_ptr<Processor>(insert)));
+ insert->ActiveChanged.connect (active_connection, boost::bind (&PlugUIBase::processor_active_changed, this, boost::weak_ptr<Processor>(insert)));
bypass_button.set_active (!pi->active());
plugin_analysis_expander.property_expanded().signal_changed().connect( sigc::mem_fun(*this, &PlugUIBase::toggle_plugin_analysis));
plugin_analysis_expander.set_expanded(false);
- death_connection = insert->GoingAway.connect (sigc::mem_fun (*this, &PlugUIBase::plugin_going_away));
+ insert->GoingAway.connect (death_connection, boost::bind (&PlugUIBase::plugin_going_away, this));
}
PlugUIBase::~PlugUIBase()
void toggle_plugin_analysis ();
void processor_active_changed (boost::weak_ptr<ARDOUR::Processor> p);
void plugin_going_away ();
- boost::signals2::scoped_connection death_connection;
+
+ PBD::ScopedConnection death_connection;
+ PBD::ScopedConnection active_connection;
+ PBD::ScopedConnectionList control_connections;
};
class GenericPluginUI : public PlugUIBase, public Gtk::VBox
}
BundleRecord* br = new BundleRecord (b, io, colour, has_colour);
- br->changed_connection = b->Changed.connect (boost::bind (&PortGroup::bundle_changed, this, _1));
+ b->Changed.connect (br->changed_connection, boost::bind (&PortGroup::bundle_changed, this, _1));
_bundles.push_back (br);
Changed ();
{
_groups.push_back (g);
- g->Changed.connect (sigc::mem_fun (*this, &PortGroupList::emit_changed));
-
- _bundle_changed_connections.add_connection (g->BundleChanged.connect (sigc::mem_fun (*this, &PortGroupList::emit_bundle_changed)));
+ g->Changed.connect (_changed_connections, boost::bind (&PortGroupList::emit_changed, this));
+ g->BundleChanged.connect (_bundle_changed_connections, boost::bind (&PortGroupList::emit_bundle_changed, this, _1));
emit_changed ();
}
#include <string>
#include <set>
#include <boost/shared_ptr.hpp>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include <gtkmm/widget.h>
#include <gtkmm/checkbutton.h>
bool has_port (std::string const &) const;
/** The bundle list has changed in some way; a bundle has been added or removed, or the list cleared etc. */
- sigc::signal<void> Changed;
+ PBD::Signal0<void> Changed;
/** An individual bundle on our list has changed in some way */
- boost::signals2::signal<void(ARDOUR::Bundle::Change)> BundleChanged;
+ PBD::Signal1<void,ARDOUR::Bundle::Change> BundleChanged;
struct BundleRecord {
boost::shared_ptr<ARDOUR::Bundle> bundle;
bool empty () const;
/** The group list has changed in some way; a group has been added or removed, or the list cleared etc. */
- boost::signals2::signal<void()> Changed;
+ PBD::Signal0<void> Changed;
/** A bundle in one of our groups has changed */
- boost::signals2::signal<void(ARDOUR::Bundle::Change)> BundleChanged;
+ PBD::Signal1<void,ARDOUR::Bundle::Change> BundleChanged;
private:
bool port_has_prefix (std::string const &, std::string const &) const;
mutable PortGroup::BundleList _bundles;
List _groups;
PBD::ScopedConnectionList _bundle_changed_connections;
+ PBD::ScopedConnectionList _changed_connections;
bool _signals_suspended;
bool _pending_change;
ARDOUR::Bundle::Change _pending_bundle_change;
for (int i = 0; i < 2; ++i) {
/* watch for the content of _ports[] changing */
- _ports[i].Changed.connect (sigc::mem_fun (*this, &PortMatrix::setup));
+ _ports[i].Changed.connect (_changed_connections, boost::bind (&PortMatrix::setup, this));
/* and for bundles in _ports[] changing */
- _ports[i].BundleChanged.connect (sigc::hide (sigc::mem_fun (*this, &PortMatrix::setup)));
+ _ports[i].BundleChanged.connect (_bundle_changed_connections, boost::bind (&PortMatrix::setup, this));
}
/* scrolling stuff */
/* Part 2: notice when things have changed that require our subclass to clear and refill _ports[] */
/* watch for routes being added or removed */
- _session_connections.add_connection (_session->RouteAdded.connect (boost::bind (&PortMatrix::routes_changed, this)));
+ _session->RouteAdded.connect (_session_connections, boost::bind (&PortMatrix::routes_changed, this));
/* and also bundles */
- _session_connections.add_connection (_session->BundleAdded.connect (boost::bind (&PortMatrix::setup_global_ports, this)));
+ _session->BundleAdded.connect (_session_connections, boost::bind (&PortMatrix::setup_global_ports, this));
/* and also ports */
- _session_connections.add_connection (_session->engine().PortRegisteredOrUnregistered.connect (boost::bind (&PortMatrix::setup_global_ports, this)));
+ _session->engine().PortRegisteredOrUnregistered.connect (_session_connections, boost::bind (&PortMatrix::setup_global_ports, this));
reconnect_to_routes ();
boost::shared_ptr<RouteList> routes = _session->get_routes ();
for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
- _route_connections.add_connection ((*i)->processors_changed.connect (sigc::mem_fun (*this, &PortMatrix::route_processors_changed)));
+ (*i)->processors_changed.connect (_route_connections, boost::bind (&PortMatrix::route_processors_changed, this, _1));
}
}
/// port type that we are working with
ARDOUR::DataType _type;
PBD::ScopedConnectionList _route_connections;
+ PBD::ScopedConnectionList _changed_connections;
+ PBD::ScopedConnectionList _bundle_changed_connections;
PortMatrixBody* _body;
Gtk::HScrollbar _hscroll;
PortGroup::BundleList r = _matrix->visible_rows()->bundles ();
for (PortGroup::BundleList::iterator i = r.begin(); i != r.end(); ++i) {
- _bundle_connections.add_connection ((*i)->bundle->Changed.connect (boost::bind (&PortMatrixBody::rebuild_and_draw_row_labels, this)));
+ (*i)->bundle->Changed.connect (_bundle_connections, boost::bind (&PortMatrixBody::rebuild_and_draw_row_labels, this));
}
}
if (_matrix->visible_columns()) {
PortGroup::BundleList c = _matrix->visible_columns()->bundles ();
for (PortGroup::BundleList::iterator i = c.begin(); i != c.end(); ++i) {
- _bundle_connections.add_connection ((*i)->bundle->Changed.connect (boost::bind (&PortMatrixBody::rebuild_and_draw_column_labels, this)));
+ (*i)->bundle->Changed.connect (_bundle_connections, boost::bind (&PortMatrixBody::rebuild_and_draw_column_labels, this));
}
}
_active.set_active (_processor->active ());
_active.signal_toggled().connect (sigc::mem_fun (*this, &ProcessorEntry::active_toggled));
- _processor->ActiveChanged.connect (sigc::mem_fun (*this, &ProcessorEntry::processor_active_changed));
- _processor->NameChanged.connect (sigc::mem_fun (*this, &ProcessorEntry::processor_name_changed));
+ _processor->ActiveChanged.connect (active_connection, boost::bind (&ProcessorEntry::processor_active_changed, this));
+ _processor->NameChanged.connect (name_connection, boost::bind (&ProcessorEntry::processor_name_changed, this));
}
EventBox&
_vbox.pack_start (_fader);
_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &SendProcessorEntry::gain_adjusted));
- _send->amp()->gain_control()->Changed.connect (sigc::mem_fun (*this, &SendProcessorEntry::show_gain));
+ _send->amp()->gain_control()->Changed.connect (send_gain_connection, boost::bind (&SendProcessorEntry::show_gain, this));
show_gain ();
}
no_processor_redisplay = false;
_route = r;
- connections.add_connection (_route->processors_changed.connect (sigc::mem_fun (*this, &ProcessorBox::route_processors_changed)));
- connections.add_connection (_route->GoingAway.connect (sigc::mem_fun (*this, &ProcessorBox::route_going_away)));
- connections.add_connection (_route->NameChanged.connect (sigc::mem_fun(*this, &ProcessorBox::route_name_changed)));
+ _route->processors_changed.connect (connections, boost::bind (&ProcessorBox::route_processors_changed, this, _1));
+ _route->GoingAway.connect (connections, boost::bind (&ProcessorBox::route_going_away, this));
+ _route->NameChanged.connect (connections, boost::bind (&ProcessorBox::route_name_changed, this));
redisplay_processors ();
}
#include <gtkmm2ext/pixfader.h>
#include "pbd/stateful.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/types.h"
#include "ardour/ardour.h"
Gtk::CheckButton _active;
boost::shared_ptr<ARDOUR::Processor> _processor;
Width _width;
+ PBD::ScopedConnection active_connection;
+ PBD::ScopedConnection name_connection;
};
class SendProcessorEntry : public ProcessorEntry
Gtk::Adjustment _adjustment;
Gtkmm2ext::HSliderController _fader;
bool _ignore_gain_change;
-
+ PBD::ScopedConnection send_gain_connection;
+
static Glib::RefPtr<Gdk::Pixbuf> _slider;
};
MIDI::Manager::PortList const & ports = MIDI::Manager::instance()->get_midi_ports ();
_store->clear ();
+ port_connections.drop_connections ();
for (MIDI::Manager::PortList::const_iterator i = ports.begin(); i != ports.end(); ++i) {
if ((*i)->input()) {
r[_model.online] = !(*i)->input()->offline();
- (*i)->input()->OfflineStatusChanged.connect (sigc::bind (sigc::mem_fun (*this, &MIDIPorts::port_offline_changed), (*i)));
+ (*i)->input()->OfflineStatusChanged.connect (port_connections, boost::bind (&MIDIPorts::port_offline_changed, this, (*i)));
r[_model.trace_input] = (*i)->input()->tracing();
}
ComboBoxText _mmc_combo;
ComboBoxText _mpc_combo;
list<ComboOption<string>* > _port_combos;
+ PBD::ScopedConnectionList port_connections;
};
*/
RegionSelection::RegionSelection ()
{
- death_connection = RegionView::RegionViewGoingAway.connect (boost::bind (&RegionSelection::remove_it, this, _1));
+ RegionView::RegionViewGoingAway.connect (death_connection, boost::bind (&RegionSelection::remove_it, this, _1));
_current_start = 0;
_current_end = 0;
RegionSelection::RegionSelection (const RegionSelection& other)
: std::list<RegionView*>()
{
- death_connection = RegionView::RegionViewGoingAway.connect (boost::bind (&RegionSelection::remove_it, this, _1));
+ RegionView::RegionViewGoingAway.connect (death_connection, boost::bind (&RegionSelection::remove_it, this, _1));
_current_start = other._current_start;
_current_end = other._current_end;
static const int32_t sync_mark_width = 9;
-boost::signals2::signal<void(RegionView*)> RegionView::RegionViewGoingAway;
+PBD::Signal1<void,RegionView*> RegionView::RegionViewGoingAway;
RegionView::RegionView (ArdourCanvas::Group* parent,
TimeAxisView& tv,
set_height (trackview.current_height());
- _region->StateChanged.connect (sigc::mem_fun(*this, &RegionView::region_changed));
-
+ _region->StateChanged.connect (*this, boost::bind (&RegionView::region_changed, this, _1));
+
group->signal_event().connect (sigc::bind (sigc::mem_fun (PublicEditor::instance(), &PublicEditor::canvas_region_view_event), group, this));
set_colors ();
void enable_display(bool yn) { _enable_display = yn; }
virtual void update_coverage_frames (LayerDisplay);
- static boost::signals2::signal<void(RegionView*)> RegionViewGoingAway;
+ static PBD::Signal1<void,RegionView*> RegionViewGoingAway;
protected:
bool in_destructor;
bool wait_for_data;
- boost::signals2::scoped_connection data_ready_connection;
+ PBD::ScopedConnection data_ready_connection;
std::vector<GhostRegion*> ghosts;
show_all ();
_return->set_metering (true);
- _return->input()->changed.connect (sigc::mem_fun (*this, &ReturnUI::ins_changed));
+ _return->input()->changed.connect (input_change_connection, boost::bind (&ReturnUI::ins_changed, this, _1, _2));
_gpm.setup_meters ();
_gpm.set_fader_name ("ReturnUIFrame");
set_name ("ReturnUIWindow");
- going_away_connection = r->GoingAway.connect (sigc::mem_fun (*this, &ReturnUIWindow::return_going_away));
+ r->GoingAway.connect (going_away_connection, boost::bind (&ReturnUIWindow::return_going_away, this));
signal_delete_event().connect (sigc::bind (sigc::ptr_fun (just_hide_it), reinterpret_cast<Window *> (this)));
}
sigc::connection screen_update_connection;
sigc::connection fast_screen_update_connection;
+ PBD::ScopedConnection input_change_connection;
void ins_changed (ARDOUR::IOChange, void*);
};
//route_select_list.rows().back().select ();
- scoped_connect (route->NameChanged, boost::bind (&RouteParams_UI::route_name_changed, this, boost::weak_ptr<Route>(route)));
- scoped_connect (route->GoingAway, boost::bind (&RouteParams_UI::route_removed, this, boost::weak_ptr<Route>(route)));
+ route->NameChanged.connect (*this, boost::bind (&RouteParams_UI::route_name_changed, this, boost::weak_ptr<Route>(route)));
+ route->GoingAway.connect (*this, boost::bind (&RouteParams_UI::route_removed, this, boost::weak_ptr<Route>(route)));
}
}
latency_packer.pack_start (delay_label);
latency_click_connection = latency_apply_button.signal_clicked().connect (sigc::mem_fun (*latency_widget, &LatencyGUI::finish));
- latency_connections.add_connection (_route->signal_latency_changed.connect (sigc::mem_fun (*this, &RouteParams_UI::refresh_latency)));
- latency_connections.add_connection ( _route->initial_delay_changed.connect (sigc::mem_fun (*this, &RouteParams_UI::refresh_latency)));
+ _route->signal_latency_changed.connect (latency_connections, sigc::mem_fun (*this, &RouteParams_UI::refresh_latency));
+ _route->initial_delay_changed.connect (latency_connections, sigc::mem_fun (*this, &RouteParams_UI::refresh_latency));
latency_frame.add (latency_packer);
latency_frame.show_all ();
if (_session) {
boost::shared_ptr<RouteList> r = _session->get_routes();
add_routes (*r);
- _session_connections.add_connection (_session->RouteAdded.connect (sigc::mem_fun(*this, &RouteParams_UI::add_routes)));
+ _session->RouteAdded.connect (_session_connections, sigc::mem_fun(*this, &RouteParams_UI::add_routes));
start_updating ();
} else {
stop_updating ();
setup_processor_boxes();
setup_latency_frame ();
- _route_processors_connection = route->processors_changed.connect (boost::bind (&RouteParams_UI::processors_changed, this, _1));
+ route->processors_changed.connect (_route_processors_connection, boost::bind (&RouteParams_UI::processors_changed, this, _1));
track_input_label.set_text (_route->name());
SendUI *send_ui = new SendUI (this, send, _session);
cleanup_view();
- _processor_going_away_connection = send->GoingAway.connect (boost::bind (&RouteParams_UI::processor_going_away, this,
- boost::weak_ptr<Processor>(proc)));
-
+ send->GoingAway.connect (_processor_going_away_connection, boost::bind (&RouteParams_UI::processor_going_away, this, boost::weak_ptr<Processor>(proc)));
_active_view = send_ui;
redir_hpane.add2 (*_active_view);
ReturnUI *return_ui = new ReturnUI (this, retrn, _session);
cleanup_view();
- _processor_going_away_connection = retrn->GoingAway.connect (boost::bind (&RouteParams_UI::processor_going_away, this,
- boost::weak_ptr<Processor>(proc)));
+ retrn->GoingAway.connect (_processor_going_away_connection, boost::bind (&RouteParams_UI::processor_going_away, this, boost::weak_ptr<Processor>(proc)));
_active_view = return_ui;
redir_hpane.add2 (*_active_view);
GenericPluginUI *plugin_ui = new GenericPluginUI (plugin_insert, true);
cleanup_view();
- _processor_going_away_connection = plugin_insert->plugin()->GoingAway.connect (boost::bind (&RouteParams_UI::plugin_going_away, this, PreFader));
+ plugin_insert->plugin()->GoingAway.connect (_processor_going_away_connection, boost::bind (&RouteParams_UI::plugin_going_away, this, PreFader));
plugin_ui->start_updating (0);
_active_view = plugin_ui;
+
redir_hpane.pack2 (*_active_view);
redir_hpane.show_all();
PortInsertUI *portinsert_ui = new PortInsertUI (this, _session, port_insert);
cleanup_view();
-
_processor_going_away_connection = port_insert->GoingAway.connect (boost::bind (&RouteParams_UI::processor_going_away, this, boost::weak_ptr<Processor> (proc)));
+
port_insert->GoingAway.connect (_processor_going_away_connection, boost::bind (&RouteParams_UI::processor_going_away, this, boost::weak_ptr<Processor> (proc)));
_active_view = portinsert_ui;
+
redir_hpane.pack2 (*_active_view);
portinsert_ui->redisplay();
redir_hpane.show_all();
#include <gtkmm/treeview.h>
#include "pbd/stateful.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/ardour.h"
RouteRedirectSelection::clear_routes ()
{
routes.clear ();
+ drop_connections ();
RoutesChanged ();
}
{
if (find (routes.begin(), routes.end(), r) == routes.end()) {
routes.push_back (r);
- r->GoingAway.connect (boost::bind (&RouteRedirectSelection::removed, this, boost::weak_ptr<Route>(r)));
+ r->GoingAway.connect (*this, boost::bind (&RouteRedirectSelection::removed, this, boost::weak_ptr<Route>(r)));
RoutesChanged();
}
}
#define __ardour_gtk_route_processor_selection_h__
#include <vector>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "processor_selection.h"
#include "route_selection.h"
}
controls_hbox.pack_start(gm.get_level_meter(), false, false);
- _route->meter_change.connect (sigc::mem_fun(*this, &RouteTimeAxisView::meter_changed));
- _route->input()->changed.connect (sigc::mem_fun(*this, &RouteTimeAxisView::io_changed));
- _route->output()->changed.connect (sigc::mem_fun(*this, &RouteTimeAxisView::io_changed));
+ _route->meter_change.connect (*this, boost::bind (&RouteTimeAxisView::meter_changed, this, _1));
+ _route->input()->changed.connect (*this, boost::bind (&RouteTimeAxisView::io_changed, this, _1, _2));
+ _route->output()->changed.connect (*this, boost::bind (&RouteTimeAxisView::io_changed, this, _1, _2));
controls_table.attach (*mute_button, 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
controls_table.attach (*solo_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
_y_position = -1;
- _route->mute_changed.connect (sigc::mem_fun(*this, &RouteUI::mute_changed));
- _route->solo_changed.connect (sigc::mem_fun(*this, &RouteUI::solo_changed));
- _route->processors_changed.connect (sigc::mem_fun(*this, &RouteTimeAxisView::processors_changed));
- _route->NameChanged.connect (sigc::mem_fun(*this, &RouteTimeAxisView::route_name_changed));
- _route->solo_isolated_changed.connect (sigc::mem_fun(*this, &RouteUI::solo_changed));
+ _route->mute_changed.connect (*this, boost::bind (&RouteUI::mute_changed, this, _1));
+ _route->solo_changed.connect (*this, boost::bind (&RouteUI::solo_changed, this, _1));
+ _route->processors_changed.connect (*this, boost::bind (&RouteTimeAxisView::processors_changed, this, _1));
+ _route->NameChanged.connect (*this, boost::bind (&RouteTimeAxisView::route_name_changed, this));
+ _route->solo_isolated_changed.connect (*this, boost::bind (&RouteUI::solo_changed, this, _1));
if (is_track()) {
- track()->TrackModeChanged.connect (sigc::mem_fun(*this, &RouteTimeAxisView::track_mode_changed));
- track()->FreezeChange.connect (sigc::mem_fun(*this, &RouteTimeAxisView::map_frozen));
- track()->DiskstreamChanged.connect (sigc::mem_fun(*this, &RouteTimeAxisView::diskstream_changed));
- get_diskstream()->SpeedChanged.connect (sigc::mem_fun(*this, &RouteTimeAxisView::speed_changed));
+ track()->TrackModeChanged.connect (*this, boost::bind (&RouteTimeAxisView::track_mode_changed, this));
+ track()->FreezeChange.connect (*this, boost::bind (&RouteTimeAxisView::map_frozen, this));
+ track()->DiskstreamChanged.connect (*this, boost::bind (&RouteTimeAxisView::diskstream_changed, this));
+ get_diskstream()->SpeedChanged.connect (*this, boost::bind (&RouteTimeAxisView::speed_changed, this));
/* pick up the correct freeze state */
map_frozen ();
RouteTimeAxisView::~RouteTimeAxisView ()
{
drop_references ();
+ drop_connections ();
for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
delete *i;
if (!Profile->get_sae()) {
items.push_back (MenuElem (_("Alignment"), *alignment_menu));
- get_diskstream()->AlignmentStyleChanged.connect (
- sigc::mem_fun(*this, &RouteTimeAxisView::align_style_changed));
+ get_diskstream()->AlignmentStyleChanged.connect (route_connections, boost::bind (&RouteTimeAxisView::align_style_changed, this));
RadioMenuItem::Group mode_group;
items.push_back (RadioMenuElem (mode_group, _("Normal mode"), sigc::bind (
}
}
- get_diskstream()->AlignmentStyleChanged.connect (
- sigc::mem_fun(*this, &RouteTimeAxisView::align_style_changed));
+ get_diskstream()->AlignmentStyleChanged.connect (route_connections, boost::bind (&RouteTimeAxisView::align_style_changed, this));
mode_menu = build_mode_menu();
if (mode_menu)
show_sends_button->set_self_managed (true);
UI::instance()->set_tip (show_sends_button, _("make mixer strips show sends to this bus"), "");
- _session_connections.add_connection (_session->SoloChanged.connect (sigc::mem_fun(*this, &RouteUI::solo_changed_so_update_mute)));
- _session_connections.add_connection (_session->TransportStateChange.connect (sigc::mem_fun (*this, &RouteUI::check_rec_enable_sensitivity)));
+ _session->SoloChanged.connect (_session_connections, sigc::mem_fun(*this, &RouteUI::solo_changed_so_update_mute));
+ _session->TransportStateChange.connect (_session_connections, sigc::mem_fun (*this, &RouteUI::check_rec_enable_sensitivity));
+ _session->RecordStateChanged.connect (_session_connections, boost::bind (&RouteUI::session_rec_enable_changed, this));
- Config->ParameterChanged.connect (sigc::mem_fun (*this, &RouteUI::parameter_changed));
+ Config->ParameterChanged.connect (*this, boost::bind (&RouteUI::parameter_changed, this, _1));
}
void
RouteUI::reset ()
{
- route_going_away_connection.disconnect();
- connections.drop_connections ();
+ route_connections.drop_connections ();
delete solo_menu;
solo_menu = 0;
cerr << "\n\nExpect to see route " << _route->name() << " be deleted\n";
_route.reset (); /* drop reference to route, so that it can be cleaned up */
- route_going_away_connection.disconnect ();
- connections.drop_connections ();
+ route_connections.drop_connections ();
delete_when_idle (this);
}
}
if (self_destruct) {
- route_going_away_connection = rp->GoingAway.connect (boost::bind (&RouteUI::self_delete, this));
+ rp->GoingAway.connect (route_connections, boost::bind (&RouteUI::self_delete, this));
}
mute_button->set_controllable (_route->mute_control());
solo_button->set_controllable (_route->solo_control());
- connections.add_connection (_route->active_changed.connect (sigc::mem_fun (*this, &RouteUI::route_active_changed)));
- connections.add_connection (_route->mute_changed.connect (sigc::mem_fun(*this, &RouteUI::mute_changed)));
- connections.add_connection (_route->solo_changed.connect (sigc::mem_fun(*this, &RouteUI::solo_changed)));
- connections.add_connection (_route->listen_changed.connect (sigc::mem_fun(*this, &RouteUI::listen_changed)));
- connections.add_connection (_route->solo_isolated_changed.connect (sigc::mem_fun(*this, &RouteUI::solo_changed)));
+ _route->active_changed.connect (route_connections, boost::bind (&RouteUI::route_active_changed, this));
+ _route->mute_changed.connect (route_connections, boost::bind (&RouteUI::mute_changed, this, _1));
+ _route->solo_changed.connect (route_connections, boost::bind (&RouteUI::solo_changed, this, _1));
+ _route->listen_changed.connect (route_connections, boost::bind (&RouteUI::listen_changed, this, _1));
+ _route->solo_isolated_changed.connect (route_connections, boost::bind (&RouteUI::solo_changed, this, _1));
if (_session->writable() && is_track()) {
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(_route);
- connections.add_connection (t->diskstream()->RecordEnableChanged.connect (sigc::mem_fun (*this, &RouteUI::route_rec_enable_changed)));
- connections.add_connection (_session->RecordStateChanged.connect (sigc::mem_fun (*this, &RouteUI::session_rec_enable_changed)));
+ t->diskstream()->RecordEnableChanged.connect (route_connections, boost::bind (&RouteUI::route_rec_enable_changed, this));
rec_enable_button->show();
rec_enable_button->set_controllable (t->rec_enable_control());
void
RouteUI::session_rec_enable_changed ()
{
+ if (!rec_enable_button) {
+ return;
+ }
+
Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_rec_display, this));
}
void
RouteUI::update_rec_display ()
{
+ if (!rec_enable_button) {
+ return;
+ }
+
bool model = _route->record_enabled();
bool view = rec_enable_button->get_active();
check = new CheckMenuItem(_("Solo Isolate"));
check->set_active (_route->solo_isolated());
check->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_isolated), check));
- _route->solo_isolated_changed.connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::solo_isolated_toggle), check));
+ _route->solo_isolated_changed.connect (route_connections, boost::bind (&RouteUI::solo_isolated_toggle, this, _1, check));
items.push_back (CheckMenuElem(*check));
check->show_all();
check = new CheckMenuItem(_("Solo Safe"));
check->set_active (_route->solo_safe());
check->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_safe), check));
- _route->solo_safe_changed.connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::solo_safe_toggle), check));
+ _route->solo_safe_changed.connect (route_connections, boost::bind (&RouteUI::solo_safe_toggle, this, _1, check));
items.push_back (CheckMenuElem(*check));
check->show_all();
//items.push_back (SeparatorElem());
// items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
- _route->mute_points_changed.connect (sigc::mem_fun (*this, &RouteUI::muting_change));
+ _route->mute_points_changed.connect (route_connections, boost::bind (&RouteUI::muting_change, this));
}
void
#include <list>
#include "pbd/xml++.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/ardour.h"
#include "ardour/mute_master.h"
static int mute_visual_state (ARDOUR::Session*, boost::shared_ptr<ARDOUR::Route>);
protected:
- PBD::ScopedConnectionList connections;
- boost::signals2::scoped_connection route_going_away_connection;
+ PBD::ScopedConnectionList route_connections;
bool self_destruct;
void init ();
if ((i = find (tracks.begin(), tracks.end(), track)) == tracks.end()) {
void (Selection::*pmf)(TimeAxisView*) = &Selection::remove;
- track->GoingAway.connect (boost::bind (pmf, this, track));
+ track->GoingAway.connect (*this, boost::bind (pmf, this, track));
tracks.push_back (track);
} else {
tracks.erase (i);
for (list<TimeAxisView*>::const_iterator i = added.begin(); i != added.end(); ++i) {
void (Selection::*pmf)(TimeAxisView*) = &Selection::remove;
- scoped_connect ((*i)->GoingAway, boost::bind (pmf, this, (*i)));
+ (*i)->GoingAway.connect (*this, boost::bind (pmf, this, (*i)));
}
if (!added.empty()) {
void (Selection::*pmf)(Marker*) = &Selection::remove;
- scoped_connect (m->GoingAway, boost::bind (pmf, this, m));
+ m->GoingAway.connect (*this, boost::bind (pmf, this, m));
markers.push_back (m);
MarkersChanged();
#include <vector>
#include <boost/shared_ptr.hpp>
+#include <boost/noncopyable.hpp>
#include <sigc++/signal.h>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "time_selection.h"
#include "region_selection.h"
template<class A> void foreach_region (void (ARDOUR::Region::*method)(A), A arg);
private:
- Selection (const Selection& other) : tracks (other.tracks) {}
PublicEditor const * editor;
uint32_t next_time_id;
_send->set_metering (true);
- _send->input()->changed.connect (sigc::mem_fun (*this, &SendUI::ins_changed));
- _send->output()->changed.connect (sigc::mem_fun (*this, &SendUI::outs_changed));
+ _send->input()->changed.connect (connections, boost::bind (&SendUI::ins_changed, this, _1, _2));
+ _send->output()->changed.connect (connections, boost::bind (&SendUI::outs_changed, this, _1, _2));
_panners.set_width (Wide);
_panners.setup_pan ();
set_name ("SendUIWindow");
- going_away_connection = s->GoingAway.connect (sigc::mem_fun (*this, &SendUIWindow::send_going_away));
+ s->GoingAway.connect (going_away_connection, boost::bind (&SendUIWindow::send_going_away, this));
signal_delete_event().connect (sigc::bind (
sigc::ptr_fun (just_hide_it),
void ins_changed (ARDOUR::IOChange, void*);
void outs_changed (ARDOUR::IOChange, void*);
+ PBD::ScopedConnectionList connections;
};
class SendUIWindow : public ArdourDialog
ok_button->signal_clicked().connect (sigc::mem_fun (*this, &SessionImportDialog::do_merge));
// prompt signals
- ElementImporter::Rename.connect (sigc::mem_fun (*this, &SessionImportDialog::open_rename_dialog));
- ElementImporter::Prompt.connect (sigc::mem_fun (*this, &SessionImportDialog::open_prompt_dialog));
+ ElementImporter::Rename.connect (connections, boost::bind (&SessionImportDialog::open_rename_dialog, this, _1, _2));
+ ElementImporter::Prompt.connect (connections, boost::bind (&SessionImportDialog::open_prompt_dialog, this, _1));
// Finalize
show_all();
Gtk::Button* ok_button;
Gtk::Button* cancel_button;
+
+ PBD::ScopedConnectionList connections;
};
#endif
sigc::mem_fun (*_session_config, &SessionConfiguration::set_sync_source)
);
- s->MTC_PortChanged.connect (sigc::bind (sigc::mem_fun (*this, &SessionOptionEditor::populate_sync_options), s, ssrc));
- s->MIDIClock_PortChanged.connect (sigc::bind (sigc::mem_fun (*this, &SessionOptionEditor::populate_sync_options), s, ssrc));
- s->config.ParameterChanged.connect (sigc::bind (sigc::mem_fun (*this, &SessionOptionEditor::follow_sync_state), s, ssrc));
+ s->MTC_PortChanged.connect (_session_connections, boost::bind (&SessionOptionEditor::populate_sync_options, this, s, ssrc));
+ s->MIDIClock_PortChanged.connect (_session_connections, boost::bind (&SessionOptionEditor::populate_sync_options, this, s, ssrc));
+ s->config.ParameterChanged.connect (_session_connections, boost::bind (&SessionOptionEditor::follow_sync_state, this, _1, s, ssrc));
populate_sync_options (s, ssrc);
follow_sync_state (string ("external-sync"), s, ssrc);
set_default_size (pixbuf->get_width(), pixbuf->get_height());
the_splash = this;
- ARDOUR::BootMessage.connect (sigc::mem_fun (*this, &Splash::boot_message));
+ ARDOUR::BootMessage.connect (msg_connection, boost::bind (&Splash::boot_message, this, _1));
}
void
#include <gtkmm/label.h>
#include <gdkmm/pixbuf.h>
+#include "pbd/signals.h"
+
class ARDOUR_UI;
class Splash : public Gtk::Window
Glib::RefPtr<Pango::Layout> layout;
void boot_message (std::string);
+ PBD::ScopedConnection msg_connection;
};
#endif /* __ardour_gtk_splash_h__ */
canvas_rect, &_trackview));
if (_trackview.is_track()) {
- scoped_connect (_trackview.track()->DiskstreamChanged, boost::bind (&StreamView::diskstream_changed, this));
- scoped_connect (_trackview.get_diskstream()->RecordEnableChanged, boost::bind (&StreamView::rec_enable_changed, this));
+ _trackview.track()->DiskstreamChanged.connect (*this, boost::bind (&StreamView::diskstream_changed, this));
+ _trackview.get_diskstream()->RecordEnableChanged.connect (*this, boost::bind (&StreamView::rec_enable_changed, this));
- scoped_connect (_trackview.session()->TransportStateChange, boost::bind (&StreamView::transport_changed, this));
- scoped_connect (_trackview.session()->TransportLooped, boost::bind (&StreamView::transport_looped, this));
- scoped_connect (_trackview.session()->RecordStateChanged, boost::bind (&StreamView::sess_rec_enable_changed, this));
+ _trackview.session()->TransportStateChange.connect (*this, boost::bind (&StreamView::transport_changed, this));
+ _trackview.session()->TransportLooped.connect (*this, boost::bind (&StreamView::transport_looped, this));
+ _trackview.session()->RecordStateChanged.connect (*this, boost::bind (&StreamView::sess_rec_enable_changed, this));
}
ColorsChanged.connect (sigc::mem_fun (*this, &StreamView::color_handler));
{
playlist_change_connection.disconnect();
playlist_changed (ds);
- playlist_change_connection = ds->PlaylistChanged.connect (boost::bind (&StreamView::playlist_changed_weak, this, boost::weak_ptr<Diskstream> (ds)));
+ ds->PlaylistChanged.connect (playlist_change_connection, boost::bind (&StreamView::playlist_changed_weak, this, boost::weak_ptr<Diskstream> (ds)));
}
void
/* catch changes */
- playlist_connections.add_connection (ds->playlist()->Modified.connect (boost::bind (&StreamView::playlist_modified_weak, this, ds)));
- playlist_connections.add_connection (ds->playlist()->RegionAdded.connect (boost::bind (&StreamView::add_region_view_weak, this, _1)));
- playlist_connections.add_connection (ds->playlist()->RegionRemoved.connect (boost::bind (&StreamView::remove_region_view, this, _1)));
+ ds->playlist()->Modified.connect (playlist_connections, boost::bind (&StreamView::playlist_modified_weak, this, ds));
+ ds->playlist()->RegionAdded.connect (playlist_connections, boost::bind (&StreamView::add_region_view_weak, this, _1));
+ ds->playlist()->RegionRemoved.connect (playlist_connections, boost::bind (&StreamView::remove_region_view, this, _1));
}
void
#include <list>
#include <cmath>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/location.h"
#include "enums.h"
/* every time the wave data changes and peaks are ready, redraw */
for (uint32_t n = 0; n < audio_region()->n_channels(); ++n) {
- audio_region()->audio_source(n)->PeaksReady.connect (sigc::bind (sigc::mem_fun(*this, &TapeAudioRegionView::update), n));
+ audio_region()->audio_source(n)->PeaksReady.connect (*this, boost::bind (&TapeAudioRegionView::update, this, n));
}
}
if(gr) {
ghosts.push_back(gr);
- scoped_connect (gr->GoingAway, boost::bind (&TimeAxisView::erase_ghost, this, _1));
+ gr->GoingAway.connect (*this, boost::bind (&TimeAxisView::erase_ghost, this, _1));
}
}
#include <gtkmm2ext/focus_entry.h>
#include "pbd/stateful.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/types.h"
#include "ardour/region.h"
#include <libgnomecanvasmm/pixbuf.h>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "selectable.h"
#include "simplerect.h"
#include <limits.h>
#include <signal.h>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include "pbd/error.h"
#include "pbd/failed_constructor.h"
class AudioEngine;
static const nframes_t max_frames = JACK_MAX_FRAMES;
- extern boost::signals2::signal<void(std::string)> BootMessage;
+ extern PBD::Signal1<void,std::string> BootMessage;
int init (bool with_vst, bool try_optimization);
void init_post_engine ();
#include <glibmm/thread.h>
#include "pbd/rcu.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/ardour.h"
#include <jack/jack.h>
_ the regular process() call to session->process() is not made.
*/
- boost::signals2::signal<int(nframes_t)> Freewheel;
+ PBD::Signal1<int,nframes_t> Freewheel;
- boost::signals2::signal<void()> Xrun;
+ PBD::Signal0<void> Xrun;
/* this signal is if JACK notifies us of a graph order event */
- boost::signals2::signal<void()> GraphReordered;
+ PBD::Signal0<void> GraphReordered;
/* this signal is emitted if the sample rate changes */
- boost::signals2::signal<void(nframes_t)> SampleRateChanged;
+ PBD::Signal1<void,nframes_t> SampleRateChanged;
/* this signal is sent if JACK ever disconnects us */
- boost::signals2::signal<void()> Halted;
+ PBD::Signal0<void> Halted;
/* these two are emitted when the engine itself is
started and stopped
*/
- boost::signals2::signal<void()> Running;
- boost::signals2::signal<void()> Stopped;
+ PBD::Signal0<void> Running;
+ PBD::Signal0<void> Stopped;
/* this signal is emitted if a JACK port is registered or unregistered */
- boost::signals2::signal<void()> PortRegisteredOrUnregistered;
+ PBD::Signal0<void> PortRegisteredOrUnregistered;
std::string make_port_name_relative (std::string);
std::string make_port_name_non_relative (std::string);
static void set_bwf_serial_number (int);
static void set_header_position_offset (nframes_t offset );
- static boost::signals2::signal<void()> HeaderPositionOffsetChanged;
+ static PBD::Signal0<void> HeaderPositionOffsetChanged;
protected:
/** Constructor to be called for existing external-to-session files */
int set_state (const XMLNode&, int version);
- boost::signals2::signal<void(boost::shared_ptr<Crossfade>)> NewCrossfade;
+ PBD::Signal1<void,boost::shared_ptr<Crossfade> > NewCrossfade;
void foreach_crossfade (boost::function<void (boost::shared_ptr<Crossfade>)>);
void crossfades_at (nframes_t frame, Crossfades&);
sframes_t start, nframes_t cnt, double samples_per_visual_peak) const;
int build_peaks ();
- bool peaks_ready (boost::function<void()> callWhenReady, boost::signals2::connection& connection_established_if_not_ready) const;
+ bool peaks_ready (boost::function<void()> callWhenReady, PBD::Connection& connection_created_if_not_ready) const;
- mutable boost::signals2::signal<void()> PeaksReady;
- mutable boost::signals2::signal<void(nframes_t,nframes_t)> PeakRangeReady;
+ mutable PBD::Signal0<void> PeaksReady;
+ mutable PBD::Signal2<void,nframes_t,nframes_t> PeakRangeReady;
XMLNode& get_state ();
int set_state (const XMLNode&, int version);
void set_automation_state (AutoState);
AutoState automation_state() const { return _state; }
- boost::signals2::signal<void()> automation_state_changed;
+ PBD::Signal0<void> automation_state_changed;
void set_automation_style (AutoStyle m);
AutoStyle automation_style() const { return _style; }
- boost::signals2::signal<void()> automation_style_changed;
+ PBD::Signal0<void> automation_style_changed;
bool automation_playback() const {
return (_state & Play) || ((_state & Touch) && !_touching);
return (_state & Write) || ((_state & Touch) && _touching);
}
- boost::signals2::signal<void()> StateChanged;
+ PBD::Signal0<void> StateChanged;
- static boost::signals2::signal<void(AutomationList*)> AutomationListCreated;
- mutable boost::signals2::signal<void()> Dirty;
+ static PBD::Signal1<void,AutomationList*> AutomationListCreated;
+ mutable PBD::Signal0<void> Dirty;
void start_touch ();
void stop_touch ();
#include <glibmm/thread.h>
#include <boost/shared_ptr.hpp>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/data_type.h"
DirectionChanged = 0x10 ///< the direction (whether ports are inputs or outputs) has changed
};
- boost::signals2::signal<void(Change)> Changed;
+ PBD::Signal1<void,Change> Changed;
protected:
#define __ardour_configuration_h__
#include <boost/function.hpp>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include "pbd/stateful.h"
#include "ardour/configuration_variable.h"
virtual XMLNode & get_variables () = 0;
virtual void set_variables (XMLNode const &) = 0;
- boost::signals2::signal<void(std::string)> ParameterChanged;
+ PBD::Signal1<void,std::string> ParameterChanged;
};
} // namespace ARDOUR
nframes_t overlap_length() const;
- boost::signals2::signal<void(boost::shared_ptr<Region>)> Invalidated;
- boost::signals2::signal<void(Change)> StateChanged;
+ PBD::Signal1<void,boost::shared_ptr<Region> > Invalidated;
+ PBD::Signal1<void,Change> StateChanged;
bool covers (nframes_t frame) const {
return _position <= frame && frame < _position + _length;
BufferSet& output_buffers() { return *_output_buffers; }
- boost::signals2::signal<void()> MuteChange;
+ PBD::Signal0<void> MuteChange;
- static boost::signals2::signal<void(nframes_t)> CycleStart;
+ static PBD::Signal1<void,nframes_t> CycleStart;
XMLNode& state (bool full);
int set_state (const XMLNode&, int version);
boost::shared_ptr<Panner> _panner;
static bool panners_legal;
- static boost::signals2::signal<int()> PannersLegal;
+ static PBD::Signal0<int> PannersLegal;
int panners_became_legal ();
- boost::signals2::scoped_connection panner_legal_c;
+ PBD::ScopedConnection panner_legal_c;
void output_changed (IOChange, void*);
gain_t target_gain ();
class Route;
class Session;
-class Diskstream : public SessionObject, public boost::noncopyable
+class Diskstream : public SessionObject
{
public:
enum Flag {
void move_processor_automation (boost::weak_ptr<Processor>,
std::list< Evoral::RangeMove<nframes_t> > const &);
- boost::signals2::signal<void()> RecordEnableChanged;
- boost::signals2::signal<void()> SpeedChanged;
- boost::signals2::signal<void()> ReverseChanged;
- boost::signals2::signal<void()> PlaylistChanged;
- boost::signals2::signal<void()> AlignmentStyleChanged;
- boost::signals2::signal<void(Location *)> LoopSet;
+ PBD::Signal0<void> RecordEnableChanged;
+ PBD::Signal0<void> SpeedChanged;
+ PBD::Signal0<void> ReverseChanged;
+ PBD::Signal0<void> PlaylistChanged;
+ PBD::Signal0<void> AlignmentStyleChanged;
+ PBD::Signal1<void,Location *> LoopSet;
- static boost::signals2::signal<void()> DiskOverrun;
- static boost::signals2::signal<void()> DiskUnderrun;
+ static PBD::Signal0<void> DiskOverrun;
+ static PBD::Signal0<void> DiskUnderrun;
protected:
friend class Session;
PBD::ScopedConnectionList playlist_connections;
- boost::signals2::scoped_connection ic_connection;
+ PBD::ScopedConnection ic_connection;
Flag _flags;
#include <string>
#include <utility>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include "ardour/types.h"
class XMLTree;
bool broken () { return _broken; }
/// Signal that requests for anew name
- static boost::signals2::signal <std::pair<bool, std::string> (std::string, std::string)> Rename;
+ static PBD::Signal2<std::pair<bool, std::string>,std::string, std::string> Rename;
/// Signal for ok/cancel prompting
- static boost::signals2::signal <bool(std::string)> Prompt;
+ static PBD::Signal1<bool,std::string> Prompt;
protected:
SRC_STATE* src_state;
nframes_t pos;
- boost::signals2::scoped_connection freewheel_connection;
+ PBD::ScopedConnection freewheel_connection;
/* shared between UI thread and audio thread */
Sample * mixdown_buffer;
Sample * gain_buffer;
- boost::signals2::scoped_connection export_connection;
+ PBD::ScopedConnection export_connection;
};
/// Export channel that reads from region channel
/// Writes all files for this channel config @return true if a new thread was spawned
bool write_files (boost::shared_ptr<ExportProcessor> new_processor);
- boost::signals2::signal<void()> FilesWritten;
+ PBD::Signal0<void> FilesWritten;
// Tells the handler the necessary information for it to handle tempfiles
void register_with_timespan (TimespanPtr timespan);
: _selected (false), _compatible (true) { }
~SelectableCompatible () {}
- boost::signals2::signal<void(bool)> SelectChanged;
- boost::signals2::signal<void(bool)> CompatibleChanged;
+ PBD::Signal1<void,bool> SelectChanged;
+ PBD::Signal1<void,bool> CompatibleChanged;
bool selected () const { return _selected; }
bool compatible () const { return _compatible; }
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/export_formats.h"
/* Signals */
- boost::signals2::signal<void(bool)> CompleteChanged;
+ PBD::Signal1<void,bool> CompleteChanged;
/* Access to lists */
#include <boost/weak_ptr.hpp>
#include "pbd/failed_constructor.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/export_format_base.h"
#include "ardour/export_format_compatibility.h"
/* Proxies for signals from sample formats and dither types */
- boost::signals2::signal<void(bool, WeakSampleFormatPtr)> SampleFormatSelectChanged;
- boost::signals2::signal<void(bool, WeakSampleFormatPtr)> SampleFormatCompatibleChanged;
+ PBD::Signal2<void,bool, WeakSampleFormatPtr> SampleFormatSelectChanged;
+ PBD::Signal2<void,bool, WeakSampleFormatPtr> SampleFormatCompatibleChanged;
- boost::signals2::signal<void(bool, WeakDitherTypePtr)> DitherTypeSelectChanged;
- boost::signals2::signal<void(bool, WeakDitherTypePtr)> DitherTypeCompatibleChanged;
+ PBD::Signal2<void,bool, WeakDitherTypePtr> DitherTypeSelectChanged;
+ PBD::Signal2<void,bool, WeakDitherTypePtr> DitherTypeCompatibleChanged;
static std::string get_sample_format_name (ExportFormatBase::SampleFormat format);
bool realtime;
- boost::signals2::scoped_connection files_written_connection;
- boost::signals2::scoped_connection export_read_finished_connection;
+ PBD::ScopedConnection files_written_connection;
+ PBD::ScopedConnection export_read_finished_connection;
std::list<Glib::ustring> files_written;
void add_file (const Glib::ustring&);
TimespanPtr current_timespan;
ConfigMap::iterator current_map_it;
TimespanBounds timespan_bounds;
- boost::signals2::scoped_connection channel_config_connection;
+ PBD::ScopedConnection channel_config_connection;
};
bool selected () const { return _selected; }
void select (bool value);
- boost::signals2::signal<void(bool)> SelectChanged;
+ PBD::Signal1<void,bool> SelectChanged;
protected:
void split_node (GraphNode * node, float position);
void remove_node (GraphNode * node);
- boost::signals2::signal<void()> GraphChanged;
+ PBD::Signal0<void> GraphChanged;
private:
void write_files ();
- static boost::signals2::signal<void(const Glib::ustring&)> WritingFile;
+ static PBD::Signal1<void,const Glib::ustring&> WritingFile;
private:
void remove_format_profile (FormatPtr format);
FormatPtr get_new_format (FormatPtr original);
- boost::signals2::signal<void()> FormatListChanged;
+ PBD::Signal0<void> FormatListChanged;
private:
#define __ardour_export_status_h__
#include <list>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include <stdint.h>
volatile bool stop;
volatile bool running;
- boost::signals2::signal<void()> Aborting;
+ PBD::Signal0<void> Aborting;
void abort (bool error_occurred = false);
bool aborted () const { return _aborted; }
bool errors () const { return _errors; }
- boost::signals2::signal<void()> Finished;
+ PBD::Signal0<void> Finished;
void finish ();
bool finished () const { return _finished; }
/// Reads data from each channel and writes to tempfile
int process (nframes_t frames);
- boost::signals2::scoped_connection process_connection;
+ PBD::ScopedConnection process_connection;
void set_range (nframes_t start, nframes_t end);
nframes_t get_length () const { return end_frame - start_frame; }
BufferSet* get_buffers();
void release_buffers();
- static boost::signals2::signal<void(nframes_t)> CycleStart;
+ static PBD::Signal1<void,nframes_t> CycleStart;
private:
BufferSet buffers;
BufferSet* target;
boost::shared_ptr<Route> _send_to;
PBD::ID _send_to_id;
- boost::signals2::scoped_connection connect_c;
+ PBD::ScopedConnection connect_c;
void send_to_going_away ();
void send_to_name_changed ();
const ChanCount& n_ports () const { return _ports.count(); }
- boost::signals2::signal<void(IOChange,void*)> changed;
+ PBD::Signal2<void,IOChange,void*> changed;
virtual XMLNode& state (bool full);
XMLNode& get_state (void);
static int disable_ports (void);
static int enable_ports (void);
- static boost::signals2::signal<void(ChanCount)> PortCountChanged; // emitted when the number of ports changes
+ static PBD::Signal1<void,ChanCount> PortCountChanged; // emitted when the number of ports changes
static std::string name_from_state (const XMLNode&);
static void set_name_in_state (XMLNode&, const std::string&);
/* we have to defer/order port connection. this is how we do it.
*/
- static boost::signals2::signal<int()> ConnectingLegal;
+ static PBD::Signal0<int> ConnectingLegal;
static bool connecting_legal;
XMLNode *pending_state_node;
private:
int connecting_became_legal ();
- boost::signals2::scoped_connection connection_legal_c;
+ PBD::ScopedConnection connection_legal_c;
boost::shared_ptr<Bundle> _bundle; ///< a bundle representing our ports
struct UserBundleInfo {
UserBundleInfo (IO*, boost::shared_ptr<UserBundle> b);
boost::shared_ptr<UserBundle> bundle;
- boost::signals2::scoped_connection changed;
+ PBD::ScopedConnection changed;
};
std::vector<UserBundleInfo*> _bundles_connected; ///< user bundles connected to our ports
virtual bool feeds (boost::shared_ptr<Route> other) const;
- boost::signals2::signal<void(IOProcessor*,bool)> AutomationPlaybackChanged;
- boost::signals2::signal<void(IOProcessor*,uint32_t)> AutomationChanged;
+ PBD::Signal2<void,IOProcessor*,bool> AutomationPlaybackChanged;
+ PBD::Signal2<void,IOProcessor*,uint32_t> AutomationChanged;
XMLNode& state (bool full_state);
int set_state (const XMLNode&, int version);
bool is_range_marker() const { return _flags & IsRangeMarker; }
bool matches (Flags f) const { return _flags & f; }
- boost::signals2::signal<void(Location*)> name_changed;
- boost::signals2::signal<void(Location*)> end_changed;
- boost::signals2::signal<void(Location*)> start_changed;
+ PBD::Signal1<void,Location*> name_changed;
+ PBD::Signal1<void,Location*> end_changed;
+ PBD::Signal1<void,Location*> start_changed;
- boost::signals2::signal<void(Location*,void*)> FlagsChanged;
+ PBD::Signal2<void,Location*,void*> FlagsChanged;
/* this is sent only when both start&end change at the same time */
- boost::signals2::signal<void(Location*)> changed;
+ PBD::Signal1<void,Location*> changed;
/* CD Track / CD-Text info */
void find_all_between (nframes64_t start, nframes64_t, LocationList&, Location::Flags);
- boost::signals2::signal<void(Location*)> current_changed;
- boost::signals2::signal<void()> changed;
- boost::signals2::signal<void(Location*)> added;
- boost::signals2::signal<void(Location*)> removed;
- boost::signals2::signal<void(Change)> StateChanged;
+ PBD::Signal1<void,Location*> current_changed;
+ PBD::Signal0<void> changed;
+ PBD::Signal1<void,Location*> added;
+ PBD::Signal1<void,Location*> removed;
+ PBD::Signal1<void,Change> StateChanged;
template<class T> void apply (T& obj, void (T::*method)(LocationList&)) {
Glib::Mutex::Lock lm (lock);
#include <vector>
#include "ardour/types.h"
#include "ardour/processor.h"
+#include "pbd/signals.h"
#include "pbd/fastlog.h"
namespace ARDOUR {
class Metering {
public:
static void update_meters ();
- static boost::signals2::signal<void()> Meter;
-
- static boost::signals2::connection connect (boost::function<void()>);
- static void disconnect (boost::signals2::connection& c);
+ static PBD::Signal0<void> Meter;
private:
/* this object is not meant to be instantiated */
Metering();
-
- static Glib::StaticMutex m_meter_signal_lock;
};
/** Meters peaks on the input and stores them for access.
XMLNode& get_state();
int set_state(const XMLNode&) { return 0; }
- boost::signals2::signal<void()> ContentsChanged;
+ PBD::Signal0<void> ContentsChanged;
const MidiSource* midi_source() const { return _midi_source; }
void set_midi_source(MidiSource* source) { _midi_source = source; }
#define MIDI_PATCH_MANAGER_H_
#include "midi++/midnam_patch.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/session_handle.h"
namespace ARDOUR {
uint32_t read_data_count() const { return _read_data_count; }
uint32_t write_data_count() const { return _write_data_count; }
- static boost::signals2::signal<void(MidiSource*)> MidiSourceCreated;
+ static PBD::Signal1<void,MidiSource*> MidiSourceCreated;
// Signal a range of recorded data is available for reading from model()
- mutable boost::signals2::signal<void(sframes_t,nframes_t)> ViewDataRangeReady;
+ mutable PBD::Signal2<void,sframes_t,nframes_t> ViewDataRangeReady;
XMLNode& get_state ();
int set_state (const XMLNode&, int version);
typedef std::list<GSource*> PortSources;
PortSources port_sources;
ARDOUR::Session& _session;
- boost::signals2::scoped_connection rebind_connection;
+ PBD::ScopedConnection rebind_connection;
bool midi_input_handler (Glib::IOCondition, MIDI::Port*);
void reset_ports ();
void set_value (float); /* note: float is used as a bitfield of MutePoints */
float get_value () const;
- boost::signals2::signal<void()> MutePointChanged;
+ PBD::Signal0<void> MutePointChanged;
XMLNode& get_state();
int set_state(const XMLNode&, int version);
int set_state (const XMLNode&, int version);
- static boost::signals2::signal<void(NamedSelection*)> NamedSelectionCreated;
+ static PBD::Signal1<void,NamedSelection*> NamedSelectionCreated;
};
}/* namespace ARDOUR */
boost::shared_ptr<AutomationControl> pan_control() { return _control; }
- boost::signals2::signal<void()> Changed; /* for position */
- boost::signals2::signal<void()> StateChanged; /* for mute */
+ PBD::Signal0<void> Changed; /* for position */
+ PBD::Signal0<void> StateChanged; /* for mute */
int set_state (const XMLNode&, int version);
virtual XMLNode& state (bool full_state) = 0;
StreamPanner &streampanner( uint32_t n ) const { assert( n < _streampanners.size() ); return *_streampanners[n]; }
uint32_t npanners() const { return _streampanners.size(); }
- boost::signals2::signal<void()> Changed;
- boost::signals2::signal<void()> LinkStateChanged;
- boost::signals2::signal<void()> StateChanged; /* for bypass */
+ PBD::Signal0<void> Changed;
+ PBD::Signal0<void> LinkStateChanged;
+ PBD::Signal0<void> StateChanged; /* for bypass */
/* only StreamPanner should call these */
class Region;
class Playlist : public SessionObject
- , public boost::noncopyable
, public boost::enable_shared_from_this<Playlist> {
public:
typedef std::list<boost::shared_ptr<Region> > RegionList;
int set_state (const XMLNode&, int version);
XMLNode& get_template ();
- boost::signals2::signal<void(bool)> InUse;
- boost::signals2::signal<void()> Modified;
- boost::signals2::signal<void(boost::weak_ptr<Region>)> RegionAdded;
- boost::signals2::signal<void(boost::weak_ptr<Region>)> RegionRemoved;
- boost::signals2::signal<void()> NameChanged;
- boost::signals2::signal<void()> LengthChanged;
- boost::signals2::signal<void(std::list< Evoral::RangeMove<nframes_t> > const &)> RangesMoved;
+ PBD::Signal1<void,bool> InUse;
+ PBD::Signal0<void> Modified;
+ PBD::Signal1<void,boost::weak_ptr<Region> > RegionAdded;
+ PBD::Signal1<void,boost::weak_ptr<Region> > RegionRemoved;
+ PBD::Signal0<void> NameChanged;
+ PBD::Signal0<void> LengthChanged;
+ PBD::Signal1<void,std::list< Evoral::RangeMove<nframes_t> > const &> RangesMoved;
static std::string bump_name (std::string old_name, Session&);
class PlaylistFactory {
public:
- static boost::signals2::signal<void(boost::shared_ptr<Playlist>, bool)> PlaylistCreated;
+ static PBD::Signal2<void,boost::shared_ptr<Playlist>, bool> PlaylistCreated;
static boost::shared_ptr<Playlist> create (Session&, const XMLNode&, bool hidden = false, bool unused = false);
static boost::shared_ptr<Playlist> create (DataType type, Session&, std::string name, bool hidden = false);
virtual bool has_editor() const = 0;
- boost::signals2::signal<void(uint32_t,float)> ParameterChanged;
+ PBD::Signal2<void,uint32_t,float> ParameterChanged;
/* NOTE: this block of virtual methods looks like the interface
to a Processor, but Plugin does not inherit from Processor.
void collect_signal_for_analysis(nframes_t nframes);
- boost::signals2::signal<void(BufferSet*, BufferSet*)> AnalysisDataGathered;
+ PBD::Signal2<void,BufferSet*, BufferSet*> AnalysisDataGathered;
private:
/* disallow copy construction */
PluginStatusType get_status (const PluginInfoPtr&);
/** plugins were added to or removed from one of the PluginInfoLists */
- boost::signals2::signal<void()> PluginListChanged;
+ PBD::Signal0<void> PluginListChanged;
private:
struct PluginStatus {
#include <vector>
#include <jack/jack.h>
#include <boost/utility.hpp>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include "ardour/data_type.h"
#include "ardour/types.h"
static void set_engine (AudioEngine *);
- boost::signals2::signal<void(bool)> MonitorInputChanged;
+ PBD::Signal1<void,bool> MonitorInputChanged;
protected:
void *get_gui () const { return _gui; }
void set_gui (void *p) { _gui = p; }
- static boost::signals2::signal<void(Processor*)> ProcessorCreated;
+ static PBD::Signal1<void,Processor*> ProcessorCreated;
- boost::signals2::signal<void()> ActiveChanged;
- boost::signals2::signal<void(ChanCount,ChanCount)> ConfigurationChanged;
+ PBD::Signal0<void> ActiveChanged;
+ PBD::Signal2<void,ChanCount,ChanCount> ConfigurationChanged;
protected:
int _pending_active;
#include <boost/utility.hpp>
#include "pbd/undo.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/ardour.h"
#include "ardour/data_type.h"
};
class Region
- : public SessionObject
- , public boost::noncopyable
- , public boost::enable_shared_from_this<Region>
- , public Readable
+ : public SessionObject
+ , public boost::enable_shared_from_this<Region>
+ , public Readable
{
public:
typedef std::vector<boost::shared_ptr<Source> > SourceList;
static Change LayerChanged;
static Change HiddenChanged;
- boost::signals2::signal<void(Change)> StateChanged;
- static boost::signals2::signal<void(boost::shared_ptr<ARDOUR::Region>)> RegionPropertyChanged;
+ PBD::Signal1<void,Change> StateChanged;
+ static PBD::Signal1<void,boost::shared_ptr<ARDOUR::Region> > RegionPropertyChanged;
void unlock_property_changes () { _flags = Flag (_flags & ~DoNotSendPropertyChanges); }
void block_property_changes () { _flags = Flag (_flags | DoNotSendPropertyChanges); }
itself, to permit dynamic_cast<> to be used to
infer the type of Region.
*/
- static boost::signals2::signal<void(boost::shared_ptr<Region>)> CheckNewRegion;
+ static PBD::Signal1<void,boost::shared_ptr<Region> > CheckNewRegion;
static boost::shared_ptr<Region> create (boost::shared_ptr<const Region>);
void set_user_latency (nframes_t);
nframes_t initial_delay() const { return _initial_delay; }
- boost::signals2::signal<void()> active_changed;
- boost::signals2::signal<void()> phase_invert_changed;
- boost::signals2::signal<void()> denormal_protection_changed;
- boost::signals2::signal<void(void*)> listen_changed;
- boost::signals2::signal<void(void*)> solo_changed;
- boost::signals2::signal<void(void*)> solo_safe_changed;
- boost::signals2::signal<void(void*)> solo_isolated_changed;
- boost::signals2::signal<void(void*)> comment_changed;
- boost::signals2::signal<void(void*)> mute_changed;
- boost::signals2::signal<void()> mute_points_changed;
+ PBD::Signal0<void> active_changed;
+ PBD::Signal0<void> phase_invert_changed;
+ PBD::Signal0<void> denormal_protection_changed;
+ PBD::Signal1<void,void*> listen_changed;
+ PBD::Signal1<void,void*> solo_changed;
+ PBD::Signal1<void,void*> solo_safe_changed;
+ PBD::Signal1<void,void*> solo_isolated_changed;
+ PBD::Signal1<void,void*> comment_changed;
+ PBD::Signal1<void,void*> mute_changed;
+ PBD::Signal0<void> mute_points_changed;
/** the processors have changed; the parameter indicates what changed */
- boost::signals2::signal<void(RouteProcessorChange)> processors_changed;
- boost::signals2::signal<void(void*)> record_enable_changed;
+ PBD::Signal1<void,RouteProcessorChange> processors_changed;
+ PBD::Signal1<void,void*> record_enable_changed;
/** the metering point has changed */
- boost::signals2::signal<void(void*)> meter_change;
- boost::signals2::signal<void()> signal_latency_changed;
- boost::signals2::signal<void()> initial_delay_changed;
+ PBD::Signal1<void,void*> meter_change;
+ PBD::Signal0<void> signal_latency_changed;
+ PBD::Signal0<void> initial_delay_changed;
/* gui's call this for their own purposes. */
- boost::signals2::signal<void(std::string,void*)> gui_changed;
+ PBD::Signal2<void,std::string,void*> gui_changed;
/* stateful */
int save_as_template (const std::string& path, const std::string& name);
- boost::signals2::signal<void(void*)> SelectedChanged;
+ PBD::Signal1<void,void*> SelectedChanged;
int listen_via (boost::shared_ptr<Route>, Placement p, bool active, bool aux);
void drop_listen (boost::shared_ptr<Route>);
void set_remote_control_id (uint32_t id);
uint32_t remote_control_id () const;
- boost::signals2::signal<void()> RemoteControlIDChanged;
+ PBD::Signal0<void> RemoteControlIDChanged;
void sync_order_keys (std::string const &);
- static boost::signals2::signal<void(std::string const &)> SyncOrderKeys;
+ static PBD::Signal1<void,std::string const &> SyncOrderKeys;
protected:
friend class Session;
#include <set>
#include <string>
#include <stdint.h>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include "pbd/stateful.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/types.h"
boost::shared_ptr<RouteList> route_list() { return routes; }
- boost::signals2::signal<void()> changed;
- boost::signals2::signal<void(void*)> FlagsChanged;
+ PBD::Signal0<void> changed;
+ PBD::Signal1<void,void*> FlagsChanged;
XMLNode& get_state ();
RouteGroup* route_group () const { return _route_group; }
- boost::signals2::signal<void()> route_group_changed;
+ PBD::Signal0<void> route_group_changed;
protected:
RouteGroup* _route_group;
#include "pbd/error.h"
#include "pbd/rcu.h"
#include "pbd/statefuldestructible.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "pbd/undo.h"
#include "midi++/mmc.h"
extern void setup_enum_writer ();
-class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager, public boost::noncopyable
+class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager
{
public:
enum RecordState {
void set_deletion_in_progress ();
void clear_deletion_in_progress ();
bool deletion_in_progress() const { return _state_of_the_state & Deletion; }
- boost::signals2::signal<void()> DirtyChanged;
+ PBD::Signal0<void> DirtyChanged;
const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
- static boost::signals2::signal<void()> AutoBindingOn;
- static boost::signals2::signal<void()> AutoBindingOff;
+ static PBD::Signal0<void> AutoBindingOn;
+ static PBD::Signal0<void> AutoBindingOff;
- static boost::signals2::signal<void(std::string)> Dialog;
+ static PBD::Signal1<void,std::string> Dialog;
std::string sound_dir (bool with_path = true) const;
std::string peak_dir () const;
/* Proxy signal for region hidden changes */
- boost::signals2::signal<void(boost::shared_ptr<Region>)> RegionHiddenChange;
+ PBD::Signal1<void,boost::shared_ptr<Region> > RegionHiddenChange;
/* Emitted when all i/o connections are complete */
- boost::signals2::signal<void()> IOConnectionsComplete;
+ PBD::Signal0<void> IOConnectionsComplete;
/* Record status signals */
- boost::signals2::signal<void()> RecordStateChanged;
+ PBD::Signal0<void> RecordStateChanged;
/* Transport mechanism signals */
- boost::signals2::signal<void()> TransportStateChange; /* generic */
- boost::signals2::signal<void(nframes64_t)> PositionChanged; /* sent after any non-sequential motion */
- boost::signals2::signal<void()> DurationChanged;
- boost::signals2::signal<void(nframes64_t)> Xrun;
- boost::signals2::signal<void()> TransportLooped;
+ PBD::Signal0<void> TransportStateChange; /* generic */
+ PBD::Signal1<void,nframes64_t> PositionChanged; /* sent after any non-sequential motion */
+ PBD::Signal0<void> DurationChanged;
+ PBD::Signal1<void,nframes64_t> Xrun;
+ PBD::Signal0<void> TransportLooped;
/** emitted when a locate has occurred */
- boost::signals2::signal<void()> Located;
+ PBD::Signal0<void> Located;
- boost::signals2::signal<void(RouteList&)> RouteAdded;
- boost::signals2::signal<void()> RouteGroupChanged;
+ PBD::Signal1<void,RouteList&> RouteAdded;
+ PBD::Signal0<void> RouteGroupChanged;
void queue_event (SessionEvent*);
Locations *locations() { return &_locations; }
- boost::signals2::signal<void(Location*)> auto_loop_location_changed;
- boost::signals2::signal<void(Location*)> auto_punch_location_changed;
- boost::signals2::signal<void()> locations_modified;
+ PBD::Signal1<void,Location*> auto_loop_location_changed;
+ PBD::Signal1<void,Location*> auto_punch_location_changed;
+ PBD::Signal0<void> locations_modified;
void set_auto_punch_location (Location *);
void set_auto_loop_location (Location *);
static int rename_template (std::string old_name, std::string new_name);
static int delete_template (std::string name);
- boost::signals2::signal<void(std::string)> StateSaved;
- boost::signals2::signal<void()> StateReady;
+ PBD::Signal1<void,std::string> StateSaved;
+ PBD::Signal0<void> StateReady;
std::vector<std::string*>* possible_states() const;
static std::vector<std::string*>* possible_states (std::string path);
RouteGroup *route_group_by_name (std::string);
- boost::signals2::signal<void(RouteGroup*)> route_group_added;
- boost::signals2::signal<void()> route_group_removed;
+ PBD::Signal1<void,RouteGroup*> route_group_added;
+ PBD::Signal0<void> route_group_removed;
void foreach_route_group (boost::function<void(RouteGroup*)> f) {
for (std::list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); i++) {
nframes_t convert_to_frames_at (nframes_t position, AnyTime const &);
- static boost::signals2::signal<void()> StartTimeChanged;
- static boost::signals2::signal<void()> EndTimeChanged;
- static boost::signals2::signal<void()> TimecodeOffsetChanged;
+ static PBD::Signal0<void> StartTimeChanged;
+ static PBD::Signal0<void> EndTimeChanged;
+ static PBD::Signal0<void> TimecodeOffsetChanged;
std::vector<SyncSource> get_available_sync_options() const;
void request_sync_source (Slave*);
TempoMap& tempo_map() { return *_tempo_map; }
/// signals the current transport position in frames, bbt and timecode time (in that order)
- boost::signals2::signal<void(const nframes_t&, const BBT_Time&, const Timecode::Time&)> tick;
+ PBD::Signal3<void,const nframes_t&, const BBT_Time&, const Timecode::Time&> tick;
/* region info */
void add_regions (std::vector<boost::shared_ptr<Region> >&);
- boost::signals2::signal<void(boost::weak_ptr<Region>)> RegionAdded;
- boost::signals2::signal<void(std::vector<boost::weak_ptr<Region> >&)> RegionsAdded;
- boost::signals2::signal<void(boost::weak_ptr<Region>)> RegionRemoved;
+ PBD::Signal1<void,boost::weak_ptr<Region> > RegionAdded;
+ PBD::Signal1<void,std::vector<boost::weak_ptr<Region> >&> RegionsAdded;
+ PBD::Signal1<void,boost::weak_ptr<Region> > RegionRemoved;
int region_name (std::string& result, std::string base = std::string(""), bool newlevel = false);
std::string new_region_name (std::string);
int start_audio_export (nframes_t position, bool realtime);
- boost::signals2::signal<int(nframes_t)> ProcessExport;
- boost::signals2::signal<void()> ExportReadFinished;
- static boost::signals2::signal<void(std::string, std::string)> Exported;
+ PBD::Signal1<int,nframes_t> ProcessExport;
+ PBD::Signal0<void> ExportReadFinished;
+ static PBD::Signal2<void,std::string, std::string> Exported;
void add_source (boost::shared_ptr<Source>);
void remove_source (boost::weak_ptr<Source>);
0 for "yes, delete this playlist",
1 for "no, don't delete this playlist".
*/
- boost::signals2::signal<void(boost::shared_ptr<Playlist>)> AskAboutPlaylistDeletion;
+ PBD::Signal1<void,boost::shared_ptr<Playlist> > AskAboutPlaylistDeletion;
/** handlers should return 0 for "ignore the rate mismatch",
!0 for "do not use this session"
*/
- static boost::signals2::signal<int(nframes_t, nframes_t)> AskAboutSampleRateMismatch;
+ static PBD::Signal2<int,nframes_t, nframes_t> AskAboutSampleRateMismatch;
/** handlers should return !0 for use pending state, 0 for ignore it.
*/
- static boost::signals2::signal<int()> AskAboutPendingState;
+ static PBD::Signal0<int> AskAboutPendingState;
boost::shared_ptr<AudioFileSource> create_audio_source_for_session (ARDOUR::AudioDiskstream&, uint32_t which_channel, bool destructive);
void remove_named_selection (NamedSelection *);
template<class T> void foreach_named_selection (T& obj, void (T::*func)(NamedSelection&));
- boost::signals2::signal<void()> NamedSelectionAdded;
- boost::signals2::signal<void()> NamedSelectionRemoved;
+ PBD::Signal0<void> NamedSelectionAdded;
+ PBD::Signal0<void> NamedSelectionRemoved;
/* Curves and AutomationLists (TODO when they go away) */
void add_automation_list(AutomationList*);
void cancel_audition ();
bool is_auditioning () const;
- boost::signals2::signal<void(bool)> AuditionActive;
+ PBD::Signal1<void,bool> AuditionActive;
/* flattening stuff */
void set_listen (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
void set_record_enable (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
- boost::signals2::signal<void(bool)> SoloActive;
- boost::signals2::signal<void()> SoloChanged;
+ PBD::Signal1<void,bool> SoloActive;
+ PBD::Signal0<void> SoloChanged;
/* control/master out */
void remove_bundle (boost::shared_ptr<Bundle>);
boost::shared_ptr<Bundle> bundle_by_name (std::string) const;
- boost::signals2::signal<void(boost::shared_ptr<Bundle>)> BundleAdded;
- boost::signals2::signal<void(boost::shared_ptr<Bundle>)> BundleRemoved;
+ PBD::Signal1<void,boost::shared_ptr<Bundle> > BundleAdded;
+ PBD::Signal1<void,boost::shared_ptr<Bundle> > BundleRemoved;
/* MIDI control */
MIDI::Port *midi_port() const { return _midi_port; }
MIDI::Port *midi_clock_port() const { return _midi_clock_port; }
- boost::signals2::signal<void()> MTC_PortChanged;
- boost::signals2::signal<void()> MMC_PortChanged;
- boost::signals2::signal<void()> MIDI_PortChanged;
- boost::signals2::signal<void()> MIDIClock_PortChanged;
+ PBD::Signal0<void> MTC_PortChanged;
+ PBD::Signal0<void> MMC_PortChanged;
+ PBD::Signal0<void> MIDI_PortChanged;
+ PBD::Signal0<void> MIDIClock_PortChanged;
void set_trace_midi_input (bool, MIDI::Port* port = 0);
void set_trace_midi_output (bool, MIDI::Port* port = 0);
void stop_scrub ();
void set_scrub_speed (float);
nframes_t scrub_buffer_size() const;
- boost::signals2::signal<void()> ScrubReady;
+ PBD::Signal0<void> ScrubReady;
/* History (for editors, mixers, UIs etc.) */
void* ptr,
float opt);
- static boost::signals2::signal<void()> SendFeedback;
+ static PBD::Signal0<void> SendFeedback;
/* Controllables */
int stop_audio_export ();
void finalize_audio_export ();
- boost::signals2::scoped_connection export_freewheel_connection;
+ PBD::ScopedConnection export_freewheel_connection;
void prepare_diskstreams ();
void commit_diskstreams (nframes_t, bool& session_requires_butler);
#ifndef __libardour_session_handle_h__
#define __libardour_session_handle_h__
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
namespace ARDOUR {
class Session;
#include <string>
#include "pbd/statefuldestructible.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/session_handle.h"
return true;
}
- boost::signals2::signal<void()> NameChanged;
+ PBD::Signal0<void> NameChanged;
protected:
std::string _name;
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
class XMLNode;
#include <jack/jack.h>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/types.h"
#include "midi++/parser.h"
private:
Session& session;
MIDI::Port* port;
- PBD::ScopedConnectionList* port_connections;
+ PBD::ScopedConnectionList port_connections;
bool can_notify_on_unknown_rate;
PIChaser* pic;
private:
ISlaveSessionProxy* session;
MIDI::Port* port;
- PBD::ScopedConnectionList* port_connections;
+ PBD::ScopedConnectionList port_connections;
/// pulses per quarter note for one MIDI clock frame (default 24)
int ppqn;
nframes_t destructive_write_unlocked (Sample *dst, nframes_t cnt);
nframes_t nondestructive_write_unlocked (Sample *dst, nframes_t cnt);
void handle_header_position_change ();
+ PBD::ScopedConnection header_position_connection;
};
} // namespace ARDOUR
class Session;
-class Source : public SessionObject, public boost::noncopyable
+class Source : public SessionObject
{
public:
enum Flag {
virtual bool set_destructive (bool /*yn*/) { return false; }
virtual bool length_mutable() const { return false; }
- static boost::signals2::signal<void(Source*)> SourceCreated;
- boost::signals2::signal<void(boost::shared_ptr<Source>)> Switched;
+ static PBD::Signal1<void,Source*> SourceCreated;
+ PBD::Signal1<void,boost::shared_ptr<Source> > Switched;
bool has_been_analysed() const;
virtual bool can_be_analysed() const { return false; }
virtual void set_been_analysed (bool yn);
virtual bool check_for_analysis_data_on_disk();
- boost::signals2::signal<void()> AnalysisChanged;
+ PBD::Signal0<void> AnalysisChanged;
AnalysisFeatureList transients;
std::string get_transients_path() const;
public:
static void init ();
- static boost::signals2::signal<void(boost::shared_ptr<Source>)> SourceCreated;
+ static PBD::Signal1<void,boost::shared_ptr<Source> > SourceCreated;
static boost::shared_ptr<Source> create (Session&, const XMLNode& node, bool async = false);
static boost::shared_ptr<Source> createSilent (Session&, const XMLNode& node,
nframes_t frame_rate () const { return _frame_rate; }
- boost::signals2::signal<void(ARDOUR::Change)> StateChanged;
+ PBD::Signal1<void,ARDOUR::Change> StateChanged;
private:
static Tempo _default_tempo;
#include "midi++/jack.h"
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "ardour/types.h"
#include "ardour/session_handle.h"
TrackMode mode () const { return _mode; }
virtual int set_mode (TrackMode /*m*/) { return false; }
virtual bool can_use_mode (TrackMode /*m*/, bool& /*bounce_required*/) { return false; }
- boost::signals2::signal<void()> TrackModeChanged;
+ PBD::Signal0<void> TrackModeChanged;
virtual int no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
bool state_changing, bool can_record, bool rec_monitors_input);
bool record_enabled() const;
void set_record_enable (bool yn, void *src);
- boost::signals2::signal<void()> DiskstreamChanged;
- boost::signals2::signal<void()> FreezeChange;
+ PBD::Signal0<void> DiskstreamChanged;
+ PBD::Signal0<void> FreezeChange;
protected:
Track (Session& sess, const XMLNode& node, DataType default_type = DataType::AUDIO);
continue; /* XXX is this OK? */
}
- scoped_connect (region->GoingAway, boost::bind (&Diskstream::remove_region_from_last_capture, this, boost::weak_ptr<Region>(region)));
+ region->GoingAway.connect (*this, boost::bind (&Diskstream::remove_region_from_last_capture, this, boost::weak_ptr<Region>(region)));
_last_capture_regions.push_back (region);
} else {
_crossfades.push_back (xfade);
- scoped_connect (xfade->Invalidated, boost::bind (&AudioPlaylist::crossfade_invalidated, this, _1));
- scoped_connect (xfade->StateChanged, boost::bind (&AudioPlaylist::crossfade_changed, this, _1));
+ xfade->Invalidated.connect (*this, boost::bind (&AudioPlaylist::crossfade_invalidated, this, _1));
+ xfade->StateChanged.connect (*this, boost::bind (&AudioPlaylist::crossfade_changed, this, _1));
notify_crossfade_added (xfade);
}
try {
boost::shared_ptr<Crossfade> xfade = boost::shared_ptr<Crossfade> (new Crossfade (*((const Playlist *)this), *child));
_crossfades.push_back (xfade);
- scoped_connect (xfade->Invalidated, boost::bind (&AudioPlaylist::crossfade_invalidated, this, _1));
- scoped_connect (xfade->StateChanged, boost::bind (&AudioPlaylist::crossfade_changed, this, _1));
+ xfade->Invalidated.connect (*this, boost::bind (&AudioPlaylist::crossfade_invalidated, this, _1));
+ xfade->StateChanged.connect (*this, boost::bind (&AudioPlaylist::crossfade_changed, this, _1));
NewCrossfade(xfade);
}
if (audio_diskstream()->deprecated_io_node) {
if (!IO::connecting_legal) {
- scoped_connect (IO::ConnectingLegal, boost::bind (&AudioTrack::deprecated_use_diskstream_connections, this));
+ IO::ConnectingLegal.connect (*this, boost::bind (&AudioTrack::deprecated_use_diskstream_connections, this));
} else {
deprecated_use_diskstream_connections ();
}
pending_state = const_cast<XMLNode*> (&node);
if (_session.state_of_the_state() & Session::Loading) {
- scoped_connect (_session.StateReady, boost::bind (&AudioTrack::set_state_part_two, this));
+ _session.StateReady.connect (*this, boost::bind (&AudioTrack::set_state_part_two, this));
} else {
set_state_part_two ();
}
if (g_atomic_int_get(&m_meter_exit)) {
break;
}
- Metering::update_meters ();
+ Metering::Meter ();
}
}
Port* dst = get_port_by_name_locked (d);
if (src) {
- ret = src->connect (d);
+ ret = src->connect (d);
} else if (dst) {
- ret = dst->connect (s);
+ ret = dst->connect (s);
} else {
/* neither port is known to us, and this API isn't intended for use as a general patch bay */
ret = -1;
ustring AudioFileSource::peak_dir = "";
-boost::signals2::signal<void()> AudioFileSource::HeaderPositionOffsetChanged;
+PBD::Signal0<void> AudioFileSource::HeaderPositionOffsetChanged;
uint64_t AudioFileSource::header_position_offset = 0;
/* XXX maybe this too */
{
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (src);
if (afs) {
- scoped_connect (afs->HeaderPositionOffsetChanged, boost::bind (&AudioRegion::source_offset_changed, this));
+ afs->HeaderPositionOffsetChanged.connect (*this, boost::bind (&AudioRegion::source_offset_changed, this));
}
init ();
{
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (src);
if (afs) {
- scoped_connect (afs->HeaderPositionOffsetChanged, boost::bind (&AudioRegion::source_offset_changed, this));
+ afs->HeaderPositionOffsetChanged.connect (*this, boost::bind (&AudioRegion::source_offset_changed, this));
}
init ();
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> ((*i));
if (afs) {
- scoped_connect (afs->HeaderPositionOffsetChanged, boost::bind (&AudioRegion::source_offset_changed, this));
+ afs->HeaderPositionOffsetChanged.connect (*this, boost::bind (&AudioRegion::source_offset_changed, this));
}
}
{
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (src);
if (afs) {
- scoped_connect (afs->HeaderPositionOffsetChanged, boost::bind (&AudioRegion::source_offset_changed, this));
+ afs->HeaderPositionOffsetChanged.connect (*this, boost::bind (&AudioRegion::source_offset_changed, this));
}
init ();
AudioRegion::connect_to_analysis_changed ()
{
for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
- scoped_connect ((*i)->AnalysisChanged, boost::bind (&AudioRegion::invalidate_transients, this));
+ (*i)->AnalysisChanged.connect (*this, boost::bind (&AudioRegion::invalidate_transients, this));
}
}
unique_srcs.insert (*i);
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (*i);
if (afs) {
- scoped_connect (afs->HeaderPositionOffsetChanged, boost::bind (&AudioRegion::source_offset_changed, this));
+ afs->HeaderPositionOffsetChanged.connect (*this, boost::bind (&AudioRegion::source_offset_changed, this));
}
}
}
void
AudioRegion::listen_to_my_curves ()
{
- scoped_connect (_envelope->StateChanged, boost::bind (&AudioRegion::envelope_changed, this));
- scoped_connect (_fade_in->StateChanged, boost::bind (&AudioRegion::fade_in_changed, this));
- scoped_connect (_fade_out->StateChanged, boost::bind (&AudioRegion::fade_out_changed, this));
+ _envelope->StateChanged.connect (*this, boost::bind (&AudioRegion::envelope_changed, this));
+ _fade_in->StateChanged.connect (*this, boost::bind (&AudioRegion::fade_in_changed, this));
+ _fade_out->StateChanged.connect (*this, boost::bind (&AudioRegion::fade_out_changed, this));
}
void
***********************************************************************/
bool
-AudioSource::peaks_ready (boost::function<void()> doThisWhenReady, boost::signals2::connection& connect_here_if_not) const
+AudioSource::peaks_ready (boost::function<void()> doThisWhenReady, Connection& connect_here_if_not) const
{
bool ret;
Glib::Mutex::Lock lm (_peaks_ready_lock);
*/
if (!(ret = _peaks_built)) {
- connect_here_if_not = PeaksReady.connect (doThisWhenReady);
+ PeaksReady.connect (connect_here_if_not, doThisWhenReady);
}
return ret;
_main_outs->allow_pan_reset ();
_main_outs->reset_panner ();
- scoped_connect (_output->changed, boost::bind (&Auditioner::output_changed, this, _1, _2));
+ _output->changed.connect (*this, boost::bind (&Auditioner::output_changed, this, _1, _2));
the_region.reset ((AudioRegion*) 0);
g_atomic_int_set (&_active, 0);
using namespace ARDOUR;
using namespace PBD;
-boost::signals2::signal<void(AutomationList *)> AutomationList::AutomationListCreated;
+PBD::Signal1<void,AutomationList *> AutomationList::AutomationListCreated;
#if 0
static void dumpit (const AutomationList& al, string prefix = "")
using namespace PBD;
using namespace ARDOUR;
-boost::signals2::signal<void(nframes_t)> Delivery::CycleStart;
-boost::signals2::signal<int()> Delivery::PannersLegal;
+PBD::Signal1<void,nframes_t> Delivery::CycleStart;
+PBD::Signal0<int> Delivery::PannersLegal;
bool Delivery::panners_legal = false;
/* deliver to an existing IO object */
_display_to_user = false;
if (_output) {
- scoped_connect (_output->changed, boost::bind (&Delivery::output_changed, this, _1, _2));
+ _output->changed.connect (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
}
- scoped_connect (CycleStart, boost::bind (&Delivery::cycle_start, this, _1));
+ CycleStart.connect (*this, boost::bind (&Delivery::cycle_start, this, _1));
}
/* deliver to a new IO object */
_display_to_user = false;
if (_output) {
- scoped_connect (_output->changed, boost::bind (&Delivery::output_changed, this, _1, _2));
+ _output->changed.connect (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
}
- scoped_connect (CycleStart, boost::bind (&Delivery::cycle_start, this, _1));
+ CycleStart.connect (*this, boost::bind (&Delivery::cycle_start, this, _1));
}
/* deliver to a new IO object, reconstruct from XML */
}
if (_output) {
- scoped_connect (_output->changed, boost::bind (&Delivery::output_changed, this, _1, _2));
+ _output->changed.connect (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
}
- scoped_connect (CycleStart, boost::bind (&Delivery::cycle_start, this, _1));
+ CycleStart.connect (*this, boost::bind (&Delivery::cycle_start, this, _1));
}
/* deliver to an existing IO object, reconstruct from XML */
}
if (_output) {
- scoped_connect (_output->changed, boost::bind (&Delivery::output_changed, this, _1, _2));
+ _output->changed.connect (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
}
- scoped_connect (CycleStart, boost::bind (&Delivery::cycle_start, this, _1));
+ CycleStart.connect (*this, boost::bind (&Delivery::cycle_start, this, _1));
}
std::string
}
} else {
panner_legal_c.disconnect ();
- panner_legal_c = PannersLegal.connect (boost::bind (&Delivery::panners_became_legal, this));
+ PannersLegal.connect (panner_legal_c, boost::bind (&Delivery::panners_became_legal, this));
}
}
*/
ARDOUR::nframes_t Diskstream::disk_io_chunk_frames = 1024 * 256;
-boost::signals2::signal<void()> Diskstream::DiskOverrun;
-boost::signals2::signal<void()> Diskstream::DiskUnderrun;
+PBD::Signal0<void> Diskstream::DiskOverrun;
+PBD::Signal0<void> Diskstream::DiskUnderrun;
Diskstream::Diskstream (Session &sess, const string &name, Flag flag)
: SessionObject(sess, name)
_io = _route->input();
ic_connection.disconnect();
- ic_connection = _io->changed.connect (boost::bind (&Diskstream::handle_input_change, this, _1, _2));
+ _io->changed.connect (ic_connection, boost::bind (&Diskstream::handle_input_change, this, _1, _2));
input_change_pending = ConfigurationChanged;
non_realtime_input_change ();
set_align_style_from_io ();
- scoped_connect (_route->GoingAway, boost::bind (&Diskstream::route_going_away, this));
+ _route->GoingAway.connect (*this, boost::bind (&Diskstream::route_going_away, this));
}
void
reset_write_sources (false);
}
- playlist_connections.add_connection (_playlist->Modified.connect (boost::bind (&Diskstream::playlist_modified, this)));
- playlist_connections.add_connection (_playlist->GoingAway.connect (boost::bind (&Diskstream::playlist_deleted, this, boost::weak_ptr<Playlist>(_playlist))));
- playlist_connections.add_connection (_playlist->RangesMoved.connect (boost::bind (&Diskstream::playlist_ranges_moved, this, _1)));
+ _playlist->Modified.connect (playlist_connections, boost::bind (&Diskstream::playlist_modified, this));
+ _playlist->GoingAway.connect (playlist_connections, boost::bind (&Diskstream::playlist_deleted, this, boost::weak_ptr<Playlist>(_playlist)));
+ _playlist->RangesMoved.connect (playlist_connections, boost::bind (&Diskstream::playlist_ranges_moved, this, _1));
}
/* don't do this if we've already asked for it *or* if we are setting up
using namespace PBD;
using namespace ARDOUR;
-boost::signals2::signal <std::pair<bool, string> (string, string)> ElementImporter::Rename;
-boost::signals2::signal <bool (string)> ElementImporter::Prompt;
+Signal2<std::pair<bool, string>,string, string> ElementImporter::Rename;
+Signal1 <bool,string> ElementImporter::Prompt;
ElementImporter::ElementImporter (XMLTree const & source, ARDOUR::Session & session) :
source (source),
throw ExportFailed ("Unhandled type in ExportChannelFactory constructor");
}
- export_connection = session->ProcessExport.connect (boost::bind (&RegionExportChannelFactory::new_cycle_started, this, _1));
+ session->ProcessExport.connect (export_connection, boost::bind (&RegionExportChannelFactory::new_cycle_started, this, _1));
buffers.set_count (ChanCount (DataType::AUDIO, n_channels));
buffers.ensure_buffers (DataType::AUDIO, n_channels, frames_per_cycle);
ExportFormatManager::add_compatibility (CompatPtr ptr)
{
compatibilities.push_back (ptr);
- scoped_connect (ptr->SelectChanged, boost::bind (&ExportFormatManager::change_compatibility_selection, this, _1, WeakCompatPtr (ptr)));
+ ptr->SelectChanged.connect (*this, boost::bind (&ExportFormatManager::change_compatibility_selection, this, _1, WeakCompatPtr (ptr)));
}
void
ExportFormatManager::add_quality (QualityPtr ptr)
{
- scoped_connect (ptr->SelectChanged, boost::bind (&ExportFormatManager::change_quality_selection, this, _1, WeakQualityPtr (ptr)));
+ ptr->SelectChanged.connect (*this, boost::bind (&ExportFormatManager::change_quality_selection, this, _1, WeakQualityPtr (ptr)));
qualities.push_back (ptr);
}
ExportFormatManager::add_format (FormatPtr ptr)
{
formats.push_back (ptr);
- scoped_connect (ptr->SelectChanged, boost::bind (&ExportFormatManager::change_format_selection, this, _1, WeakFormatPtr (ptr)));
+ ptr->SelectChanged.connect (*this, boost::bind (&ExportFormatManager::change_format_selection, this, _1, WeakFormatPtr (ptr)));
universal_set = universal_set->get_union (*ptr);
/* Encoding options */
boost::shared_ptr<HasSampleFormat> hsf;
if (hsf = boost::dynamic_pointer_cast<HasSampleFormat> (ptr)) {
- scoped_connect (hsf->SampleFormatSelectChanged, boost::bind (&ExportFormatManager::change_sample_format_selection, this, _1, _2));
- scoped_connect (hsf->DitherTypeSelectChanged, boost::bind (&ExportFormatManager::change_dither_type_selection, this, _1, _2));
+ hsf->SampleFormatSelectChanged.connect (*this, boost::bind (&ExportFormatManager::change_sample_format_selection, this, _1, _2));
+ hsf->DitherTypeSelectChanged.connect (*this, boost::bind (&ExportFormatManager::change_dither_type_selection, this, _1, _2));
}
}
void
ExportFormatManager::add_sample_rate (SampleRatePtr ptr)
{
- scoped_connect (ptr->SelectChanged, boost::bind (&ExportFormatManager::change_sample_rate_selection, this, _1, WeakSampleRatePtr (ptr)));
+ ptr->SelectChanged.connect (*this, boost::bind (&ExportFormatManager::change_sample_rate_selection, this, _1, WeakSampleRatePtr (ptr)));
sample_rates.push_back (ptr);
}
SampleFormatPtr ptr (new SampleFormatState (format, get_sample_format_name (format)));
sample_format_states.push_back (ptr);
- scoped_connect (ptr->SelectChanged, boost::bind (&HasSampleFormat::update_sample_format_selection, this, _1));
+ ptr->SelectChanged.connect (*this, boost::bind (&HasSampleFormat::update_sample_format_selection, this, _1));
// BOOST SIGNALS how to connect one signal to another
- // scoped_connect (ptr->SelectChanged, boost::bind (SampleFormatSelectChanged, _1, WeakSampleFormatPtr (ptr));
- // scoped_connect (ptr->CompatibleChanged, boost::bind (SampleFormatCompatibleChanged, _1, WeakSampleFormatPtr (ptr));
+ // ptr->SelectChanged.connect (*this, boost::bind (SampleFormatSelectChanged, _1, WeakSampleFormatPtr (ptr));
+ // ptr->CompatibleChanged.connect (*this, boost::bind (SampleFormatCompatibleChanged, _1, WeakSampleFormatPtr (ptr));
}
void
{
DitherTypePtr ptr (new DitherTypeState (type, name));
dither_type_states.push_back (ptr);
- scoped_connect (ptr->SelectChanged, boost::bind (&HasSampleFormat::update_dither_type_selection, this, _1));
+ ptr->SelectChanged.connect (*this, boost::bind (&HasSampleFormat::update_dither_type_selection, this, _1));
// BOOST SIGNALS how to connect one signal to another
- // scoped_connect (ptr->SelectChanged, boost::bind (DitherTypeSelectChanged, _1, WeakDitherTypePtr (ptr));
- // scoped_connect (ptr->CompatibleChanged, boost::bind (DitherTypeCompatibleChanged, _1, WeakDitherTypePtr (ptr));
+ // ptr->SelectChanged.connect (*this, boost::bind (DitherTypeSelectChanged, _1, WeakDitherTypePtr (ptr));
+ // ptr->CompatibleChanged.connect (*this, boost::bind (DitherTypeCompatibleChanged, _1, WeakDitherTypePtr (ptr));
}
HasSampleFormat::SampleFormatPtr
{
processor.reset (new ExportProcessor (session));
- files_written_connection = ExportProcessor::WritingFile.connect (boost::bind (&ExportHandler::add_file, this, _1));
+ ExportProcessor::WritingFile.connect (files_written_connection, boost::bind (&ExportHandler::add_file, this, _1));
}
ExportHandler::~ExportHandler ()
realtime = rt;
- export_read_finished_connection = session.ExportReadFinished.connect (boost::bind (&ExportHandler::finish_timespan, this));
+ session.ExportReadFinished.connect (export_read_finished_connection, boost::bind (&ExportHandler::finish_timespan, this));
start_timespan ();
}
/* connect stuff and start export */
- current_timespan->process_connection = session.ProcessExport.connect (boost::bind (&ExportTimespan::process, current_timespan, _1));
+ session.ProcessExport.connect (current_timespan->process_connection, boost::bind (&ExportTimespan::process, current_timespan, _1));
session.start_audio_export (current_timespan->get_start(), realtime);
}
cc = current_map_it->second.channel_config;
}
- channel_config_connection = cc->FilesWritten.connect (boost::bind (&ExportHandler::timespan_thread_finished, this));
+ cc->FilesWritten.connect (channel_config_connection, boost::bind (&ExportHandler::timespan_thread_finished, this));
++current_map_it;
} else { /* All files are written from current timespan, reset timespan and start new */
namespace ARDOUR
{
-boost::signals2::signal<void (const Glib::ustring&)> ExportProcessor::WritingFile;
+PBD::Signal1<void,const Glib::ustring&> ExportProcessor::WritingFile;
ExportProcessor::ExportProcessor (Session & session) :
session (session),
mix_buffers_with_gain_t ARDOUR::mix_buffers_with_gain = 0;
mix_buffers_no_gain_t ARDOUR::mix_buffers_no_gain = 0;
-boost::signals2::signal<void(std::string)> ARDOUR::BootMessage;
+PBD::Signal1<void,std::string> ARDOUR::BootMessage;
void ARDOUR::setup_enum_writer ();
using namespace std;
using namespace ARDOUR;
-boost::signals2::signal<void(nframes_t)> InternalReturn::CycleStart;
+PBD::Signal1<void,nframes_t> InternalReturn::CycleStart;
InternalReturn::InternalReturn (Session& s)
: Return (s, true)
, user_count (0)
{
- scoped_connect (CycleStart, boost::bind (&InternalReturn::cycle_start, this, _1));
+ CycleStart.connect (*this, boost::bind (&InternalReturn::cycle_start, this, _1));
}
InternalReturn::InternalReturn (Session& s, const XMLNode& node)
: Return (s, node, true)
, user_count (0)
{
- scoped_connect (CycleStart, boost::bind (&InternalReturn::cycle_start, this, _1));
+ CycleStart.connect (*this, boost::bind (&InternalReturn::cycle_start, this, _1));
}
void
set_name (sendto->name());
- scoped_connect (_send_to->GoingAway, boost::bind (&InternalSend::send_to_going_away, this));
- scoped_connect (_send_to->NameChanged, boost::bind (&InternalSend::send_to_name_changed, this));
+ _send_to->GoingAway.connect (*this, boost::bind (&InternalSend::send_to_going_away, this));
+ _send_to->NameChanged.connect (*this, boost::bind (&InternalSend::send_to_name_changed, this));
}
InternalSend::InternalSend (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
*/
if (!IO::connecting_legal) {
- connect_c = IO::ConnectingLegal.connect (boost::bind (&InternalSend::connect_when_legal, this));
+ IO::ConnectingLegal.connect (connect_c, boost::bind (&InternalSend::connect_when_legal, this));
} else {
connect_when_legal ();
}
const string IO::state_node_name = "IO";
bool IO::connecting_legal = false;
-boost::signals2::signal<int()> IO::ConnectingLegal;
-boost::signals2::signal<void(ChanCount)> IO::PortCountChanged;
+PBD::Signal0<int> IO::ConnectingLegal;
+PBD::Signal1<void,ChanCount> IO::PortCountChanged;
/** @param default_type The type of port that will be created by ensure_io
* and friends if no type is explicitly requested (to avoid breakage).
pending_state_node = new XMLNode (node);
pending_state_node_version = version;
pending_state_node_in = false;
- connection_legal_c = ConnectingLegal.connect (boost::bind (&IO::connecting_became_legal, this));
+ ConnectingLegal.connect (connection_legal_c, boost::bind (&IO::connecting_became_legal, this));
}
pending_state_node = new XMLNode (node);
pending_state_node_version = version;
pending_state_node_in = in;
- connection_legal_c = ConnectingLegal.connect (boost::bind (&IO::connecting_became_legal, this));
+ ConnectingLegal.connect (connection_legal_c, boost::bind (&IO::connecting_became_legal, this));
}
return 0;
IO::UserBundleInfo::UserBundleInfo (IO* io, boost::shared_ptr<UserBundle> b)
{
bundle = b;
- changed = b->Changed.connect (boost::bind (&IO::bundle_changed, io, _1));
+ b->Changed.connect (changed, boost::bind (&IO::bundle_changed, io, _1));
}
std::string
using namespace ARDOUR;
-boost::signals2::signal<void()> Metering::Meter;
-Glib::StaticMutex Metering::m_meter_signal_lock;
-
-boost::signals2::connection
-Metering::connect (boost::function<void()> f)
-{
- // SignalProcessor::Meter is emitted from another thread so the
- // Meter signal must be protected.
- Glib::Mutex::Lock guard (m_meter_signal_lock);
- return Meter.connect (f);
-}
-
-void
-Metering::disconnect (boost::signals2::connection& c)
-{
- Glib::Mutex::Lock guard (m_meter_signal_lock);
- c.disconnect ();
-}
-
-/**
- Update the meters.
-
- The meter signal lock is taken to prevent modification of the
- Meter signal while updating the meters, taking the meter signal
- lock prior to taking the io_lock ensures that all IO will remain
- valid while metering.
-*/
-void
-Metering::update_meters()
-{
- Glib::Mutex::Lock guard (m_meter_signal_lock);
- Meter(); /* EMIT SIGNAL */
-}
+PBD::Signal0<void> Metering::Meter;
PeakMeter::PeakMeter (Session& s, const XMLNode& node)
: Processor (s, node)
using namespace PBD;
MIDIClock_Slave::MIDIClock_Slave (Session& s, MIDI::Port& p, int ppqn)
- : port_connections (0)
- , ppqn (ppqn)
+ : ppqn (ppqn)
, bandwidth (30.0 / 60.0) // 1 BpM = 1 / 60 Hz
{
session = (ISlaveSessionProxy *) new SlaveSessionProxy(s);
MIDIClock_Slave::MIDIClock_Slave (ISlaveSessionProxy* session_proxy, int ppqn)
: session(session_proxy)
- , port_connections (0)
, ppqn (ppqn)
, bandwidth (30.0 / 60.0) // 1 BpM = 1 / 60 Hz
{
MIDIClock_Slave::~MIDIClock_Slave()
{
delete session;
- delete port_connections;
}
void
MIDIClock_Slave::rebind (MIDI::Port& p)
{
- delete port_connections;
- port_connections = new ScopedConnectionList;
-
+ port_connections.drop_connections();
+
port = &p;
#ifdef DEBUG_MIDI_CLOCK
std::cerr << "MIDIClock_Slave: connecting to port " << port->name() << std::endl;
#endif
- port_connections->add_connection (port->input()->timing.connect (boost::bind (&MIDIClock_Slave::update_midi_clock, this, _1, _2)));
- port_connections->add_connection (port->input()->start.connect (boost::bind (&MIDIClock_Slave::start, this, _1, _2)));
- port_connections->add_connection (port->input()->contineu.connect (boost::bind (&MIDIClock_Slave::contineu, this, _1, _2)));
- port_connections->add_connection (port->input()->stop.connect (boost::bind (&MIDIClock_Slave::stop, this, _1, _2)));
- port_connections->add_connection (port->input()->position.connect (boost::bind (&MIDIClock_Slave::position, this, _1, _2, 3)));
+ port->input()->timing.connect (port_connections, boost::bind (&MIDIClock_Slave::update_midi_clock, this, _1, _2));
+ port->input()->start.connect (port_connections, boost::bind (&MIDIClock_Slave::start, this, _1, _2));
+ port->input()->contineu.connect (port_connections, boost::bind (&MIDIClock_Slave::contineu, this, _1, _2));
+ port->input()->stop.connect (port_connections, boost::bind (&MIDIClock_Slave::stop, this, _1, _2));
+ port->input()->position.connect (port_connections, boost::bind (&MIDIClock_Slave::position, this, _1, _2, 3));
}
void
continue; /* XXX is this OK? */
}
- scoped_connect (region->GoingAway, boost::bind (&Diskstream::remove_region_from_last_capture, this, boost::weak_ptr<Region>(region)));
+ region->GoingAway.connect (*this, boost::bind (&Diskstream::remove_region_from_last_capture, this, boost::weak_ptr<Region>(region)));
_last_capture_regions.push_back (region);
: Region (src, start, length, PBD::basename_nosuffix(src->name()), DataType::MIDI, 0, Region::Flag(Region::DefaultFlags|Region::External))
{
assert(_name.find("/") == string::npos);
- scoped_connect (midi_source(0)->Switched, boost::bind (&MidiRegion::switch_source, this, _1));
+ midi_source(0)->Switched.connect (*this, boost::bind (&MidiRegion::switch_source, this, _1));
}
/* Basic MidiRegion constructor (one channel) */
: Region (src, start, length, name, DataType::MIDI, layer, flags)
{
assert(_name.find("/") == string::npos);
- scoped_connect (midi_source(0)->Switched, boost::bind (&MidiRegion::switch_source, this, _1));
+ midi_source(0)->Switched.connect (*this, boost::bind (&MidiRegion::switch_source, this, _1));
}
/* Basic MidiRegion constructor (many channels) */
: Region (srcs, start, length, name, DataType::MIDI, layer, flags)
{
assert(_name.find("/") == string::npos);
- scoped_connect (midi_source(0)->Switched, boost::bind (&MidiRegion::switch_source, this, _1));
+ midi_source(0)->Switched.connect (*this, boost::bind (&MidiRegion::switch_source, this, _1));
}
: Region (other, offset, length, name, layer, flags)
{
assert(_name.find("/") == string::npos);
- scoped_connect (midi_source(0)->Switched, boost::bind (&MidiRegion::switch_source, this, _1));
+ midi_source(0)->Switched.connect (*this, boost::bind (&MidiRegion::switch_source, this, _1));
}
MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other)
: Region (other)
{
assert(_name.find("/") == string::npos);
- scoped_connect (midi_source(0)->Switched, boost::bind (&MidiRegion::switch_source, this, _1));
+ midi_source(0)->Switched.connect (*this, boost::bind (&MidiRegion::switch_source, this, _1));
}
MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, const XMLNode& node)
throw failed_constructor();
}
- scoped_connect (midi_source(0)->Switched, boost::bind (&MidiRegion::switch_source, this, _1));
+ midi_source(0)->Switched.connect (*this, boost::bind (&MidiRegion::switch_source, this, _1));
assert(_name.find("/") == string::npos);
assert(_type == DataType::MIDI);
}
throw failed_constructor();
}
- scoped_connect (midi_source(0)->Switched, boost::bind (&MidiRegion::switch_source, this, _1));
+ midi_source(0)->Switched.connect (*this, boost::bind (&MidiRegion::switch_source, this, _1));
assert(_name.find("/") == string::npos);
assert(_type == DataType::MIDI);
}
using namespace ARDOUR;
using namespace PBD;
-boost::signals2::signal<void(MidiSource*)> MidiSource::MidiSourceCreated;
+PBD::Signal1<void,MidiSource*> MidiSource::MidiSourceCreated;
MidiSource::MidiSource (Session& s, string name, Source::Flag flags)
: Source(s, DataType::MIDI, name, flags)
pending_state = const_cast<XMLNode*> (&node);
if (_session.state_of_the_state() & Session::Loading) {
- scoped_connect (_session.StateReady, boost::bind (&MidiTrack::set_state_part_two, this));
+ _session.StateReady.connect (*this, boost::bind (&MidiTrack::set_state_part_two, this));
} else {
set_state_part_two ();
}
: AbstractUI<MidiUIRequest> (_("midiui"))
, _session (s)
{
- rebind_connection = MIDI::Manager::instance()->PortsChanged.connect (boost::bind (&MidiControlUI::change_midi_ports, this));
+ MIDI::Manager::instance()->PortsChanged.connect (rebind_connection, boost::bind (&MidiControlUI::change_midi_ports, this));
}
MidiControlUI::~MidiControlUI ()
MTC_Slave::MTC_Slave (Session& s, MIDI::Port& p)
: session (s)
- , port_connections (0)
{
can_notify_on_unknown_rate = true;
did_reset_tc_format = false;
MTC_Slave::~MTC_Slave()
{
- delete port_connections;
-
if (did_reset_tc_format) {
session.config.set_timecode_format (saved_tc_format);
}
void
MTC_Slave::rebind (MIDI::Port& p)
{
- delete port_connections;
- port_connections = new ScopedConnectionList;
+ port_connections.drop_connections ();
port = &p;
- port_connections->add_connection (port->input()->mtc_time.connect ( boost::bind (&MTC_Slave::update_mtc_time, this, _1, _2, _3)));
- port_connections->add_connection (port->input()->mtc_qtr.connect (boost::bind (&MTC_Slave::update_mtc_qtr, this, _1, _2, _3)));
- port_connections->add_connection (port->input()->mtc_status.connect (boost::bind (&MTC_Slave::update_mtc_status, this, _1)));
+ port->input()->mtc_time.connect (port_connections, boost::bind (&MTC_Slave::update_mtc_time, this, _1, _2, _3));
+ port->input()->mtc_qtr.connect (port_connections, boost::bind (&MTC_Slave::update_mtc_qtr, this, _1, _2, _3));
+ port->input()->mtc_status.connect (port_connections, boost::bind (&MTC_Slave::update_mtc_status, this, _1));
}
void
using namespace ARDOUR;
using namespace PBD;
-boost::signals2::signal<void(NamedSelection*)> NamedSelection::NamedSelectionCreated;
+PBD::Signal1<void,NamedSelection*> NamedSelection::NamedSelectionCreated;
typedef std::list<boost::shared_ptr<Playlist> > PlaylistList;
freeze_length = 0;
_explicit_relayering = false;
- scoped_connect (Modified, boost::bind (&Playlist::mark_session_dirty, this));
+ Modified.connect (*this, boost::bind (&Playlist::mark_session_dirty, this));
}
Playlist::~Playlist ()
}
}
- region_state_changed_connections.add_connection
- (region->StateChanged.connect (boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region))));
+ region->StateChanged.connect (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
return true;
}
using namespace ARDOUR;
using namespace PBD;
-boost::signals2::signal<void(boost::shared_ptr<Playlist>, bool)> PlaylistFactory::PlaylistCreated;
+PBD::Signal2<void,boost::shared_ptr<Playlist>, bool> PlaylistFactory::PlaylistCreated;
boost::shared_ptr<Playlist>
PlaylistFactory::create (Session& s, const XMLNode& node, bool hidden, bool unused)
using namespace ARDOUR;
using namespace PBD;
-boost::signals2::signal<void(Processor*)> Processor::ProcessorCreated;
+PBD::Signal1<void,Processor*> Processor::ProcessorCreated;
// Always saved as Processor, but may be IOProcessor or Send in legacy sessions
const string Processor::state_node_name = "Processor";
Change Region::LayerChanged = ARDOUR::new_change ();
Change Region::HiddenChanged = ARDOUR::new_change ();
-boost::signals2::signal<void(boost::shared_ptr<ARDOUR::Region>)> Region::RegionPropertyChanged;
+PBD::Signal1<void,boost::shared_ptr<ARDOUR::Region> > Region::RegionPropertyChanged;
/* derived-from-derived constructor (no sources in constructor) */
Region::Region (Session& s, nframes_t start, nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
_sources.push_back (src);
_master_sources.push_back (src);
- scoped_connect (src->GoingAway, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(src)));
+ src->GoingAway.connect (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(src)));
assert(_sources.size() > 0);
_positional_lock_style = AudioTime;
for (SourceList::const_iterator i = s.begin (); i != s.end(); ++i) {
_sources.push_back (*i);
- scoped_connect ((*i)->GoingAway, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(*i)));
+ (*i)->GoingAway.connect (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(*i)));
unique_srcs.insert (*i);
}
for (SourceList::const_iterator i = s.begin (); i != s.end(); ++i) {
_master_sources.push_back (*i);
if (unique_srcs.find (*i) == unique_srcs.end()) {
- scoped_connect ((*i)->GoingAway, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(*i)));
+ (*i)->GoingAway.connect (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(*i)));
}
}
}
using namespace ARDOUR;
using namespace PBD;
-boost::signals2::signal<void(boost::shared_ptr<Region>)> RegionFactory::CheckNewRegion;
+PBD::Signal1<void,boost::shared_ptr<Region> > RegionFactory::CheckNewRegion;
boost::shared_ptr<Region>
RegionFactory::create (boost::shared_ptr<Region> region, nframes_t start,
using namespace PBD;
uint32_t Route::order_key_cnt = 0;
-boost::signals2::signal<void(string const&)> Route::SyncOrderKeys;
+PBD::Signal1<void,string const&> Route::SyncOrderKeys;
Route::Route (Session& sess, string name, Flag flg, DataType default_type)
: SessionObject (sess, name)
/* now that we have _meter, its safe to connect to this */
- scoped_connect (Metering::Meter, (boost::bind (&Route::meter, this)));
+ Metering::Meter.connect (*this, (boost::bind (&Route::meter, this)));
}
Route::Route (Session& sess, const XMLNode& node, DataType default_type)
/* now that we have _meter, its safe to connect to this */
- scoped_connect (Metering::Meter, (boost::bind (&Route::meter, this)));
+ Metering::Meter.connect (*this, (boost::bind (&Route::meter, this)));
}
void
_input.reset (new IO (_session, _name, IO::Input, _default_type));
_output.reset (new IO (_session, _name, IO::Output, _default_type));
- scoped_connect (_input->changed, boost::bind (&Route::input_change_handler, this, _1, _2));
- scoped_connect (_output->changed, boost::bind (&Route::output_change_handler, this, _1, _2));
+ _input->changed.connect (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
+ _output->changed.connect (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
/* add amp processor */
// XXX: do we want to emit the signal here ? change call order.
processor->activate ();
}
- scoped_connect (processor->ActiveChanged, boost::bind (&Session::update_latency_compensation, &_session, false, false));
+ processor->ActiveChanged.connect (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
_output->set_user_latency (0);
}
return -1;
}
- scoped_connect ((*i)->ActiveChanged, boost::bind (&Session::update_latency_compensation, &_session, false, false));
+ (*i)->ActiveChanged.connect (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
}
_output->set_user_latency (0);
routes->push_back (r);
r->join_route_group (this);
- scoped_connect (r->GoingAway, boost::bind (&RouteGroup::remove_when_going_away, this, boost::weak_ptr<Route> (r)));
+ r->GoingAway.connect (*this, boost::bind (&RouteGroup::remove_when_going_away, this, boost::weak_ptr<Route> (r)));
_session.set_dirty ();
changed (); /* EMIT SIGNAL */
bool Session::_disable_all_loaded_plugins = false;
-boost::signals2::signal<void(std::string)> Session::Dialog;
-boost::signals2::signal<int()> Session::AskAboutPendingState;
-boost::signals2::signal<int(nframes_t,nframes_t)> Session::AskAboutSampleRateMismatch;
-boost::signals2::signal<void()> Session::SendFeedback;
-
-boost::signals2::signal<void()> Session::TimecodeOffsetChanged;
-boost::signals2::signal<void()> Session::StartTimeChanged;
-boost::signals2::signal<void()> Session::EndTimeChanged;
-boost::signals2::signal<void()> Session::AutoBindingOn;
-boost::signals2::signal<void()> Session::AutoBindingOff;
-boost::signals2::signal<void(std::string, std::string)> Session::Exported;
+PBD::Signal1<void,std::string> Session::Dialog;
+PBD::Signal0<int> Session::AskAboutPendingState;
+PBD::Signal2<int,nframes_t,nframes_t> Session::AskAboutSampleRateMismatch;
+PBD::Signal0<void> Session::SendFeedback;
+
+PBD::Signal0<void> Session::TimecodeOffsetChanged;
+PBD::Signal0<void> Session::StartTimeChanged;
+PBD::Signal0<void> Session::EndTimeChanged;
+PBD::Signal0<void> Session::AutoBindingOn;
+PBD::Signal0<void> Session::AutoBindingOff;
+PBD::Signal2<void,std::string, std::string> Session::Exported;
static void clean_up_session_event (SessionEvent* ev) { delete ev; }
const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
- scoped_connect (Config->ParameterChanged, boost::bind (&Session::config_changed, this, _1, false));
- scoped_connect (config.ParameterChanged, boost::bind (&Session::config_changed, this, _1, true));
+ Config->ParameterChanged.connect (*this, boost::bind (&Session::config_changed, this, _1, false));
+ config.ParameterChanged.connect (*this, boost::bind (&Session::config_changed, this, _1, true));
if (was_dirty) {
DirtyChanged (); /* EMIT SIGNAL */
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
- scoped_connect (Config->ParameterChanged, boost::bind (&Session::config_changed, this, _1, false));
+ Config->ParameterChanged.connect (*this, boost::bind (&Session::config_changed, this, _1, false));
}
Session::~Session ()
/* every time we reconnect, recompute worst case output latencies */
- scoped_connect (_engine.Running, boost::bind (&Session::set_worst_io_latencies, this));
+ _engine.Running.connect (*this, boost::bind (&Session::set_worst_io_latencies, this));
if (synced_to_jack()) {
_engine.transport_stop ();
boost::shared_ptr<Playlist> playlist;
if ((playlist = dstream->playlist()) != 0) {
- scoped_connect (playlist->LengthChanged, boost::bind (&Session::playlist_length_changed, this));
+ playlist->LengthChanged.connect (*this, boost::bind (&Session::playlist_length_changed, this));
}
/* see comment in playlist_length_changed () */
punch_connections.drop_connections ();
- punch_connections.add_connection (location->start_changed.connect (boost::bind (&Session::auto_punch_start_changed, this, _1)));
- punch_connections.add_connection (location->end_changed.connect (boost::bind (&Session::auto_punch_end_changed, this, _1)));
- punch_connections.add_connection (location->changed.connect (boost::bind (&Session::auto_punch_changed, this, _1)));
+ location->start_changed.connect (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
+ location->end_changed.connect (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
+ location->changed.connect (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
location->set_auto_punch (true, this);
loop_connections.drop_connections ();
- loop_connections.add_connection (location->start_changed.connect (boost::bind (&Session::auto_loop_changed, this, _1)));
- loop_connections.add_connection (location->end_changed.connect (boost::bind (&Session::auto_loop_changed, this, _1)));
- loop_connections.add_connection (location->changed.connect (boost::bind (&Session::auto_loop_changed, this, _1)));
+ location->start_changed.connect (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
+ location->end_changed.connect (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
+ location->changed.connect (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
location->set_auto_loop (true, this);
route_group->add (track);
}
- scoped_connect (track->DiskstreamChanged, boost::bind (&Session::resort_routes, this));
+ track->DiskstreamChanged.connect (*this, boost::bind (&Session::resort_routes, this));
//track->set_remote_control_id (control_id);
new_routes.push_back (track);
track->audio_diskstream()->non_realtime_input_change();
- scoped_connect (track->DiskstreamChanged, boost::bind (&Session::resort_routes, this));
+ track->DiskstreamChanged.connect (*this, boost::bind (&Session::resort_routes, this));
track->set_remote_control_id (control_id);
++control_id;
boost::weak_ptr<Route> wpr (*x);
- scoped_connect ((*x)->listen_changed, boost::bind (&Session::route_listen_changed, this, _1, wpr));
- scoped_connect ((*x)->solo_changed, boost::bind (&Session::route_solo_changed, this, _1, wpr));
- scoped_connect ((*x)->mute_changed, boost::bind (&Session::route_mute_changed, this, _1));
- scoped_connect ((*x)->output()->changed, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
- scoped_connect ((*x)->processors_changed, boost::bind (&Session::route_processors_changed, this, _1));
- scoped_connect ((*x)->route_group_changed, boost::bind (&Session::route_group_changed, this));
+ (*x)->listen_changed.connect (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
+ (*x)->solo_changed.connect (*this, boost::bind (&Session::route_solo_changed, this, _1, wpr));
+ (*x)->mute_changed.connect (*this, boost::bind (&Session::route_mute_changed, this, _1));
+ (*x)->output()->changed.connect (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
+ (*x)->processors_changed.connect (*this, boost::bind (&Session::route_processors_changed, this, _1));
+ (*x)->route_group_changed.connect (*this, boost::bind (&Session::route_group_changed, this));
if ((*x)->is_master()) {
_master_out = (*x);
/* writer goes out of scope, copies ds back to main */
}
- scoped_connect (dstream->PlaylistChanged, boost::bind (&Session::diskstream_playlist_changed, this, boost::weak_ptr<Diskstream> (dstream)));
+ dstream->PlaylistChanged.connect (*this, boost::bind (&Session::diskstream_playlist_changed, this, boost::weak_ptr<Diskstream> (dstream)));
/* this will connect to future changes, and check the current length */
diskstream_playlist_changed (boost::weak_ptr<Diskstream> (dstream));
- scoped_connect (dstream->RecordEnableChanged, boost::bind (&Session::update_have_rec_enabled_diskstream, this));
+ dstream->RecordEnableChanged.connect (*this, boost::bind (&Session::update_have_rec_enabled_diskstream, this));
dstream->prepare ();
}
}
- scoped_connect (region->StateChanged, boost::bind (&Session::region_changed, this, _1, boost::weak_ptr<Region>(region)));
- scoped_connect (region->GoingAway, boost::bind (&Session::remove_region, this, boost::weak_ptr<Region>(region)));
+ region->StateChanged.connect (*this, boost::bind (&Session::region_changed, this, _1, boost::weak_ptr<Region>(region)));
+ region->GoingAway.connect (*this, boost::bind (&Session::remove_region, this, boost::weak_ptr<Region>(region)));
update_region_name_map (region);
}
}
if (result.second) {
- scoped_connect (source->GoingAway, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
+ source->GoingAway.connect (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
set_dirty();
}
bool existing = playlists->add (playlist);
if (!existing) {
-
scoped_connect (playlist->GoingAway, boost::bind (&Session::remove_playlist, this, boost::weak_ptr<Playlist>(playlist)));
+
playlist->GoingAway.connect (*this, boost::bind (&Session::remove_playlist, this, boost::weak_ptr<Playlist>(playlist)));
}
if (unused) {
void
Session::add_processor (Processor* processor)
{
- scoped_connect (processor->GoingAway, boost::bind (&Session::remove_processor, this, processor));
+ processor->GoingAway.connect (*this, boost::bind (&Session::remove_processor, this, processor));
set_dirty();
}
_exporting = true;
export_status->running = true;
- scoped_connect (export_status->Aborting, boost::bind (&Session::stop_audio_export, this));
- scoped_connect (export_status->Finished, boost::bind (&Session::finalize_audio_export, this));
+ export_status->Aborting.connect (*this, boost::bind (&Session::stop_audio_export, this));
+ export_status->Finished.connect (*this, boost::bind (&Session::finalize_audio_export, this));
return 0;
}
last_process_function = process_function;
process_function = &Session::process_export;
} else {
- export_freewheel_connection = _engine.Freewheel.connect (boost::bind (&Session::process_export_fw, this, _1));
+ _engine.Freewheel.connect (export_freewheel_connection, boost::bind (&Session::process_export_fw, this, _1));
return _engine.freewheel (true);
}
: _session (s)
{
if (_session) {
- _session_connections.add_connection (_session->GoingAway.connect (boost::bind (&SessionHandlePtr::session_going_away, this)));
+ _session->GoingAway.connect (_session_connections, boost::bind (&SessionHandlePtr::session_going_away, this));
}
}
if (s) {
_session = s;
- _session_connections.add_connection (_session->GoingAway.connect (boost::bind (&SessionHandlePtr::session_going_away, this)));
+ _session->GoingAway.connect (_session_connections, boost::bind (&SessionHandlePtr::session_going_away, this));
}
}
SessionHandleRef::SessionHandleRef (Session& s)
: _session (s)
{
- scoped_connect (_session.GoingAway, boost::bind (&SessionHandleRef::session_going_away, this));
+ _session.GoingAway.connect (*this, boost::bind (&SessionHandleRef::session_going_away, this));
}
void
mmc->set_send_device_id (old_send_device_id);
}
- scoped_connect (mmc->Play, boost::bind (&Session::mmc_deferred_play, this, _1));
- scoped_connect (mmc->DeferredPlay, boost::bind (&Session::mmc_deferred_play, this, _1));
- scoped_connect (mmc->Stop, boost::bind (&Session::mmc_stop, this, _1));
- scoped_connect (mmc->FastForward, boost::bind (&Session::mmc_fast_forward, this, _1));
- scoped_connect (mmc->Rewind, boost::bind (&Session::mmc_rewind, this, _1));
- scoped_connect (mmc->Pause, boost::bind (&Session::mmc_pause, this, _1));
- scoped_connect (mmc->RecordPause, boost::bind (&Session::mmc_record_pause, this, _1));
- scoped_connect (mmc->RecordStrobe, boost::bind (&Session::mmc_record_strobe, this, _1));
- scoped_connect (mmc->RecordExit, boost::bind (&Session::mmc_record_exit, this, _1));
- scoped_connect (mmc->Locate, boost::bind (&Session::mmc_locate, this, _1, _2));
- scoped_connect (mmc->Step, boost::bind (&Session::mmc_step, this, _1, _2));
- scoped_connect (mmc->Shuttle, boost::bind (&Session::mmc_shuttle, this, _1, _2, _3));
- scoped_connect (mmc->TrackRecordStatusChange, boost::bind (&Session::mmc_record_enable, this, _1, _2, _3));
+ mmc->Play.connect (*this, boost::bind (&Session::mmc_deferred_play, this, _1));
+ mmc->DeferredPlay.connect (*this, boost::bind (&Session::mmc_deferred_play, this, _1));
+ mmc->Stop.connect (*this, boost::bind (&Session::mmc_stop, this, _1));
+ mmc->FastForward.connect (*this, boost::bind (&Session::mmc_fast_forward, this, _1));
+ mmc->Rewind.connect (*this, boost::bind (&Session::mmc_rewind, this, _1));
+ mmc->Pause.connect (*this, boost::bind (&Session::mmc_pause, this, _1));
+ mmc->RecordPause.connect (*this, boost::bind (&Session::mmc_record_pause, this, _1));
+ mmc->RecordStrobe.connect (*this, boost::bind (&Session::mmc_record_strobe, this, _1));
+ mmc->RecordExit.connect (*this, boost::bind (&Session::mmc_record_exit, this, _1));
+ mmc->Locate.connect (*this, boost::bind (&Session::mmc_locate, this, _1, _2));
+ mmc->Step.connect (*this, boost::bind (&Session::mmc_step, this, _1, _2));
+ mmc->Shuttle.connect (*this, boost::bind (&Session::mmc_shuttle, this, _1, _2, _3));
+ mmc->TrackRecordStatusChange.connect (*this, boost::bind (&Session::mmc_record_enable, this, _1, _2, _3));
/* also handle MIDI SPP because its so common */
- scoped_connect (_mmc_port->input()->start, boost::bind (&Session::spp_start, this, _1, _2));
- scoped_connect (_mmc_port->input()->contineu, boost::bind (&Session::spp_continue, this, _1, _2));
- scoped_connect (_mmc_port->input()->stop, boost::bind (&Session::spp_stop, this, _1, _2));
+ _mmc_port->input()->start.connect (*this, boost::bind (&Session::spp_start, this, _1, _2));
+ _mmc_port->input()->contineu.connect (*this, boost::bind (&Session::spp_continue, this, _1, _2));
+ _mmc_port->input()->stop.connect (*this, boost::bind (&Session::spp_stop, this, _1, _2));
Config->set_mmc_port_name (port_tag);
if (!existing) {
playlists.insert (playlists.begin(), playlist);
-
scoped_connect (playlist->InUse, boost::bind (&SessionPlaylists::track, this, _1, boost::weak_ptr<Playlist>(playlist)));
+
playlist->InUse.connect (*this, boost::bind (&SessionPlaylists::track, this, _1, boost::weak_ptr<Playlist>(playlist)));
}
return existing;
_base_frame_rate = _current_frame_rate;
_tempo_map = new TempoMap (_current_frame_rate);
- scoped_connect (_tempo_map->StateChanged, boost::bind (&Session::tempo_map_changed, this, _1));
+ _tempo_map->StateChanged.connect (*this, boost::bind (&Session::tempo_map_changed, this, _1));
_non_soloed_outs_muted = false;
delta_accumulator_cnt = 0;
_slave_state = Stopped;
- scoped_connect (_engine.GraphReordered, boost::bind (&Session::graph_reordered, this));
+ _engine.GraphReordered.connect (*this, boost::bind (&Session::graph_reordered, this));
/* These are all static "per-class" signals */
- scoped_connect (RegionFactory::CheckNewRegion, boost::bind (&Session::add_region, this, _1));
- scoped_connect (SourceFactory::SourceCreated, boost::bind (&Session::add_source, this, _1));
- scoped_connect (PlaylistFactory::PlaylistCreated, boost::bind (&Session::add_playlist, this, _1, _2));
- scoped_connect (Processor::ProcessorCreated, boost::bind (&Session::add_processor, this, _1));
- scoped_connect (NamedSelection::NamedSelectionCreated, boost::bind (&Session::add_named_selection, this, _1));
- scoped_connect (AutomationList::AutomationListCreated, boost::bind (&Session::add_automation_list, this, _1));
+ RegionFactory::CheckNewRegion.connect (*this, boost::bind (&Session::add_region, this, _1));
+ SourceFactory::SourceCreated.connect (*this, boost::bind (&Session::add_source, this, _1));
+ PlaylistFactory::PlaylistCreated.connect (*this, boost::bind (&Session::add_playlist, this, _1, _2));
+ Processor::ProcessorCreated.connect (*this, boost::bind (&Session::add_processor, this, _1));
+ NamedSelection::NamedSelectionCreated.connect (*this, boost::bind (&Session::add_named_selection, this, _1));
+ AutomationList::AutomationListCreated.connect (*this, boost::bind (&Session::add_automation_list, this, _1));
// BOOST SIGNALS
- // scoped_connect (Controllable::Destroyed, boost::bind (&Session::remove_controllable, this, _1));
+ // Controllable::Destroyed.connect (*this, boost::bind (&Session::remove_controllable, this, _1));
- scoped_connect (IO::PortCountChanged, boost::bind (&Session::ensure_buffers, this, _1));
+ IO::PortCountChanged.connect (*this, boost::bind (&Session::ensure_buffers, this, _1));
/* stop IO objects from doing stuff until we're ready for them */
_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave|Loading);
- scoped_connect (_locations.changed, boost::bind (&Session::locations_changed, this));
- scoped_connect (_locations.added, boost::bind (&Session::locations_added, this, _1));
+ _locations.changed.connect (*this, boost::bind (&Session::locations_changed, this));
+ _locations.added.connect (*this, boost::bind (&Session::locations_added, this, _1));
setup_click_sounds (0);
setup_midi_control ();
/* Pay attention ... */
- scoped_connect (_engine.Halted, boost::bind (&Session::engine_halted, this));
- scoped_connect (_engine.Xrun, boost::bind (&Session::xrun_recovery, this));
+ _engine.Halted.connect (*this, boost::bind (&Session::engine_halted, this));
+ _engine.Xrun.connect (*this, boost::bind (&Session::xrun_recovery, this));
try {
when_engine_running();
_timeline_position = header_position_offset;
}
- AudioFileSource::HeaderPositionOffsetChanged.connect (
- boost::bind (&SndFileSource::handle_header_position_change, this));
+ AudioFileSource::HeaderPositionOffsetChanged.connect (header_position_connection, boost::bind (&SndFileSource::handle_header_position_change, this));
}
int
using namespace std;
using namespace PBD;
-boost::signals2::signal<void(boost::shared_ptr<Source>)> SourceFactory::SourceCreated;
+PBD::Signal1<void,boost::shared_ptr<Source> > SourceFactory::SourceCreated;
Glib::Cond* SourceFactory::PeaksToBuild;
Glib::StaticMutex SourceFactory::peak_building_lock = GLIBMM_STATIC_MUTEX_INIT;
std::list<boost::weak_ptr<AudioSource> > SourceFactory::files_with_peaks;
SessionHandlePtr::set_session (s);
if (_session) {
- _session_connections.add_connection (_session->tick.connect (boost::bind (&Ticker::tick, this, _1, _2, _3)));
+ _session->tick.connect (_session_connections, boost::bind (&Ticker::tick, this, _1, _2, _3));
}
}
Ticker::set_session (s);
if (_session) {
- _session_connections.add_connection (_session->MIDIClock_PortChanged.connect (boost::bind (&MidiClockTicker::update_midi_clock_port, this)));
- _session_connections.add_connection (_session->TransportStateChange.connect (boost::bind (&MidiClockTicker::transport_state_changed, this)));
- _session_connections.add_connection (_session->PositionChanged.connect (boost::bind (&MidiClockTicker::position_changed, this, _1)));
- _session_connections.add_connection (_session->TransportLooped.connect (boost::bind (&MidiClockTicker::transport_looped, this)));
+ _session->MIDIClock_PortChanged.connect (_session_connections, boost::bind (&MidiClockTicker::update_midi_clock_port, this));
+ _session->TransportStateChange.connect (_session_connections, boost::bind (&MidiClockTicker::transport_state_changed, this));
+ _session->PositionChanged.connect (_session_connections, boost::bind (&MidiClockTicker::position_changed, this, _1));
+ _session->TransportLooped.connect (_session_connections, boost::bind (&MidiClockTicker::transport_looped, this));
update_midi_clock_port();
}
}
}
prompter->set_text (prompt);
prompter->touch (); // shows popup
- learning_connection = controllable->LearningFinished.connect (boost::bind (&BindingProxy::learning_finished, this));
+ controllable->LearningFinished.connect (learning_connection, boost::bind (&BindingProxy::learning_finished, this));
}
return true;
}
void
Channel::connect_input_signals ()
{
- add_connection (_port.input()->channel_pressure[_channel_number].connect
- (boost::bind (&Channel::process_chanpress, this, _1, _2)));
- add_connection (_port.input()->channel_note_on[_channel_number].connect
- (boost::bind (&Channel::process_note_on, this, _1, _2)));
- add_connection (_port.input()->channel_note_off[_channel_number].connect
- (boost::bind (&Channel::process_note_off, this, _1, _2)));
- add_connection (_port.input()->channel_poly_pressure[_channel_number].connect
- (boost::bind (&Channel::process_polypress, this, _1, _2)));
- add_connection (_port.input()->channel_program_change[_channel_number].connect
- (boost::bind (&Channel::process_program_change, this, _1, _2)));
- add_connection (_port.input()->channel_controller[_channel_number].connect
- (boost::bind (&Channel::process_controller, this, _1, _2)));
- add_connection (_port.input()->channel_pitchbend[_channel_number].connect
- (boost::bind (&Channel::process_pitchbend, this, _1, _2)));
-
- add_connection (_port.input()->reset.connect (boost::bind (&Channel::process_reset, this, _1)));
+ _port.input()->channel_pressure[_channel_number].connect (*this, boost::bind (&Channel::process_chanpress, this, _1, _2));
+ _port.input()->channel_note_on[_channel_number].connect (*this, boost::bind (&Channel::process_note_on, this, _1, _2));
+ _port.input()->channel_note_off[_channel_number].connect (*this, boost::bind (&Channel::process_note_off, this, _1, _2));
+ _port.input()->channel_poly_pressure[_channel_number].connect (*this, boost::bind (&Channel::process_polypress, this, _1, _2));
+ _port.input()->channel_program_change[_channel_number].connect (*this, boost::bind (&Channel::process_program_change, this, _1, _2));
+ _port.input()->channel_controller[_channel_number].connect (*this, boost::bind (&Channel::process_controller, this, _1, _2));
+ _port.input()->channel_pitchbend[_channel_number].connect (*this, boost::bind (&Channel::process_pitchbend, this, _1, _2));
+
+ _port.input()->reset.connect (*this, boost::bind (&Channel::process_reset, this, _1));
}
void
Channel::connect_output_signals ()
{
- add_connection (_port.output()->channel_pressure[_channel_number].connect
- (boost::bind (&Channel::process_chanpress, this, _1, _2)));
- add_connection (_port.output()->channel_note_on[_channel_number].connect
- (boost::bind (&Channel::process_note_on, this, _1, _2)));
- add_connection (_port.output()->channel_note_off[_channel_number].connect
- (boost::bind (&Channel::process_note_off, this, _1, _2)));
- add_connection (_port.output()->channel_poly_pressure[_channel_number].connect
- (boost::bind (&Channel::process_polypress, this, _1, _2)));
- add_connection (_port.output()->channel_program_change[_channel_number].connect
- (boost::bind (&Channel::process_program_change, this, _1, _2)));
- add_connection (_port.output()->channel_controller[_channel_number].connect
- (boost::bind (&Channel::process_controller, this, _1, _2)));
- add_connection (_port.output()->channel_pitchbend[_channel_number].connect
- (boost::bind (&Channel::process_pitchbend, this, _1, _2)));
-
- add_connection (_port.output()->reset.connect (boost::bind (&Channel::process_reset, this, _1)));
+ _port.output()->channel_pressure[_channel_number].connect (*this, boost::bind (&Channel::process_chanpress, this, _1, _2));
+ _port.output()->channel_note_on[_channel_number].connect (*this, boost::bind (&Channel::process_note_on, this, _1, _2));
+ _port.output()->channel_note_off[_channel_number].connect (*this, boost::bind (&Channel::process_note_off, this, _1, _2));
+ _port.output()->channel_poly_pressure[_channel_number].connect (*this, boost::bind (&Channel::process_polypress, this, _1, _2));
+ _port.output()->channel_program_change[_channel_number].connect (*this, boost::bind (&Channel::process_program_change, this, _1, _2));
+ _port.output()->channel_controller[_channel_number].connect (*this, boost::bind (&Channel::process_controller, this, _1, _2));
+ _port.output()->channel_pitchbend[_channel_number].connect (*this, boost::bind (&Channel::process_pitchbend, this, _1, _2));
+
+ _port.output()->reset.connect (*this, boost::bind (&Channel::process_reset, this, _1));
}
void
#include <queue>
-#include <boost/signals2.hpp>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "midi++/types.h"
#include "midi++/parser.h"
int get_known_ports (std::vector<PortSet>&);
- boost::signals2::signal<void()> PortsChanged;
+ PBD::Signal0<void> PortsChanged;
private:
/* This is a SINGLETON pattern */
#ifndef __midipp_mmc_h_h__
#define __midipp_mmc_h_h__
-#include <boost/signals2.hpp>
-
+#include "pbd/signals.h"
#include "midi++/types.h"
namespace MIDI {
class MachineControl
{
public:
- typedef boost::signals2::signal<void(MachineControl&)> MMCSignal;
+ typedef PBD::Signal1<void,MachineControl&> MMCSignal;
typedef byte CommandSignature[60];
typedef byte ResponseSignature[60];
true if the direction is "forwards", false for "reverse"
*/
- boost::signals2::signal<void(MachineControl&,float,bool)> Shuttle;
+ PBD::Signal3<void,MachineControl&,float,bool> Shuttle;
/* The second argument specifies the desired track record enabled
status.
*/
- boost::signals2::signal<void(MachineControl &,size_t,bool)>
+ PBD::Signal3<void,MachineControl &,size_t,bool>
TrackRecordStatusChange;
/* The second argument specifies the desired track record enabled
status.
*/
- boost::signals2::signal<void(MachineControl &,size_t,bool)>
+ PBD::Signal3<void,MachineControl &,size_t,bool>
TrackMuteChange;
/* The second argument points to a byte array containing
format (5 bytes, roughly: hrs/mins/secs/frames/subframes)
*/
- boost::signals2::signal<void(MachineControl &, const byte *)> Locate;
+ PBD::Signal2<void,MachineControl &, const byte *> Locate;
/* The second argument is the number of steps to jump */
- boost::signals2::signal<void(MachineControl &, int)> Step;
+ PBD::Signal2<void,MachineControl &, int> Step;
protected:
MIDI::Port &_port;
void process_mmc_message (Parser &p, byte *, size_t len);
- boost::signals2::scoped_connection mmc_connection;
+ PBD::ScopedConnection mmc_connection;
int do_masked_write (byte *, size_t len);
int do_locate (byte *, size_t len);
#include <string>
#include <iostream>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include "midi++/types.h"
class Port;
class Parser;
-typedef boost::signals2::signal<void(Parser&)> ZeroByteSignal;
-typedef boost::signals2::signal<void(Parser&,nframes_t)> TimestampedSignal;
-typedef boost::signals2::signal<void(Parser&, byte)> OneByteSignal;
-typedef boost::signals2::signal<void(Parser &, EventTwoBytes *)> TwoByteSignal;
-typedef boost::signals2::signal<void(Parser &, pitchbend_t)> PitchBendSignal;
-typedef boost::signals2::signal<void(Parser &, byte *, size_t)> Signal;
+typedef PBD::Signal1<void,Parser&> ZeroByteSignal;
+typedef PBD::Signal2<void,Parser&,nframes_t> TimestampedSignal;
+typedef PBD::Signal2<void,Parser&, byte> OneByteSignal;
+typedef PBD::Signal2<void,Parser &, EventTwoBytes *> TwoByteSignal;
+typedef PBD::Signal2<void,Parser &, pitchbend_t> PitchBendSignal;
+typedef PBD::Signal3<void,Parser &, byte *, size_t> Signal;
class Parser {
public:
void set_offline (bool);
bool offline() const { return _offline; }
- boost::signals2::signal<void()> OfflineStatusChanged;
+ PBD::Signal0<void> OfflineStatusChanged;
- boost::signals2::signal<int(byte *, size_t)> edit;
+ PBD::Signal2<int,byte *, size_t> edit;
void set_mmc_forwarding (bool yn) {
_mmc_forward = yn;
const byte *mtc_current() const { return _mtc_time; }
bool mtc_locked() const { return _mtc_locked; }
- boost::signals2::signal<void(Parser&,int,nframes_t)> mtc_qtr;
- boost::signals2::signal<void(const byte*,bool,nframes_t)> mtc_time;
- boost::signals2::signal<void(MTC_Status)> mtc_status;
- boost::signals2::signal<bool()> mtc_skipped;
+ PBD::Signal3<void,Parser&,int,nframes_t> mtc_qtr;
+ PBD::Signal3<void,const byte*,bool,nframes_t> mtc_time;
+ PBD::Signal1<void,MTC_Status> mtc_status;
+ PBD::Signal0<bool> mtc_skipped;
void set_mtc_forwarding (bool yn) {
_mtc_forward = yn;
std::ostream *trace_stream;
std::string trace_prefix;
void trace_event (Parser &p, byte *msg, size_t len);
- boost::signals2::scoped_connection trace_connection;
+ PBD::ScopedConnection trace_connection;
size_t message_counter[256];
#include <string>
#include <iostream>
-#include <boost/signals2.hpp>
#include "pbd/xml++.h"
#include "midi++/types.h"
_send_device_id = 0x7f;
if ((parser = _port.input()) != 0) {
- mmc_connection = parser->mmc.connect (boost::bind (&MachineControl::process_mmc_message, this, _1, _2, _3));
+ parser->mmc.connect (mmc_connection, boost::bind (&MachineControl::process_mmc_message, this, _1, _2, _3));
} else {
warning << "MMC connected to a non-input port: useless!"
<< endmsg;
cerr << "enabling tracing for port " << _port.name() << endl;
trace_stream = o;
trace_prefix = prefix;
- trace_connection = any.connect (boost::bind (&Parser::trace_event, this, _1, _2, _3));
+ any.connect (trace_connection, boost::bind (&Parser::trace_event, this, _1, _2, _3));
} else {
trace_prefix = "";
trace_stream = 0;
using namespace PBD;
using namespace std;
-boost::signals2::signal<void(Controllable*)> Controllable::Destroyed;
-boost::signals2::signal<bool(Controllable*)> Controllable::StartLearning;
-boost::signals2::signal<void(Controllable*)> Controllable::StopLearning;
-boost::signals2::signal<void(Controllable*,int,int)> Controllable::CreateBinding;
-boost::signals2::signal<void(Controllable*)> Controllable::DeleteBinding;
+PBD::Signal1<void,Controllable*> Controllable::Destroyed;
+PBD::Signal1<bool,Controllable*> Controllable::StartLearning;
+PBD::Signal1<void,Controllable*> Controllable::StopLearning;
+PBD::Signal3<void,Controllable*,int,int> Controllable::CreateBinding;
+PBD::Signal1<void,Controllable*> Controllable::DeleteBinding;
Glib::StaticRWLock Controllable::registry_lock = GLIBMM_STATIC_RW_LOCK_INIT;
Controllable::Controllables Controllable::registry;
Controllable::ControllablesByURI Controllable::registry_by_uri;
+PBD::ScopedConnectionList registry_connections;
Controllable::Controllable (const string& name, const string& uri)
: _name (name)
/* Controllable::remove() is static - no need to manage this connection */
- ctl.GoingAway.connect (boost::bind (&Controllable::remove, ref (ctl)));
+ ctl.GoingAway.connect (registry_connections, boost::bind (&Controllable::remove, ref (ctl)));
}
void
#include <set>
#include <map>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include <glibmm/thread.h>
#include "pbd/statefuldestructible.h"
virtual void set_value (float) = 0;
virtual float get_value (void) const = 0;
- boost::signals2::signal<void()> LearningFinished;
- static boost::signals2::signal<void(PBD::Controllable*,int,int)> CreateBinding;
- static boost::signals2::signal<void(PBD::Controllable*)> DeleteBinding;
+ PBD::Signal0<void> LearningFinished;
+ static PBD::Signal3<void,PBD::Controllable*,int,int> CreateBinding;
+ static PBD::Signal1<void,PBD::Controllable*> DeleteBinding;
- static boost::signals2::signal<bool(PBD::Controllable*)> StartLearning;
- static boost::signals2::signal<void(PBD::Controllable*)> StopLearning;
+ static PBD::Signal1<bool,PBD::Controllable*> StartLearning;
+ static PBD::Signal1<void,PBD::Controllable*> StopLearning;
- static boost::signals2::signal<void(Controllable*)> Destroyed;
+ static PBD::Signal1<void,Controllable*> Destroyed;
- boost::signals2::signal<void()> Changed;
+ PBD::Signal0<void> Changed;
int set_state (const XMLNode&, int version);
XMLNode& get_state ();
#ifndef __pbd_destructible_h__
#define __pbd_destructible_h__
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
namespace PBD {
Destructible() : refs_dropped (false){}
virtual ~Destructible () {}
- boost::signals2::signal<void ()> GoingAway;
+ PBD::Signal0<void> GoingAway;
void drop_references () { if (!refs_dropped) { GoingAway(); } refs_dropped = true; }
private:
: obj(a_object), before(a_before), after(a_after)
{
/* if the object dies, make sure that we die and that everyone knows about it */
- obj_death_connection = obj.GoingAway.connect (boost::bind (&MementoCommand::object_died, this));
+ obj.GoingAway.connect (obj_death_connection, boost::bind (&MementoCommand::object_died, this));
}
~MementoCommand () {
obj_T& obj;
XMLNode* before;
XMLNode* after;
- boost::signals2::scoped_connection obj_death_connection;
+ PBD::ScopedConnection obj_death_connection;
};
#endif // __lib_pbd_memento_h__
+++ /dev/null
-/*
- Copyright (C) 2009 Paul Davis
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- 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.
-
-*/
-
-#ifndef __pbd_scoped_connections_h__
-#define __pbd_scoped_connections_h__
-
-#include <list>
-#include <glibmm/thread.h>
-#include <boost/signals2.hpp>
-
-#include "pbd/destructible.h"
-
-namespace PBD {
-
-class ScopedConnectionList
-{
- public:
- ScopedConnectionList();
- ~ScopedConnectionList ();
-
- void add_connection (const boost::signals2::connection& c);
- void drop_connections ();
-
- template<typename S> void scoped_connect (S& sig, const typename S::slot_function_type& sf) {
- add_connection (sig.connect (sf));
- }
-
- private:
- /* this class is not copyable */
- ScopedConnectionList(const ScopedConnectionList&) {}
-
- /* this lock is shared by all instances of a ScopedConnectionList.
- We do not want one mutex per list, and since we only need the lock
- when adding or dropping connections, which are generally occuring
- in object creation and UI operations, the contention on this
- lock is low and not of significant consequence. Even though
- boost::signals2 is thread-safe, this additional list of
- scoped connections needs to be protected in 2 cases:
-
- (1) (unlikely) we make a connection involving a callback on the
- same object from 2 threads. (wouldn't that just be appalling
- programming style?)
-
- (2) where we are dropping connections in one thread and adding
- one from another.
- */
-
- static Glib::StaticMutex _lock;
-
- typedef std::list<boost::signals2::scoped_connection*> ConnectionList;
- ConnectionList _list;
-};
-
-} /* namespace */
-
-#endif /* __pbd_scoped_connections_h__ */
--- /dev/null
+/*
+ Copyright (C) 2009 Paul Davis
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ 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.
+
+*/
+
+#ifndef __pbd_signals_h__
+#define __pbd_signals_h__
+
+#include <list>
+#include <glibmm/thread.h>
+#include <boost/signals2.hpp>
+#include <boost/noncopyable.hpp>
+
+namespace PBD {
+
+typedef boost::signals2::connection UnscopedConnection;
+typedef boost::signals2::connection Connection;
+typedef boost::signals2::scoped_connection ScopedConnection;
+
+class ScopedConnectionList : public boost::noncopyable
+{
+ public:
+ ScopedConnectionList();
+ ~ScopedConnectionList ();
+
+ void add_connection (const UnscopedConnection& c);
+ void drop_connections ();
+
+ template<typename S> void scoped_connect (S& sig, const typename S::slot_function_type& sf) {
+ add_connection (sig.connect (sf));
+ }
+
+ private:
+ /* this class is not copyable */
+ ScopedConnectionList(const ScopedConnectionList&) {}
+
+ /* this lock is shared by all instances of a ScopedConnectionList.
+ We do not want one mutex per list, and since we only need the lock
+ when adding or dropping connections, which are generally occuring
+ in object creation and UI operations, the contention on this
+ lock is low and not of significant consequence. Even though
+ boost::signals2 is thread-safe, this additional list of
+ scoped connections needs to be protected in 2 cases:
+
+ (1) (unlikely) we make a connection involving a callback on the
+ same object from 2 threads. (wouldn't that just be appalling
+ programming style?)
+
+ (2) where we are dropping connections in one thread and adding
+ one from another.
+ */
+
+ static Glib::StaticMutex _lock;
+
+ typedef std::list<ScopedConnection*> ConnectionList;
+ ConnectionList _list;
+};
+
+template<typename R>
+class Signal0 {
+public:
+ Signal0 () {}
+ typedef boost::signals2::signal<R()> SignalType;
+
+ void connect (ScopedConnectionList& clist,
+ const typename SignalType::slot_function_type& slot) {
+ clist.add_connection (_signal.connect (slot));
+ }
+
+ void connect (Connection& c,
+ const typename SignalType::slot_function_type& slot) {
+ c = _signal.connect (slot);
+ }
+
+ typename SignalType::result_type operator()() {
+ return _signal ();
+ }
+
+private:
+ SignalType _signal;
+};
+
+template<typename R, typename A>
+class Signal1 {
+public:
+ Signal1 () {}
+ typedef boost::signals2::signal<R(A)> SignalType;
+
+ void connect (ScopedConnectionList& clist,
+ const typename SignalType::slot_function_type& slot) {
+ clist.add_connection (_signal.connect (slot));
+ }
+
+ void connect (Connection& c,
+ const typename SignalType::slot_function_type& slot) {
+ c = _signal.connect (slot);
+ }
+
+ typename SignalType::result_type operator()(A arg1) {
+ return _signal (arg1);
+ }
+
+private:
+ SignalType _signal;
+};
+
+template<typename R, typename A1, typename A2>
+class Signal2 {
+public:
+ Signal2 () {}
+ typedef boost::signals2::signal<R(A1, A2)> SignalType;
+
+ void connect (ScopedConnectionList& clist,
+ const typename SignalType::slot_function_type& slot) {
+ clist.add_connection (_signal.connect (slot));
+ }
+
+ void connect (Connection& c,
+ const typename SignalType::slot_function_type& slot) {
+ c = _signal.connect (slot);
+ }
+
+ typename SignalType::result_type operator()(A1 arg1, A2 arg2) {
+ return _signal (arg1, arg2);
+ }
+
+private:
+ SignalType _signal;
+};
+
+template<typename R, typename A1, typename A2, typename A3>
+class Signal3 {
+public:
+ Signal3 () {}
+ typedef boost::signals2::signal<R(A1,A2,A3)> SignalType;
+
+ void connect (ScopedConnectionList& clist,
+ const typename SignalType::slot_function_type& slot) {
+ clist.add_connection (_signal.connect (slot));
+ }
+
+ void connect (Connection& c,
+ const typename SignalType::slot_function_type& slot) {
+ c = _signal.connect (slot);
+ }
+
+ typename SignalType::result_type operator()(A1 arg1, A2 arg2, A3 arg3) {
+ return _signal (arg1, arg2, arg3);
+ }
+
+private:
+ SignalType _signal;
+};
+
+} /* namespace */
+
+#endif /* __pbd_signals_h__ */
#include <sigc++/bind.h>
#include <sys/time.h>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "pbd/command.h"
typedef sigc::slot<void> UndoAction;
void set_depth (uint32_t);
- boost::signals2::signal<void()> Changed;
+ PBD::Signal0<void> Changed;
private:
bool _clearing;
+++ /dev/null
-/*
- Copyright (C) 2009 Paul Davis
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- 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.
-
-*/
-
-#include "pbd/scoped_connections.h"
-
-using namespace PBD;
-
-Glib::StaticMutex ScopedConnectionList::_lock = GLIBMM_STATIC_MUTEX_INIT;
-
-ScopedConnectionList::ScopedConnectionList()
-{
-}
-
-ScopedConnectionList::~ScopedConnectionList()
-{
- drop_connections ();
-}
-
-void
-ScopedConnectionList::add_connection (const boost::signals2::connection& c)
-{
- Glib::Mutex::Lock lm (_lock);
- _list.push_back (new boost::signals2::scoped_connection (c));
-}
-
-void
-ScopedConnectionList::drop_connections ()
-{
- Glib::Mutex::Lock lm (_lock);
-
- for (ConnectionList::iterator i = _list.begin(); i != _list.end(); ++i) {
- delete *i;
- }
-
- _list.clear ();
-}
-
--- /dev/null
+/*
+ Copyright (C) 2009 Paul Davis
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ 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.
+
+*/
+
+#include "pbd/signals.h"
+
+using namespace PBD;
+
+Glib::StaticMutex ScopedConnectionList::_lock = GLIBMM_STATIC_MUTEX_INIT;
+
+ScopedConnectionList::ScopedConnectionList()
+{
+}
+
+ScopedConnectionList::~ScopedConnectionList()
+{
+ drop_connections ();
+}
+
+void
+ScopedConnectionList::add_connection (const UnscopedConnection& c)
+{
+ Glib::Mutex::Lock lm (_lock);
+ _list.push_back (new ScopedConnection (c));
+}
+
+void
+ScopedConnectionList::drop_connections ()
+{
+ Glib::Mutex::Lock lm (_lock);
+
+ for (ConnectionList::iterator i = _list.begin(); i != _list.end(); ++i) {
+ delete *i;
+ }
+
+ _list.clear ();
+}
+
so there is no need to manage this connection.
*/
- scoped_connect (action->GoingAway, boost::bind (&command_death, this, action));
+ action->GoingAway.connect (*this, boost::bind (&command_death, this, action));
actions.push_back (action);
}
{
uint32_t current_depth = UndoList.size();
- scoped_connect (ut->GoingAway, boost::bind (&UndoHistory::remove, this, ut));
+ ut->GoingAway.connect (*this, boost::bind (&UndoHistory::remove, this, ut));
/* if the current undo history is larger than or equal to the currently
requested depth, then pop off at least 1 element to make space
pool.cc
pthread_utils.cc
receiver.cc
- scoped_connections.cc
search_path.cc
shortpath.cc
+ signals.cc
stacktrace.cc
stateful.cc
strreplace.cc
using namespace ARDOUR;
using ARDOUR::nframes_t;
-sigc::signal<void,std::string,std::string> BasicUI::AccessAction;
+PBD::Signal2<void,std::string,std::string> BasicUI::AccessAction;
BasicUI::BasicUI (Session& s)
: session (&s)
using namespace ARDOUR;
using namespace std;
-sigc::signal<void> ControlProtocol::ZoomToSession;
-sigc::signal<void> ControlProtocol::ZoomOut;
-sigc::signal<void> ControlProtocol::ZoomIn;
-sigc::signal<void> ControlProtocol::Enter;
-sigc::signal<void,float> ControlProtocol::ScrollTimeline;
+PBD::Signal0<void> ControlProtocol::ZoomToSession;
+PBD::Signal0<void> ControlProtocol::ZoomOut;
+PBD::Signal0<void> ControlProtocol::ZoomIn;
+PBD::Signal0<void> ControlProtocol::Enter;
+PBD::Signal1<void,float> ControlProtocol::ScrollTimeline;
ControlProtocol::ControlProtocol (Session& s, string str)
: BasicUI (s),
_name (str)
{
_active = false;
- session->RouteAdded.connect (mem_fun(*this, &ControlProtocol::add_strip));
+ session->RouteAdded.connect (*this, boost::bind (&ControlProtocol::add_strip, this, _1));
}
ControlProtocol::~ControlProtocol ()
#define __ardour_basic_ui_h__
#include <string>
-
+#include "pbd/signals.h"
#include <jack/types.h>
void loop_toggle ();
void access_action ( std::string action_path );
- static sigc::signal<void,std::string,std::string> AccessAction;
+ static PBD::Signal2<void,std::string,std::string> AccessAction;
void goto_start ();
void goto_end ();
void rewind ();
#include <vector>
#include <list>
#include <boost/shared_ptr.hpp>
-#include <sigc++/sigc++.h>
-#include <pbd/stateful.h>
+#include "pbd/stateful.h"
+#include "pbd/signals.h"
#include "control_protocol/basic_ui.h"
namespace ARDOUR {
class Route;
class Session;
-class ControlProtocol : virtual public sigc::trackable, public PBD::Stateful, public BasicUI {
+class ControlProtocol : virtual public sigc::trackable, public PBD::Stateful, public PBD::ScopedConnectionList, public BasicUI {
public:
ControlProtocol (Session&, std::string name);
virtual ~ControlProtocol();
virtual void route_list_changed () {}
- sigc::signal<void> ActiveChanged;
+ PBD::Signal0<void> ActiveChanged;
/* signals that a control protocol can emit and other (presumably graphical)
user interfaces can respond to
*/
- static sigc::signal<void> ZoomToSession;
- static sigc::signal<void> ZoomIn;
- static sigc::signal<void> ZoomOut;
- static sigc::signal<void> Enter;
- static sigc::signal<void,float> ScrollTimeline;
+ static PBD::Signal0<void> ZoomToSession;
+ static PBD::Signal0<void> ZoomIn;
+ static PBD::Signal0<void> ZoomOut;
+ static PBD::Signal0<void> Enter;
+ static PBD::Signal1<void,float> ScrollTimeline;
/* the model here is as follows:
void next_track (uint32_t initial_id);
void prev_track (uint32_t initial_id);
+
+ private:
+ ControlProtocol (const ControlProtocol&) {} /* noncopyable */
};
extern "C" {
auto_binding = FALSE;
- Controllable::StartLearning.connect (mem_fun (*this, &GenericMidiControlProtocol::start_learning));
- Controllable::StopLearning.connect (mem_fun (*this, &GenericMidiControlProtocol::stop_learning));
- Session::SendFeedback.connect (mem_fun (*this, &GenericMidiControlProtocol::send_feedback));
-
- Controllable::CreateBinding.connect (mem_fun (*this, &GenericMidiControlProtocol::create_binding));
- Controllable::DeleteBinding.connect (mem_fun (*this, &GenericMidiControlProtocol::delete_binding));
-
- Session::AutoBindingOn.connect (mem_fun (*this, &GenericMidiControlProtocol::auto_binding_on));
- Session::AutoBindingOff.connect (mem_fun (*this, &GenericMidiControlProtocol::auto_binding_off));
+ Controllable::StartLearning.connect (*this, boost::bind (&GenericMidiControlProtocol::start_learning, this, _1));
+ Controllable::StopLearning.connect (*this, boost::bind (&GenericMidiControlProtocol::stop_learning, this, _1));
+ Controllable::CreateBinding.connect (*this, boost::bind (&GenericMidiControlProtocol::create_binding, this, _1, _2, _3));
+ Controllable::DeleteBinding.connect (*this, boost::bind (&GenericMidiControlProtocol::delete_binding, this, _1));
+
+ Session::SendFeedback.connect (*this, boost::bind (&GenericMidiControlProtocol::send_feedback, this));
+ Session::AutoBindingOn.connect (*this, boost::bind (&GenericMidiControlProtocol::auto_binding_on, this));
+ Session::AutoBindingOff.connect (*this, boost::bind (&GenericMidiControlProtocol::auto_binding_off, this));
}
GenericMidiControlProtocol::~GenericMidiControlProtocol ()
control_type = none;
_control_description = "MIDI Control: none";
control_additional = (byte) -1;
- connections = 0;
feedback = true; // for now
/* use channel 0 ("1") as the initial channel */
our existing event + type information.
*/
- if (connections > 0) {
- midi_sense_connection[0].disconnect ();
- }
-
- if (connections > 1) {
- midi_sense_connection[1].disconnect ();
- }
+ midi_sense_connection[0].disconnect ();
+ midi_sense_connection[1].disconnect ();
+ midi_learn_connection.disconnect ();
+}
- connections = 0;
+void
+MIDIControllable::drop_external_control ()
+{
+ midi_sense_connection[0].disconnect ();
+ midi_sense_connection[1].disconnect ();
midi_learn_connection.disconnect ();
+ control_type = none;
+ control_additional = (byte) -1;
}
void
MIDIControllable::learn_about_external_control ()
{
drop_external_control ();
- midi_learn_connection = _port.input()->any.connect (boost::bind (&MIDIControllable::midi_receiver, this, _1, _2, _3));
+ _port.input()->any.connect (midi_learn_connection, boost::bind (&MIDIControllable::midi_receiver, this, _1, _2, _3));
}
void
midi_learn_connection.disconnect ();
}
-void
-MIDIControllable::drop_external_control ()
-{
- if (connections > 0) {
- midi_sense_connection[0].disconnect ();
- }
- if (connections > 1) {
- midi_sense_connection[1].disconnect ();
- }
-
- connections = 0;
- midi_learn_connection.disconnect ();
-
- control_type = none;
- control_additional = (byte) -1;
-}
-
float
MIDIControllable::control_to_midi(float val)
{
int chn_i = chn;
switch (ev) {
case MIDI::off:
- midi_sense_connection[0] = p.channel_note_off[chn_i].connect
- (boost::bind (&MIDIControllable::midi_sense_note_off, this, _1, _2));
+ p.channel_note_off[chn_i].connect (midi_sense_connection[0], boost::bind (&MIDIControllable::midi_sense_note_off, this, _1, _2));
/* if this is a bistate, connect to noteOn as well,
and we'll toggle back and forth between the two.
*/
if (bistate) {
- midi_sense_connection[1] = p.channel_note_on[chn_i].connect
- (boost::bind (&MIDIControllable::midi_sense_note_on, this, _1, _2));
- connections = 2;
- } else {
- connections = 1;
- }
+ p.channel_note_on[chn_i].connect (midi_sense_connection[1], boost::bind (&MIDIControllable::midi_sense_note_on, this, _1, _2));
+ }
+
_control_description = "MIDI control: NoteOff";
break;
case MIDI::on:
- midi_sense_connection[0] = p.channel_note_on[chn_i].connect
- (boost::bind (&MIDIControllable::midi_sense_note_on, this, _1, _2));
+ p.channel_note_on[chn_i].connect (midi_sense_connection[0], boost::bind (&MIDIControllable::midi_sense_note_on, this, _1, _2));
if (bistate) {
- midi_sense_connection[1] = p.channel_note_off[chn_i].connect
- (boost::bind (&MIDIControllable::midi_sense_note_off, this, _1, _2));
- connections = 2;
- } else {
- connections = 1;
+ p.channel_note_off[chn_i].connect (midi_sense_connection[1], boost::bind (&MIDIControllable::midi_sense_note_off, this, _1, _2));
}
_control_description = "MIDI control: NoteOn";
break;
case MIDI::controller:
- midi_sense_connection[0] = p.channel_controller[chn_i].connect
- (boost::bind (&MIDIControllable::midi_sense_controller, this, _1, _2));
- connections = 1;
+ p.channel_controller[chn_i].connect (midi_sense_connection[0], boost::bind (&MIDIControllable::midi_sense_controller, this, _1, _2));
snprintf (buf, sizeof (buf), "MIDI control: Controller %d", control_additional);
_control_description = buf;
break;
case MIDI::program:
if (!bistate) {
- midi_sense_connection[0] = p.channel_program_change[chn_i].connect
- (boost::bind (&MIDIControllable::midi_sense_program_change, this, _1, _2));
- connections = 1;
+ p.channel_program_change[chn_i].connect (midi_sense_connection[0], boost::bind (&MIDIControllable::midi_sense_program_change, this, _1, _2));
_control_description = "MIDI control: ProgramChange";
}
break;
case MIDI::pitchbend:
if (!bistate) {
- midi_sense_connection[0] = p.channel_pitchbend[chn_i].connect
- (boost::bind (&MIDIControllable::midi_sense_pitchbend, this, _1, _2));
- connections = 1;
+ p.channel_pitchbend[chn_i].connect (midi_sense_connection[0], boost::bind (&MIDIControllable::midi_sense_pitchbend, this, _1, _2));
_control_description = "MIDI control: Pitchbend";
}
break;
#include <string>
-#include <boost/signals2.hpp>
-
#include "midi++/types.h"
+
#include "pbd/controllable.h"
+#include "pbd/signals.h"
#include "pbd/stateful.h"
+
#include "ardour/types.h"
namespace MIDI {
MIDI::byte last_value;
bool bistate;
int midi_msg_id; /* controller ID or note number */
- boost::signals2::connection midi_sense_connection[2];
- boost::signals2::connection midi_learn_connection;
- size_t connections;
+ PBD::ScopedConnection midi_sense_connection[2];
+ PBD::ScopedConnection midi_learn_connection;
MIDI::eventType control_type;
MIDI::byte control_additional;
MIDI::channel_t control_channel;
#include <vector>
#include <string>
-#include <boost/signals2.hpp>
+#include "pbd/signals.h"
#include "mackie_control_exception.h"
virtual unsigned int in_use_timeout() { return _in_use_timeout; }
/// Keep track of the timeout so it can be updated with more incoming events
- boost::signals2::scoped_connection in_use_connection;
+ PBD::ScopedConnection in_use_connection;
private:
int _id;
void MackieControlProtocol::connect_session_signals()
{
// receive routes added
- session_connections.add_connection (session->RouteAdded.connect(boost::bind (&MackieControlProtocol::notify_route_added, this, _1)));
+ session->RouteAdded.connect(session_connections, boost::bind (&MackieControlProtocol::notify_route_added, this, _1));
// receive record state toggled
- session_connections.add_connection (session->RecordStateChanged.connect(boost::bind (&MackieControlProtocol::notify_record_state_changed, this)));
+ session->RecordStateChanged.connect(session_connections, boost::bind (&MackieControlProtocol::notify_record_state_changed, this));
// receive transport state changed
- session_connections.add_connection (session->TransportStateChange.connect(boost::bind (&MackieControlProtocol::notify_transport_state_changed, this)));
+ session->TransportStateChange.connect(session_connections, boost::bind (&MackieControlProtocol::notify_transport_state_changed, this));
// receive punch-in and punch-out
- session_connections.add_connection (Config->ParameterChanged.connect(boost::bind (&MackieControlProtocol::notify_parameter_changed, this, _1)));
- session_connections.add_connection (session->config.ParameterChanged.connect (boost::bind (&MackieControlProtocol::notify_parameter_changed, this, _1)));
+ Config->ParameterChanged.connect(session_connections, boost::bind (&MackieControlProtocol::notify_parameter_changed, this, _1));
+ session->config.ParameterChanged.connect (session_connections, boost::bind (&MackieControlProtocol::notify_parameter_changed, this, _1));
// receive rude solo changed
- session_connections.add_connection (session->SoloActive.connect(boost::bind (&MackieControlProtocol::notify_solo_active_changed, this, _1)));
+ session->SoloActive.connect(session_connections, boost::bind (&MackieControlProtocol::notify_solo_active_changed, this, _1));
// make sure remote id changed signals reach here
// see also notify_route_added
Sorted sorted = get_sorted_routes();
for ( Sorted::iterator it = sorted.begin(); it != sorted.end(); ++it )
{
- session_connections.add_connection ((*it)->RemoteControlIDChanged.connect (boost::bind(&MackieControlProtocol::notify_remote_id_changed, this)));
+ ((*it)->RemoteControlIDChanged.connect (route_connections, boost::bind(&MackieControlProtocol::notify_remote_id_changed, this)));
}
}
MackiePort * sport = new MackiePort( *this, midi_port, number );
_ports.push_back( sport );
- port_connections.add_connection (sport->init_event.connect (boost::bind (&MackieControlProtocol::handle_port_init, this, sport)));
- port_connections.add_connection (sport->active_event.connect (boost::bind (&MackieControlProtocol::handle_port_active, this, sport)));
- port_connections.add_connection (sport->inactive_event.connect (boost::bind (&MackieControlProtocol::handle_port_inactive, this, sport)));
-
+ sport->init_event.connect (port_connections, boost::bind (&MackieControlProtocol::handle_port_init, this, sport));
+ sport->active_event.connect (port_connections, boost::bind (&MackieControlProtocol::handle_port_active, this, sport));
+ sport->inactive_event.connect (port_connections, boost::bind (&MackieControlProtocol::handle_port_inactive, this, sport));
+
_ports_changed = true;
}
}
// Connect events. Must be after route table otherwise there will be trouble
for( MackiePorts::iterator it = _ports.begin(); it != _ports.end(); ++it ) {
- port_connections.add_connection ((*it)->control_event.connect(boost::bind (&MackieControlProtocol::handle_control_event, this, _1, _2, _3)));
+ (*it)->control_event.connect (port_connections, boost::bind (&MackieControlProtocol::handle_control_event, this, _1, _2, _3));
}
}
typedef ARDOUR::RouteList ARS;
for (ARS::iterator it = rl.begin(); it != rl.end(); ++it) {
- route_connections.add_connection ((*it)->RemoteControlIDChanged.connect (boost::bind (&MackieControlProtocol::notify_remote_id_changed, this)));
+ (*it)->RemoteControlIDChanged.connect (route_connections, boost::bind (&MackieControlProtocol::notify_remote_id_changed, this));
}
}
#ifdef PORT_DEBUG
cout << "MackiePort::open " << *this << endl;
#endif
- _sysex = port().input()->sysex.connect (boost::bind (&MackiePort::handle_midi_sysex, this, _1, _2, _3));
+ port().input()->sysex.connect (sysex_connection, boost::bind (&MackiePort::handle_midi_sysex, this, _1, _2, _3));
// make sure the device is connected
init();
#endif
// disconnect signals
- _any.disconnect();
- _sysex.disconnect();
+ any_connection.disconnect();
+ sysex_connection.disconnect();
// TODO emit a "closing" signal?
#ifdef PORT_DEBUG
void MackiePort::connect_any()
{
-/*
- Doesn't work because there isn't an == operator for slots
- MIDI::Signal::slot_list_type slots = port().input()->any.slots();
-
- if ( find( slots.begin(), slots.end(), mem_fun( *this, &MackiePort::handle_midi_any ) ) == slots.end() )
-*/
- // TODO but this will break if midi tracing is turned on
- if ( port().input()->any.empty() )
- {
-#ifdef DEBUG
- cout << "connect input parser " << port().input() << " to handle_midi_any" << endl;
-#endif
- _any = port().input()->any.connect (boost::bind (&MackiePort::handle_midi_any, this, _1, _2, _3));
-#ifdef DEBUG
- cout << "input parser any connections: " << port().input()->any.size() << endl;
-#endif
- }
- else
- {
- cout << "MackiePort::connect_any already connected" << endl;
+ if (!any_connection.connected()) {
+ port().input()->any.connect (any_connection, boost::bind (&MackiePort::handle_midi_any, this, _1, _2, _3));
}
}
#ifndef mackie_port_h
#define mackie_port_h
-#include "surface_port.h"
-
#include <midi++/types.h>
-#include <boost/signals2.hpp>
-
#include <glibmm/thread.h>
+#include "pbd/signals.h"
+
+#include "surface_port.h"
#include "midi_byte_array.h"
#include "types.h"
private:
MackieControlProtocol & _mcp;
port_type_t _port_type;
- boost::signals2::scoped_connection _any;
- boost::signals2::scoped_connection _sysex;
+ PBD::ScopedConnection any_connection;
+ PBD::ScopedConnection sysex_connection;
emulation_t _emulation;
bool _initialising;
void RouteSignal::connect()
{
if (_strip.has_solo()) {
- connections.add_connection (_route->solo_control()->Changed.connect(boost::bind (&MackieControlProtocol::notify_solo_changed, &_mcp, this)));
+ _route->solo_control()->Changed.connect(connections, boost::bind (&MackieControlProtocol::notify_solo_changed, &_mcp, this));
}
if (_strip.has_mute()) {
- connections.add_connection (_route->mute_control()->Changed.connect(boost::bind (&MackieControlProtocol::notify_mute_changed, &_mcp, this)));
+ _route->mute_control()->Changed.connect(connections, boost::bind (&MackieControlProtocol::notify_mute_changed, &_mcp, this));
}
if (_strip.has_gain()) {
- connections.add_connection (_route->gain_control()->Changed.connect(boost::bind (&MackieControlProtocol::notify_gain_changed, &_mcp, this, false)));
+ _route->gain_control()->Changed.connect(connections, boost::bind (&MackieControlProtocol::notify_gain_changed, &_mcp, this, false));
}
- connections.add_connection (_route->NameChanged.connect (boost::bind (&MackieControlProtocol::notify_name_changed, &_mcp, this)));
+ _route->NameChanged.connect (connections, boost::bind (&MackieControlProtocol::notify_name_changed, &_mcp, this));
if (_route->panner()) {
- connections.add_connection (_route->panner()->Changed.connect(boost::bind (&MackieControlProtocol::notify_panner_changed, &_mcp, this, false)));
+ _route->panner()->Changed.connect(connections, boost::bind (&MackieControlProtocol::notify_panner_changed, &_mcp, this, false));
for ( unsigned int i = 0; i < _route->panner()->npanners(); ++i ) {
- connections.add_connection (_route->panner()->streampanner(i).Changed.connect (boost::bind (&MackieControlProtocol::notify_panner_changed, &_mcp, this, false)));
+ _route->panner()->streampanner(i).Changed.connect (connections, boost::bind (&MackieControlProtocol::notify_panner_changed, &_mcp, this, false));
}
}
boost::shared_ptr<Track> trk = boost::dynamic_pointer_cast<ARDOUR::Track>(_route);
if (trk) {
- connections.add_connection (trk->rec_enable_control()->Changed .connect(boost::bind (&MackieControlProtocol::notify_record_enable_changed, &_mcp, this)));
+ trk->rec_enable_control()->Changed .connect(connections, boost::bind (&MackieControlProtocol::notify_record_enable_changed, &_mcp, this));
}
// TODO this works when a currently-banked route is made inactive, but not
// when a route is activated which should be currently banked.
- connections.add_connection (_route->active_changed.connect (boost::bind (&MackieControlProtocol::notify_active_changed, &_mcp, this)));
-
+ _route->active_changed.connect (connections, boost::bind (&MackieControlProtocol::notify_active_changed, &_mcp, this));
+
// TODO
// SelectedChanged
// RemoteControlIDChanged. Better handled at Session level.
#include <vector>
#include <boost/shared_ptr.hpp>
-#include "pbd/scoped_connections.h"
+#include "pbd/signals.h"
#include "midi_byte_array.h"
#ifndef surface_port_h
#define surface_port_h
-#include <boost/signals2.hpp>
#include <glibmm/thread.h>
+#include "pbd/signals.h"
#include "midi_byte_array.h"
#include "types.h"
const MIDI::Port & port() const { return *_port; }
// all control notofications are sent from here
- boost::signals2::signal<void(SurfacePort &, Control &, const ControlState &)> control_event;
+ PBD::Signal3<void,SurfacePort &, Control &, const ControlState &> control_event;
// emitted just before the port goes into initialisation
// where it tries to establish that its device is connected
- boost::signals2::signal<void()> init_event;
+ PBD::Signal0<void> init_event;
// emitted when the port completes initialisation successfully
- boost::signals2::signal<void()> active_event;
+ PBD::Signal0<void> active_event;
// emitted when the port goes inactive (ie a read or write failed)
- boost::signals2::signal<void()> inactive_event;
+ PBD::Signal0<void> inactive_event;
// the port number - master is 0(extenders are 1((,4
virtual int number() const { return _number; }
// "Application Hooks"
session_loaded (s);
- scoped_connect (session->Exported, boost::bind (&OSC::session_exported, this, _1, _2));
+ session->Exported.connect (*this, boost::bind (&OSC::session_exported, this, _1, _2));
}
OSC::~OSC()
*/
if (!route_exists) {
- scoped_connect (route->GoingAway, (boost::bind (&OSC::drop_route, this, boost::weak_ptr<Route> (route))));
+ route->GoingAway.connect (*this, boost::bind (&OSC::drop_route, this, boost::weak_ptr<Route> (route)));
}
}
#include <glibmm/main.h>
#include "pbd/abstract_ui.h"
-#include "pbd/scoped_connections.h"
#include "ardour/types.h"
#include "control_protocol/control_protocol.h"
~OSCUIRequest() {}
};
-class OSC : public ARDOUR::ControlProtocol, public PBD::ScopedConnectionList, public AbstractUI<OSCUIRequest>
+class OSC : public ARDOUR::ControlProtocol, public AbstractUI<OSCUIRequest>
{
public:
OSC (ARDOUR::Session&, uint32_t port);
, addr (a)
, path (p)
{
- c->Changed.connect (mem_fun (*this, &OSCControllable::send_change));
+ c->Changed.connect (changed_connection, mem_fun (*this, &OSCControllable::send_change));
}
OSCControllable::~OSCControllable ()
protected:
boost::shared_ptr<PBD::Controllable> controllable;
+ PBD::ScopedConnection changed_connection;
lo_address addr;
std::string path;
projects / ardour.git / commitdiff