using namespace Gtk;
using namespace Gdk;
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace std;
using namespace Gtk;
using namespace Glib;
-using namespace sigc;
using namespace PBD;
using namespace ARDOUR;
#include "i18n.h"
using namespace Gtk;
-using namespace sigc;
using namespace std;
using namespace PBD;
using namespace ARDOUR;
using namespace Gtk;
using namespace Gtkmm2ext;
-using namespace sigc;
using namespace std;
using namespace PBD;
using namespace ARDOUR;
#include "utils.h"
using namespace std;
-using namespace sigc;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace sigc;
ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
UIConfiguration *ARDOUR_UI::ui_config = 0;
update_sample_rate (engine->frame_rate());
Config->ParameterChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::parameter_changed));
- Config->map_parameters (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);
/* now start and maybe save state */
using namespace Gtkmm2ext;
using namespace Gtk;
using namespace Glib;
-using namespace sigc;
int
ARDOUR_UI::setup_windows ()
void
ARDOUR_UI::auditioning_changed (bool onoff)
{
- UI::instance()->call_slot(sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::_auditioning_changed), onoff));
+ UI::instance()->call_slot (boost::bind (&ARDOUR_UI::_auditioning_changed, this, onoff));
}
void
void
ARDOUR_UI::editor_realized ()
{
- Config->map_parameters (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);
set_size_request_to_display_given_text (speed_display_box, _("-0.55"), 2, 2);
reset_dpi ();
#include "opts.h"
#include "i18n.h"
-using namespace sigc;
using namespace Gtk;
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
using namespace Glib;
-using namespace sigc;
int
ARDOUR_UI::create_editor ()
using namespace Gtkmm2ext;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
void
ARDOUR_UI::toggle_external_sync()
ARDOUR_UI::setup_session_options ()
{
session->config.ParameterChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::parameter_changed));
- session->config.map_parameters (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);
}
#if 0
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace std;
using namespace Gtkmm2ext;
#define MUTED_ALPHA 10
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
void
AudioRegionView::peaks_ready_handler (uint32_t which)
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::bind (sigc::mem_fun(*this, &AudioRegionView::create_one_wave), which, false));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&AudioRegionView::create_one_wave, this, which, false));
// cerr << "AudioRegionView::peaks_ready_handler() called on " << which << " this: " << this << endl;
}
void
AutomationController::value_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (
- sigc::mem_fun(*this, &AutomationController::display_effective_value));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&AutomationController::display_effective_value, this));
}
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
{
if (!update_pending) {
update_pending = true;
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun(*this, &AutomationLine::reset));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&AutomationLine::reset, this));
}
}
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gnome; // for Canvas
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
-using namespace sigc;
using namespace Editing;
using Gtkmm2ext::Keyboard;
#include "canvas_impl.h"
#include "ardour_ui.h"
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
#endif
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
loc->set_name (_("Punch"));
}
- Config->map_parameters (sigc::mem_fun (*this, &Editor::parameter_changed));
- session->config.map_parameters (sigc::mem_fun (*this, &Editor::parameter_changed));
+ boost::function<void (string)> pc (boost::bind (&Editor::parameter_changed, this, _1));
+ Config->map_parameters (pc);
+ session->config.map_parameters (pc);
session->StateSaved.connect (sigc::mem_fun(*this, &Editor::session_state_saved));
using namespace Gtk;
using namespace Glib;
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace Editing;
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
#include "i18n.h"
-using namespace sigc;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
#include "editor_component.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
EditorComponent::EditorComponent (Editor* e)
void
EditorComponent::session_going_away ()
{
- for (list<connection>::iterator i = _session_connections.begin(); i != _session_connections.end(); ++i) {
+ for (list<sigc::connection>::iterator i = _session_connections.begin(); i != _session_connections.end(); ++i) {
i->disconnect ();
}
#include "utils.h"
#include "editor.h"
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
using namespace Editing;
using namespace ArdourCanvas;
}
else
{
- Gtkmm2ext::UI::instance()->call_slot(sigc::bind(sigc::mem_fun(*this, &Editor::handle_new_imageframe_time_axis_view),track_name, src)) ;
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&Editor::handle_new_imageframe_time_axis_view, this,track_name, src));
}
}
// Can we only sigc::bind 2 data Items?
// @todo we really want to sigc::bind the src attribute too, for the moment tracks can only be added remotely,
// so this is not too much of an issue, however will need to be looked at again
- Gtkmm2ext::UI::instance()->call_slot(sigc::bind(sigc::mem_fun(*this, &Editor::handle_new_imageframe_marker_time_axis_view),track_name, marked_track)) ;
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&Editor::handle_new_imageframe_marker_time_axis_view, this, track_name, marked_track));
}
void
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
void
Editor::keyboard_selection_finish (bool add)
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
using namespace Editing;
using Gtkmm2ext::Keyboard;
#include "i18n.h"
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace Editing;
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
}
void
-EditorRegions::selection_mapover (slot<void,boost::shared_ptr<Region> > sl)
+EditorRegions::selection_mapover (sigc::slot<void,boost::shared_ptr<Region> > sl)
{
Glib::RefPtr<TreeSelection> selection = _display.get_selection();
TreeView::Selection::ListHandle_Path rows = selection->get_selected_rows ();
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
#include "i18n.h"
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
*/
void
-Editor::mapover_tracks (slot<void, RouteTimeAxisView&, uint32_t> sl, TimeAxisView* basis, RouteGroup::Property prop) const
+Editor::mapover_tracks (sigc::slot<void, RouteTimeAxisView&, uint32_t> sl, TimeAxisView* basis, RouteGroup::Property prop) const
{
RouteTimeAxisView* route_basis = dynamic_cast<RouteTimeAxisView*> (basis);
if (route_basis == 0) {
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
void
Editor::handle_new_named_selection ()
{
- ARDOUR_UI::instance()->call_slot (sigc::mem_fun(*this, &Editor::redisplay_named_selections));
+ ARDOUR_UI::instance()->call_slot (boost::bind (&Editor::redisplay_named_selections, this));
}
void
#include "prompter.h"
using namespace std;
-using namespace sigc;
using namespace PBD;
using namespace Gtk;
using namespace ARDOUR;
#include "keyboard.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using Gtkmm2ext::Keyboard;
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace sigc;
using namespace std;
using Gtkmm2ext::Keyboard;
void
GainMeterBase::gain_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun(*this, &GainMeterBase::effective_gain_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&GainMeterBase::effective_gain_display, this));
}
void
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace sigc;
GenericPluginUI::GenericPluginUI (boost::shared_ptr<PluginInsert> pi, bool scrollable)
: PlugUIBase (pi),
{
if (!cui->update_pending) {
cui->update_pending = true;
- Gtkmm2ext::UI::instance()->call_slot (sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::update_control_display), cui));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&GenericPluginUI::update_control_display, this, cui));
}
}
using namespace std;
using namespace ardourvis ;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
/**
#include "canvas_impl.h"
#include "gui_thread.h"
-using namespace sigc ;
using namespace ARDOUR ;
using namespace Gtk;
#include <jack/jack.h>
using namespace std;
-using namespace sigc;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace Glib;
using namespace PBD;
using namespace Gtk;
using namespace Gtkmm2ext;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace sigc;
using namespace std;
//sigc::signal<void> LevelMeter::ResetAllPeakDisplays;
using namespace ARDOUR_COMMAND_LINE;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
TextReceiver text_receiver ("ardour");
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
//---------------------------------------------------------------------------------------//
#include "marker_view.h"
using namespace ARDOUR ;
-using namespace sigc;
sigc::signal<void,MarkerView*> MarkerView::GoingAway;
using namespace std;
using namespace Gtk;
-using namespace sigc;
using namespace ARDOUR;
MidiChannelSelector::MidiChannelSelector(int n_rows, int n_columns, int start_row, int start_column)
using namespace PBD;
using namespace Gtk;
using namespace Gtkmm2ext;
-using namespace sigc;
static const char* mode_strings[] = { "duplex", "output", "input", (char*) 0 };
#include "i18n.h"
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
-using namespace sigc;
using namespace Editing;
// Minimum height at which a control is displayed
#include "i18n.h"
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
void
MixerStrip::diskstream_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun(*this, &MixerStrip::update_diskstream_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&MixerStrip::update_diskstream_display, this));
}
void
MixerStrip::input_changed (IOChange /*change*/, void */*src*/)
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun(*this, &MixerStrip::update_input_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&MixerStrip::update_input_display, this));
set_width_enum (_width, this);
}
void
MixerStrip::output_changed (IOChange /*change*/, void */*src*/)
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun(*this, &MixerStrip::update_output_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&MixerStrip::update_output_display, this));
set_width_enum (_width, this);
}
using namespace Gtk;
using namespace Glib;
using namespace Gtkmm2ext;
-using namespace sigc;
using namespace std;
using PBD::atoi;
using namespace Gtk;
using namespace std;
-using namespace sigc;
using namespace Glib;
void
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace Gtk;
using namespace ARDOUR;
add_widget_to_page (p, _box);
}
-BoolOption::BoolOption (string const & i, string const & n, slot<bool> g, slot<bool, bool> s)
+BoolOption::BoolOption (string const & i, string const & n, sigc::slot<bool> g, sigc::slot<bool, bool> s)
: Option (i, n),
_get (g),
_set (s)
_set (_button->get_active ());
}
-EntryOption::EntryOption (string const & i, string const & n, slot<string> g, slot<bool, string> s)
+EntryOption::EntryOption (string const & i, string const & n, sigc::slot<string> g, sigc::slot<bool, string> s)
: Option (i, n),
_get (g),
_set (s)
using namespace std;
using namespace Gtk;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using Gtkmm2ext::Keyboard;
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace sigc;
const int PannerUI::pan_bar_height = 30;
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace sigc;
PluginUIWindow::PluginUIWindow (Gtk::Window* win, boost::shared_ptr<PluginInsert> insert, bool scrollable)
: parent (win)
#include "gui_thread.h"
using namespace std;
-using namespace sigc;
using namespace Gtk;
using namespace ARDOUR;
void
PortMatrix::reconnect_to_routes ()
{
- for (vector<connection>::iterator i = _route_connections.begin(); i != _route_connections.end(); ++i) {
+ for (vector<sigc::connection>::iterator i = _route_connections.begin(); i != _route_connections.end(); ++i) {
i->disconnect ();
}
_route_connections.clear ();
#endif
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace PBD;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
/** Construct an empty RegionSelection.
*/
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
, wait_for_data(false)
, _time_converter(r->session().tempo_map(), r->position())
{
+ cerr << "RV " << this << " has ref on region " << _region->name() << endl;
}
RegionView::RegionView (const RegionView& other)
valid = false;
_pixel_width = other._pixel_width;
_height = other._height;
+ cerr << "RV " << this << " has ref on region " << _region->name() << endl;
}
RegionView::RegionView (const RegionView& other, boost::shared_ptr<Region> other_region)
valid = false;
_pixel_width = other._pixel_width;
_height = other._height;
+ cerr << "RV " << this << " has ref on region " << _region->name() << endl;
}
RegionView::RegionView (ArdourCanvas::Group* parent,
, wait_for_data(false)
, _time_converter(r->session().tempo_map(), r->position())
{
+ cerr << "RV " << this << " has ref on region " << _region->name() << endl;
}
void
using namespace PBD;
using namespace Gtk;
using namespace Gtkmm2ext;
-using namespace sigc;
RouteParams_UI::RouteParams_UI ()
: ArdourDialog ("track/bus inspector"),
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
RouteRedirectSelection&
RouteRedirectSelection::operator= (const RouteRedirectSelection& other)
using namespace Gtkmm2ext;
using namespace Gtk;
using namespace Editing;
-using namespace sigc;
using namespace std;
Glib::RefPtr<Gdk::Pixbuf> RouteTimeAxisView::slider;
void
RouteTimeAxisView::speed_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun(*this, &RouteTimeAxisView::reset_samples_per_unit));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteTimeAxisView::reset_samples_per_unit, this));
}
void
RouteTimeAxisView::diskstream_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun(*this, &RouteTimeAxisView::update_diskstream_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteTimeAxisView::update_diskstream_display, this));
}
void
#include "ardour/profile.h"
#include "i18n.h"
-using namespace sigc;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace ARDOUR;
void
RouteUI::solo_changed(void* /*src*/)
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &RouteUI::update_solo_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_solo_display, this));
}
void
RouteUI::listen_changed(void* /*src*/)
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &RouteUI::update_solo_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_solo_display, this));
}
int
void
RouteUI::solo_changed_so_update_mute ()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &RouteUI::update_mute_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_mute_display, this));
}
void
RouteUI::mute_changed(void* /*src*/)
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &RouteUI::update_mute_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_mute_display, this));
}
int
void
RouteUI::route_rec_enable_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &RouteUI::update_rec_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_rec_display, this));
}
void
RouteUI::session_rec_enable_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &RouteUI::update_rec_display));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_rec_display, this));
}
void
RouteUI::route_active_changed ()
{
if (route_active_menu_item) {
- Gtkmm2ext::UI::instance()->call_slot (sigc::bind (sigc::mem_fun (*route_active_menu_item, &CheckMenuItem::set_active), _route->active()));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&CheckMenuItem::set_active, route_active_menu_item, _route->active()));
}
}
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
struct AudioRangeComparator {
bool operator()(AudioRange a, AudioRange b) {
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
class OptionsPortMatrix : public PortMatrix
{
playlist_change_connection.disconnect();
playlist_changed (ds);
- playlist_change_connection = ds->PlaylistChanged.connect (sigc::bind (
- sigc::mem_fun (*this, &StreamView::playlist_changed_weak),
- boost::weak_ptr<Diskstream> (ds)));
+ playlist_change_connection = ds->PlaylistChanged.connect (
+ sigc::bind (sigc::mem_fun (*this, &StreamView::playlist_changed_weak),
+ boost::weak_ptr<Diskstream> (ds)));
}
void
boost::shared_ptr<Track> t;
if ((t = _trackview.track()) != 0) {
- Gtkmm2ext::UI::instance()->call_slot (sigc::bind (
- sigc::mem_fun (*this, &StreamView::display_diskstream),
- t->diskstream()));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&StreamView::display_diskstream, this, t->diskstream()));
} else {
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &StreamView::undisplay_diskstream));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&StreamView::undisplay_diskstream, this));
}
}
void
StreamView::rec_enable_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &StreamView::setup_rec_box));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&StreamView::setup_rec_box, this));
}
void
StreamView::sess_rec_enable_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &StreamView::setup_rec_box));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&StreamView::setup_rec_box, this));
}
void
StreamView::transport_changed()
{
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &StreamView::setup_rec_box));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&StreamView::setup_rec_box, this));
}
void
{
// to force a new rec region
rec_active = false;
- Gtkmm2ext::UI::instance()->call_slot (sigc::mem_fun (*this, &StreamView::setup_rec_box));
+ Gtkmm2ext::UI::instance()->call_slot (boost::bind (&StreamView::setup_rec_box, this));
}
void
#include "i18n.h"
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
using namespace std;
using namespace Gtk;
using namespace Gdk;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace std;
using namespace Gtk;
-using namespace sigc;
using namespace Glib;
using namespace PBD;
using Gtkmm2ext::Keyboard;
using namespace ARDOUR;
using namespace PBD;
-using namespace sigc;
using namespace Gtk;
/**
#include "pbd/convert.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
#ifndef __ardour_configuration_h__
#define __ardour_configuration_h__
-
+#include <boost/function.hpp>
#include "pbd/stateful.h"
#include "ardour/configuration_variable.h"
Configuration();
virtual ~Configuration();
- virtual void map_parameters (sigc::slot<void, std::string> s) = 0;
+ virtual void map_parameters (boost::function<void (std::string)>&) = 0;
virtual int set_state (XMLNode const &, int) = 0;
virtual XMLNode & get_state () = 0;
virtual XMLNode & get_variables () = 0;
public:
RCConfiguration();
- void map_parameters (sigc::slot<void, std::string>);
+ void map_parameters (boost::function<void (std::string)>&);
int set_state (XMLNode const &, int version);
XMLNode& get_state ();
XMLNode& get_variables ();
public:
SessionConfiguration ();
- void map_parameters (sigc::slot<void, std::string>);
+ void map_parameters (boost::function<void (std::string)>&);
int set_state (XMLNode const &, int version);
XMLNode& get_state ();
XMLNode& get_variables ();
continue; /* XXX is this OK? */
}
- region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
+ region->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
_last_capture_regions.push_back (region);
#include "i18n.h"
using namespace ARDOUR;
-using namespace sigc;
using namespace std;
using namespace PBD;
} else {
_crossfades.push_back (xfade);
- xfade->Invalidated.connect (mem_fun (*this, &AudioPlaylist::crossfade_invalidated));
- xfade->StateChanged.connect (mem_fun (*this, &AudioPlaylist::crossfade_changed));
+ xfade->Invalidated.connect (sigc::mem_fun (*this, &AudioPlaylist::crossfade_invalidated));
+ xfade->StateChanged.connect (sigc::mem_fun (*this, &AudioPlaylist::crossfade_changed));
notify_crossfade_added (xfade);
}
try {
boost::shared_ptr<Crossfade> xfade = boost::shared_ptr<Crossfade> (new Crossfade (*((const Playlist *)this), *child));
_crossfades.push_back (xfade);
- xfade->Invalidated.connect (mem_fun (*this, &AudioPlaylist::crossfade_invalidated));
- xfade->StateChanged.connect (mem_fun (*this, &AudioPlaylist::crossfade_changed));
+ xfade->Invalidated.connect (sigc::mem_fun (*this, &AudioPlaylist::crossfade_invalidated));
+ xfade->StateChanged.connect (sigc::mem_fun (*this, &AudioPlaylist::crossfade_changed));
NewCrossfade(xfade);
}
if (audio_diskstream()->deprecated_io_node) {
if (!IO::connecting_legal) {
- IO::ConnectingLegal.connect (mem_fun (*this, &AudioTrack::deprecated_use_diskstream_connections));
+ IO::ConnectingLegal.connect (sigc::mem_fun (*this, &AudioTrack::deprecated_use_diskstream_connections));
} else {
deprecated_use_diskstream_connections ();
}
pending_state = const_cast<XMLNode*> (&node);
if (_session.state_of_the_state() & Session::Loading) {
- _session.StateReady.connect (mem_fun (*this, &AudioTrack::set_state_part_two));
+ _session.StateReady.connect (sigc::mem_fun (*this, &AudioTrack::set_state_part_two));
} else {
set_state_part_two ();
}
{
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (src);
if (afs) {
- afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
+ afs->HeaderPositionOffsetChanged.connect (sigc::mem_fun (*this, &AudioRegion::source_offset_changed));
}
init ();
{
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (src);
if (afs) {
- afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
+ afs->HeaderPositionOffsetChanged.connect (sigc::mem_fun (*this, &AudioRegion::source_offset_changed));
}
init ();
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> ((*i));
if (afs) {
- afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
+ afs->HeaderPositionOffsetChanged.connect (sigc::mem_fun (*this, &AudioRegion::source_offset_changed));
}
}
{
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (src);
if (afs) {
- afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
+ afs->HeaderPositionOffsetChanged.connect (sigc::mem_fun (*this, &AudioRegion::source_offset_changed));
}
init ();
AudioRegion::connect_to_analysis_changed ()
{
for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
- (*i)->AnalysisChanged.connect (mem_fun (*this, &AudioRegion::invalidate_transients));
+ (*i)->AnalysisChanged.connect (sigc::mem_fun (*this, &AudioRegion::invalidate_transients));
}
}
unique_srcs.insert (*i);
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (*i);
if (afs) {
- afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
+ afs->HeaderPositionOffsetChanged.connect (sigc::mem_fun (*this, &AudioRegion::source_offset_changed));
}
}
}
void
AudioRegion::listen_to_my_curves ()
{
- _envelope->StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
- _fade_in->StateChanged.connect (mem_fun (*this, &AudioRegion::fade_in_changed));
- _fade_out->StateChanged.connect (mem_fun (*this, &AudioRegion::fade_out_changed));
+ _envelope->StateChanged.connect (sigc::mem_fun (*this, &AudioRegion::envelope_changed));
+ _fade_in->StateChanged.connect (sigc::mem_fun (*this, &AudioRegion::fade_in_changed));
+ _fade_out->StateChanged.connect (sigc::mem_fun (*this, &AudioRegion::fade_out_changed));
}
void
_main_outs->allow_pan_reset ();
_main_outs->reset_panner ();
- _output->changed.connect (mem_fun (*this, &Auditioner::output_changed));
+ _output->changed.connect (sigc::mem_fun (*this, &Auditioner::output_changed));
the_region.reset ((AudioRegion*) 0);
g_atomic_int_set (&_active, 0);
using namespace std;
using namespace ARDOUR;
-using namespace sigc;
using namespace PBD;
sigc::signal<void,AutomationList *> AutomationList::AutomationListCreated;
ControlProtocolManager::set_session (Session& s)
{
_session = &s;
- _session->GoingAway.connect (mem_fun (*this, &ControlProtocolManager::drop_session));
+ _session->GoingAway.connect (sigc::mem_fun (*this, &ControlProtocolManager::drop_session));
for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
if ((*i)->requested || (*i)->mandatory) {
_display_to_user = false;
if (_output) {
- _output->changed.connect (mem_fun (*this, &Delivery::output_changed));
+ _output->changed.connect (sigc::mem_fun (*this, &Delivery::output_changed));
}
- CycleStart.connect (mem_fun (*this, &Delivery::cycle_start));
+ CycleStart.connect (sigc::mem_fun (*this, &Delivery::cycle_start));
}
/* deliver to a new IO object */
_display_to_user = false;
if (_output) {
- _output->changed.connect (mem_fun (*this, &Delivery::output_changed));
+ _output->changed.connect (sigc::mem_fun (*this, &Delivery::output_changed));
}
- CycleStart.connect (mem_fun (*this, &Delivery::cycle_start));
+ CycleStart.connect (sigc::mem_fun (*this, &Delivery::cycle_start));
}
/* deliver to a new IO object, reconstruct from XML */
}
if (_output) {
- _output->changed.connect (mem_fun (*this, &Delivery::output_changed));
+ _output->changed.connect (sigc::mem_fun (*this, &Delivery::output_changed));
}
- CycleStart.connect (mem_fun (*this, &Delivery::cycle_start));
+ CycleStart.connect (sigc::mem_fun (*this, &Delivery::cycle_start));
}
/* deliver to an existing IO object, reconstruct from XML */
}
if (_output) {
- _output->changed.connect (mem_fun (*this, &Delivery::output_changed));
+ _output->changed.connect (sigc::mem_fun (*this, &Delivery::output_changed));
}
- CycleStart.connect (mem_fun (*this, &Delivery::cycle_start));
+ CycleStart.connect (sigc::mem_fun (*this, &Delivery::cycle_start));
}
std::string
}
} else {
panner_legal_c.disconnect ();
- panner_legal_c = PannersLegal.connect (mem_fun (*this, &Delivery::panners_became_legal));
+ panner_legal_c = PannersLegal.connect (sigc::mem_fun (*this, &Delivery::panners_became_legal));
}
}
_io = _route->input();
ic_connection.disconnect();
- ic_connection = _io->changed.connect (mem_fun (*this, &Diskstream::handle_input_change));
+ ic_connection = _io->changed.connect (sigc::mem_fun (*this, &Diskstream::handle_input_change));
input_change_pending = ConfigurationChanged;
non_realtime_input_change ();
set_align_style_from_io ();
- _route->GoingAway.connect (mem_fun (*this, &Diskstream::route_going_away));
+ _route->GoingAway.connect (sigc::mem_fun (*this, &Diskstream::route_going_away));
}
void
reset_write_sources (false);
}
- plmod_connection = _playlist->Modified.connect (mem_fun (*this, &Diskstream::playlist_modified));
- plgone_connection = _playlist->GoingAway.connect (
bind (mem_fun (*this, &Diskstream::playlist_deleted), boost::weak_ptr<Playlist>(_playlist)));
- plregion_connection = _playlist->RangesMoved.connect (mem_fun (*this, &Diskstream::playlist_ranges_moved));
+ plmod_connection = _playlist->Modified.connect (sigc::mem_fun (*this, &Diskstream::playlist_modified));
+ plgone_connection = _playlist->GoingAway.connect (
sigc::bind (sigc::mem_fun (*this, &Diskstream::playlist_deleted), boost::weak_ptr<Playlist>(_playlist)));
+ plregion_connection = _playlist->RangesMoved.connect (sigc::mem_fun (*this, &Diskstream::playlist_ranges_moved));
}
/* don't do this if we've already asked for it *or* if we are setting up
: Return (s, true)
, user_count (0)
{
- CycleStart.connect (mem_fun (*this, &InternalReturn::cycle_start));
+ CycleStart.connect (sigc::mem_fun (*this, &InternalReturn::cycle_start));
}
InternalReturn::InternalReturn (Session& s, const XMLNode& node)
: Return (s, node, true)
, user_count (0)
{
- CycleStart.connect (mem_fun (*this, &InternalReturn::cycle_start));
+ CycleStart.connect (sigc::mem_fun (*this, &InternalReturn::cycle_start));
}
void
set_name (sendto->name());
- _send_to->GoingAway.connect (mem_fun (*this, &InternalSend::send_to_going_away));
- _send_to->NameChanged.connect (mem_fun (*this, &InternalSend::send_to_name_changed));
+ _send_to->GoingAway.connect (sigc::mem_fun (*this, &InternalSend::send_to_going_away));
+ _send_to->NameChanged.connect (sigc::mem_fun (*this, &InternalSend::send_to_name_changed));
}
InternalSend::InternalSend (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
*/
if (!IO::connecting_legal) {
- connect_c = IO::ConnectingLegal.connect (mem_fun (*this, &InternalSend::connect_when_legal));
+ connect_c = IO::ConnectingLegal.connect (sigc::mem_fun (*this, &InternalSend::connect_when_legal));
} else {
connect_when_legal ();
}
pending_state_node = new XMLNode (node);
pending_state_node_version = version;
pending_state_node_in = false;
- connection_legal_c = ConnectingLegal.connect (mem_fun (*this, &IO::connecting_became_legal));
+ connection_legal_c = ConnectingLegal.connect (sigc::mem_fun (*this, &IO::connecting_became_legal));
}
pending_state_node = new XMLNode (node);
pending_state_node_version = version;
pending_state_node_in = in;
- connection_legal_c = ConnectingLegal.connect (mem_fun (*this, &IO::connecting_became_legal));
+ connection_legal_c = ConnectingLegal.connect (sigc::mem_fun (*this, &IO::connecting_became_legal));
}
return 0;
using namespace std;
using namespace ARDOUR;
-using namespace sigc;
JACK_Slave::JACK_Slave (jack_client_t* j)
: jack (j)
using namespace std;
using namespace ARDOUR;
-using namespace sigc;
using namespace PBD;
Location::Location (const Location& other)
using namespace std;
using namespace ARDOUR;
-using namespace sigc;
using namespace MIDI;
using namespace PBD;
std::cerr << "MIDIClock_Slave: connecting to port " << port->name() << std::endl;
#endif
- connections.push_back (port->input()->timing.connect (mem_fun (*this, &MIDIClock_Slave::update_midi_clock)));
- connections.push_back (port->input()->start.connect (mem_fun (*this, &MIDIClock_Slave::start)));
- connections.push_back (port->input()->contineu.connect (mem_fun (*this, &MIDIClock_Slave::contineu)));
- connections.push_back (port->input()->stop.connect (mem_fun (*this, &MIDIClock_Slave::stop)));
- connections.push_back (port->input()->position.connect (mem_fun (*this, &MIDIClock_Slave::position)));
+ connections.push_back (port->input()->timing.connect (sigc::mem_fun (*this, &MIDIClock_Slave::update_midi_clock)));
+ connections.push_back (port->input()->start.connect (sigc::mem_fun (*this, &MIDIClock_Slave::start)));
+ connections.push_back (port->input()->contineu.connect (sigc::mem_fun (*this, &MIDIClock_Slave::contineu)));
+ connections.push_back (port->input()->stop.connect (sigc::mem_fun (*this, &MIDIClock_Slave::stop)));
+ connections.push_back (port->input()->position.connect (sigc::mem_fun (*this, &MIDIClock_Slave::position)));
}
void
continue; /* XXX is this OK? */
}
- region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
+ region->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
_last_capture_regions.push_back (region);
#include "i18n.h"
using namespace std;
-using namespace sigc;
using namespace ARDOUR;
using namespace MIDI;
using namespace MIDI::Name;
MidiPatchManager::set_session (Session& s)
{
_session = &s;
- _session->GoingAway.connect (mem_fun (*this, &MidiPatchManager::drop_session));
+ _session->GoingAway.connect (sigc::mem_fun (*this, &MidiPatchManager::drop_session));
refresh();
}
#include "i18n.h"
using namespace ARDOUR;
-using namespace sigc;
using namespace std;
MidiPlaylist::MidiPlaylist (Session& session, const XMLNode& node, bool hidden)
pending_state = const_cast<XMLNode*> (&node);
if (_session.state_of_the_state() & Session::Loading) {
- _session.StateReady.connect (mem_fun (*this, &MidiTrack::set_state_part_two));
+ _session.StateReady.connect (sigc::mem_fun (*this, &MidiTrack::set_state_part_two));
} else {
set_state_part_two ();
}
: AbstractUI<MidiUIRequest> (_("midiui"))
, _session (s)
{
- MIDI::Manager::instance()->PortsChanged.connect (mem_fun (*this, &MidiControlUI::change_midi_ports));
+ MIDI::Manager::instance()->PortsChanged.connect (sigc::mem_fun (*this, &MidiControlUI::change_midi_ports));
}
MidiControlUI::~MidiControlUI ()
if ((fd = (*i)->selectable ()) >= 0) {
Glib::RefPtr<IOSource> psrc = IOSource::create (fd, IO_IN|IO_HUP|IO_ERR);
- psrc->connect (bind (mem_fun (*this, &MidiControlUI::midi_input_handler), (*i)));
+ psrc->connect (sigc::bind (sigc::mem_fun (*this, &MidiControlUI::midi_input_handler), (*i)));
psrc->attach (_main_loop->get_context());
// glibmm hack: for now, store only the GSource*
using namespace std;
using namespace ARDOUR;
-using namespace sigc;
using namespace MIDI;
using namespace PBD;
port = &p;
- connections.push_back (port->input()->mtc_time.connect (mem_fun (*this, &MTC_Slave::update_mtc_time)));
- connections.push_back (port->input()->mtc_qtr.connect (mem_fun (*this, &MTC_Slave::update_mtc_qtr)));
- connections.push_back (port->input()->mtc_status.connect (mem_fun (*this, &MTC_Slave::update_mtc_status)));
+ connections.push_back (port->input()->mtc_time.connect (sigc::mem_fun (*this, &MTC_Slave::update_mtc_time)));
+ connections.push_back (port->input()->mtc_qtr.connect (sigc::mem_fun (*this, &MTC_Slave::update_mtc_qtr)));
+ connections.push_back (port->input()->mtc_status.connect (sigc::mem_fun (*this, &MTC_Slave::update_mtc_status)));
}
void
freeze_length = 0;
_explicit_relayering = false;
- Modified.connect (mem_fun (*this, &Playlist::mark_session_dirty));
+ Modified.connect (sigc::mem_fun (*this, &Playlist::mark_session_dirty));
}
Playlist::~Playlist ()
}
region_state_changed_connections.push_back (
- region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy),
+ region->StateChanged.connect (sigc::bind (sigc::mem_fun (this, &Playlist::region_changed_proxy),
boost::weak_ptr<Region> (region)))
);
}
void
-RCConfiguration::map_parameters (sigc::slot<void, std::string> theSlot)
+RCConfiguration::map_parameters (boost::function<void (std::string)>& functor)
{
#undef CONFIG_VARIABLE
#undef CONFIG_VARIABLE_SPECIAL
-#define CONFIG_VARIABLE(type,var,name,value) theSlot (name);
-#define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) theSlot (name);
+#define CONFIG_VARIABLE(type,var,name,value) functor (name);
+#define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) functor (name);
#include "ardour/rc_configuration_vars.h"
#undef CONFIG_VARIABLE
#undef CONFIG_VARIABLE_SPECIAL
_sources.push_back (src);
_master_sources.push_back (src);
- src->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), src));
+ src->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &Region::source_deleted), src));
assert(_sources.size() > 0);
_positional_lock_style = AudioTime;
{
DEBUG_TRACE (DEBUG::Destruction, string_compose ("Region %1 destructor @ %2\n", _name, this));
notify_callbacks ();
- GoingAway (); /* EMIT SIGNAL */
+ drop_references ();
}
void
Region::source_deleted (boost::shared_ptr<Source>)
{
_sources.clear ();
+ drop_references ();
}
vector<string>
for (SourceList::const_iterator i = s.begin (); i != s.end(); ++i) {
_sources.push_back (*i);
- (*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), *i));
+ (*i)->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &Region::source_deleted), *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()) {
- (*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), *i));
+ (*i)->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &Region::source_deleted), *i));
}
}
}
/* now that we have _meter, its safe to connect to this */
- _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
+ _meter_connection = Metering::connect (sigc::mem_fun (*this, &Route::meter));
}
Route::Route (Session& sess, const XMLNode& node, DataType default_type)
/* now that we have _meter, its safe to connect to this */
- _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
+ _meter_connection = Metering::connect (sigc::mem_fun (*this, &Route::meter));
}
void
_input.reset (new IO (_session, _name, IO::Input, _default_type));
_output.reset (new IO (_session, _name, IO::Output, _default_type));
- _input->changed.connect (mem_fun (this, &Route::input_change_handler));
- _output->changed.connect (mem_fun (this, &Route::output_change_handler));
+ _input->changed.connect (sigc::mem_fun (this, &Route::input_change_handler));
+ _output->changed.connect (sigc::mem_fun (this, &Route::output_change_handler));
/* add amp processor */
// XXX: do we want to emit the signal here ? change call order.
processor->activate ();
}
- processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
+ processor->ActiveChanged.connect (sigc::bind (sigc::mem_fun (_session, &Session::update_latency_compensation), false, false));
_output->set_user_latency (0);
}
return -1;
}
- (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
+ (*i)->ActiveChanged.connect (sigc::bind (sigc::mem_fun (_session, &Session::update_latency_compensation), false, false));
}
_output->set_user_latency (0);
#include "i18n.h"
using namespace ARDOUR;
-using namespace sigc;
using namespace std;
RouteGroup::RouteGroup (Session& s, const string &n, Flag f, Property p)
routes->push_back (r);
r->join_route_group (this);
- r->GoingAway.connect (sigc::bind (mem_fun (*this, &RouteGroup::remove_when_going_away), boost::weak_ptr<Route> (r)));
+ r->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &RouteGroup::remove_when_going_away), boost::weak_ptr<Route> (r)));
_session.set_dirty ();
changed (); /* EMIT SIGNAL */
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
- Config->ParameterChanged.connect (bind (mem_fun (*this, &Session::config_changed), false));
- config.ParameterChanged.connect (bind (mem_fun (*this, &Session::config_changed), true));
+ Config->ParameterChanged.connect (sigc::bind (sigc::mem_fun (*this, &Session::config_changed), false));
+ config.ParameterChanged.connect (sigc::bind (sigc::mem_fun (*this, &Session::config_changed), true));
if (was_dirty) {
DirtyChanged (); /* EMIT SIGNAL */
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
- Config->ParameterChanged.connect (bind (mem_fun (*this, &Session::config_changed), false));
+ Config->ParameterChanged.connect (sigc::bind (sigc::mem_fun (*this, &Session::config_changed), false));
}
Session::~Session ()
tmp = i;
++tmp;
- DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for region %1 (%2); pre-ref = %2\n", i->second->name(), i->second.get(), i->second.use_count()));
+ DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for region %1 (%2); pre-ref = %3\n", i->second->name(), i->second.get(), i->second.use_count()));
i->second->drop_references ();
DEBUG_TRACE(DEBUG::Destruction, string_compose ("region post ref = %1\n", i->second.use_count()));
i = tmp;
BootMessage (_("Using configuration"));
- Config->map_parameters (bind (mem_fun (*this, &Session::config_changed), false));
- config.map_parameters (bind (mem_fun (*this, &Session::config_changed), true));
+ boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
+ boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
+
+ Config->map_parameters (ff);
+ config.map_parameters (ft);
/* every time we reconnect, recompute worst case output latencies */
- _engine.Running.connect (mem_fun (*this, &Session::set_worst_io_latencies));
+ _engine.Running.connect (sigc::mem_fun (*this, &Session::set_worst_io_latencies));
if (synced_to_jack()) {
_engine.transport_stop ();
boost::shared_ptr<Playlist> playlist;
if ((playlist = dstream->playlist()) != 0) {
- playlist->LengthChanged.connect (mem_fun (this, &Session::playlist_length_changed));
+ playlist->LengthChanged.connect (sigc::mem_fun (this, &Session::playlist_length_changed));
}
/* see comment in playlist_length_changed () */
auto_punch_end_changed_connection.disconnect();
auto_punch_changed_connection.disconnect();
- auto_punch_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_punch_start_changed));
- auto_punch_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_punch_end_changed));
- auto_punch_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_punch_changed));
+ auto_punch_start_changed_connection = location->start_changed.connect (sigc::mem_fun (this, &Session::auto_punch_start_changed));
+ auto_punch_end_changed_connection = location->end_changed.connect (sigc::mem_fun (this, &Session::auto_punch_end_changed));
+ auto_punch_changed_connection = location->changed.connect (sigc::mem_fun (this, &Session::auto_punch_changed));
location->set_auto_punch (true, this);
auto_loop_changed_connection.disconnect();
auto_loop_start_changed_connection = location->start_changed.connect (
- mem_fun (this, &Session::auto_loop_changed));
+ sigc::mem_fun (this, &Session::auto_loop_changed));
auto_loop_end_changed_connection = location->end_changed.connect (
- mem_fun (this, &Session::auto_loop_changed));
+ sigc::mem_fun (this, &Session::auto_loop_changed));
auto_loop_changed_connection = location->changed.connect (
- mem_fun (this, &Session::auto_loop_changed));
+ sigc::mem_fun (this, &Session::auto_loop_changed));
location->set_auto_loop (true, this);
route_group->add (track);
}
- track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
+ track->DiskstreamChanged.connect (sigc::mem_fun (this, &Session::resort_routes));
//track->set_remote_control_id (control_id);
new_routes.push_back (track);
track->audio_diskstream()->non_realtime_input_change();
- track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
+ track->DiskstreamChanged.connect (sigc::mem_fun (this, &Session::resort_routes));
track->set_remote_control_id (control_id);
++control_id;
boost::weak_ptr<Route> wpr (*x);
- (*x)->listen_changed.connect (sigc::bind (mem_fun (*this, &Session::route_listen_changed), wpr));
- (*x)->solo_changed.connect (sigc::bind (mem_fun (*this, &Session::route_solo_changed), wpr));
- (*x)->mute_changed.connect (mem_fun (*this, &Session::route_mute_changed));
- (*x)->output()->changed.connect (mem_fun (*this, &Session::set_worst_io_latencies_x));
- (*x)->processors_changed.connect (mem_fun (*this, &Session::route_processors_changed));
- (*x)->route_group_changed.connect (mem_fun (*this, &Session::route_group_changed));
+ (*x)->listen_changed.connect (sigc::bind (sigc::mem_fun (*this, &Session::route_listen_changed), wpr));
+ (*x)->solo_changed.connect (sigc::bind (sigc::mem_fun (*this, &Session::route_solo_changed), wpr));
+ (*x)->mute_changed.connect (sigc::mem_fun (*this, &Session::route_mute_changed));
+ (*x)->output()->changed.connect (sigc::mem_fun (*this, &Session::set_worst_io_latencies_x));
+ (*x)->processors_changed.connect (sigc::mem_fun (*this, &Session::route_processors_changed));
+ (*x)->route_group_changed.connect (sigc::mem_fun (*this, &Session::route_group_changed));
if ((*x)->is_master()) {
_master_out = (*x);
/* writer goes out of scope, copies ds back to main */
}
- dstream->PlaylistChanged.connect (sigc::bind (mem_fun (*this, &Session::diskstream_playlist_changed), boost::weak_ptr<Diskstream> (dstream)));
+ dstream->PlaylistChanged.connect (sigc::bind (sigc::mem_fun (*this, &Session::diskstream_playlist_changed), boost::weak_ptr<Diskstream> (dstream)));
/* this will connect to future changes, and check the current length */
diskstream_playlist_changed (boost::weak_ptr<Diskstream> (dstream));
- dstream->RecordEnableChanged.connect (mem_fun (*this, &Session::update_have_rec_enabled_diskstream));
+ dstream->RecordEnableChanged.connect (sigc::mem_fun (*this, &Session::update_have_rec_enabled_diskstream));
dstream->prepare ();
}
}
- region->StateChanged.connect (sigc::bind (mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
- region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
+ region->StateChanged.connect (sigc::bind (sigc::mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
+ region->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
update_region_name_map (region);
}
}
if (result.second) {
- source->GoingAway.connect (sigc::bind (mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
+ source->GoingAway.connect (sigc::bind (sigc::mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
set_dirty();
}
bool existing = playlists->add (playlist);
if (!existing) {
- playlist->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_playlist), boost::weak_ptr<Playlist>(playlist)));
+ playlist->GoingAway.connect (sigc::bind (
sigc::mem_fun (*this, &Session::remove_playlist), boost::weak_ptr<Playlist>(playlist)));
}
if (unused) {
void
Session::add_processor (Processor* processor)
{
- processor->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_processor), processor));
+ processor->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &Session::remove_processor), processor));
set_dirty();
}
}
void
-SessionConfiguration::map_parameters (sigc::slot<void, std::string> theSlot)
+SessionConfiguration::map_parameters (boost::function<void (std::string)>& functor)
{
#undef CONFIG_VARIABLE
#undef CONFIG_VARIABLE_SPECIAL
-#define CONFIG_VARIABLE(type,var,name,value) theSlot (name);
-#define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) theSlot (name);
+#define CONFIG_VARIABLE(type,var,name,value) functor (name);
+#define CONFIG_VARIABLE_SPECIAL(type,var,name,value,mutator) functor (name);
#include "ardour/session_configuration_vars.h"
#undef CONFIG_VARIABLE
#undef CONFIG_VARIABLE_SPECIAL
}
mmc->Play.connect
- (mem_fun (*this, &Session::mmc_deferred_play));
+ (sigc::mem_fun (*this, &Session::mmc_deferred_play));
mmc->DeferredPlay.connect
- (mem_fun (*this, &Session::mmc_deferred_play));
+ (sigc::mem_fun (*this, &Session::mmc_deferred_play));
mmc->Stop.connect
- (mem_fun (*this, &Session::mmc_stop));
+ (sigc::mem_fun (*this, &Session::mmc_stop));
mmc->FastForward.connect
- (mem_fun (*this, &Session::mmc_fast_forward));
+ (sigc::mem_fun (*this, &Session::mmc_fast_forward));
mmc->Rewind.connect
- (mem_fun (*this, &Session::mmc_rewind));
+ (sigc::mem_fun (*this, &Session::mmc_rewind));
mmc->Pause.connect
- (mem_fun (*this, &Session::mmc_pause));
+ (sigc::mem_fun (*this, &Session::mmc_pause));
mmc->RecordPause.connect
- (mem_fun (*this, &Session::mmc_record_pause));
+ (sigc::mem_fun (*this, &Session::mmc_record_pause));
mmc->RecordStrobe.connect
- (mem_fun (*this, &Session::mmc_record_strobe));
+ (sigc::mem_fun (*this, &Session::mmc_record_strobe));
mmc->RecordExit.connect
- (mem_fun (*this, &Session::mmc_record_exit));
+ (sigc::mem_fun (*this, &Session::mmc_record_exit));
mmc->Locate.connect
- (mem_fun (*this, &Session::mmc_locate));
+ (sigc::mem_fun (*this, &Session::mmc_locate));
mmc->Step.connect
- (mem_fun (*this, &Session::mmc_step));
+ (sigc::mem_fun (*this, &Session::mmc_step));
mmc->Shuttle.connect
- (mem_fun (*this, &Session::mmc_shuttle));
+ (sigc::mem_fun (*this, &Session::mmc_shuttle));
mmc->TrackRecordStatusChange.connect
- (mem_fun (*this, &Session::mmc_record_enable));
+ (sigc::mem_fun (*this, &Session::mmc_record_enable));
/* also handle MIDI SPP because its so common */
- _mmc_port->input()->start.connect (mem_fun (*this, &Session::spp_start));
- _mmc_port->input()->contineu.connect (mem_fun (*this, &Session::spp_continue));
- _mmc_port->input()->stop.connect (mem_fun (*this, &Session::spp_stop));
+ _mmc_port->input()->start.connect (sigc::mem_fun (*this, &Session::spp_start));
+ _mmc_port->input()->contineu.connect (sigc::mem_fun (*this, &Session::spp_continue));
+ _mmc_port->input()->stop.connect (sigc::mem_fun (*this, &Session::spp_stop));
Config->set_mmc_port_name (port_tag);
if (!step_queued) {
if (midi_control_ui) {
RefPtr<TimeoutSource> tsrc = TimeoutSource::create (100);
- tsrc->connect (mem_fun (*this, &Session::mmc_step_timeout));
+ tsrc->connect (sigc::mem_fun (*this, &Session::mmc_step_timeout));
tsrc->attach (midi_control_ui->main_loop()->get_context());
step_queued = true;
}
if (!existing) {
playlists.insert (playlists.begin(), playlist);
- playlist->InUse.connect (sigc::bind (mem_fun (*this, &SessionPlaylists::track), boost::weak_ptr<Playlist>(playlist)));
+ playlist->InUse.connect (sigc::bind (
sigc::mem_fun (*this, &SessionPlaylists::track), boost::weak_ptr<Playlist>(playlist)));
}
return existing;
_base_frame_rate = _current_frame_rate;
_tempo_map = new TempoMap (_current_frame_rate);
- _tempo_map->StateChanged.connect (mem_fun (*this, &Session::tempo_map_changed));
+ _tempo_map->StateChanged.connect (sigc::mem_fun (*this, &Session::tempo_map_changed));
_non_soloed_outs_muted = false;
delta_accumulator_cnt = 0;
_slave_state = Stopped;
- _engine.GraphReordered.connect (mem_fun (*this, &Session::graph_reordered));
+ _engine.GraphReordered.connect (sigc::mem_fun (*this, &Session::graph_reordered));
/* These are all static "per-class" signals */
- RegionFactory::CheckNewRegion.connect (mem_fun (*this, &Session::add_region));
- SourceFactory::SourceCreated.connect (mem_fun (*this, &Session::add_source));
- PlaylistFactory::PlaylistCreated.connect (mem_fun (*this, &Session::add_playlist));
- Processor::ProcessorCreated.connect (mem_fun (*this, &Session::add_processor));
- NamedSelection::NamedSelectionCreated.connect (mem_fun (*this, &Session::add_named_selection));
- AutomationList::AutomationListCreated.connect (mem_fun (*this, &Session::add_automation_list));
+ RegionFactory::CheckNewRegion.connect (sigc::mem_fun (*this, &Session::add_region));
+ SourceFactory::SourceCreated.connect (sigc::mem_fun (*this, &Session::add_source));
+ PlaylistFactory::PlaylistCreated.connect (sigc::mem_fun (*this, &Session::add_playlist));
+ Processor::ProcessorCreated.connect (sigc::mem_fun (*this, &Session::add_processor));
+ NamedSelection::NamedSelectionCreated.connect (sigc::mem_fun (*this, &Session::add_named_selection));
+ AutomationList::AutomationListCreated.connect (sigc::mem_fun (*this, &Session::add_automation_list));
- Controllable::Destroyed.connect (mem_fun (*this, &Session::remove_controllable));
+ Controllable::Destroyed.connect (sigc::mem_fun (*this, &Session::remove_controllable));
- IO::PortCountChanged.connect (mem_fun (*this, &Session::ensure_buffers));
+ IO::PortCountChanged.connect (sigc::mem_fun (*this, &Session::ensure_buffers));
/* stop IO objects from doing stuff until we're ready for them */
_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave|Loading);
- _locations.changed.connect (mem_fun (this, &Session::locations_changed));
- _locations.added.connect (mem_fun (this, &Session::locations_added));
+ _locations.changed.connect (sigc::mem_fun (this, &Session::locations_changed));
+ _locations.added.connect (sigc::mem_fun (this, &Session::locations_added));
setup_click_sounds (0);
setup_midi_control ();
/* Pay attention ... */
- _engine.Halted.connect (mem_fun (*this, &Session::engine_halted));
- _engine.Xrun.connect (mem_fun (*this, &Session::xrun_recovery));
+ _engine.Halted.connect (sigc::mem_fun (*this, &Session::engine_halted));
+ _engine.Xrun.connect (sigc::mem_fun (*this, &Session::xrun_recovery));
try {
when_engine_running();
using namespace std;
using namespace ARDOUR;
-using namespace sigc;
using namespace PBD;
void
}
AudioFileSource::HeaderPositionOffsetChanged.connect (
- mem_fun (*this, &SndFileSource::handle_header_position_change));
+ sigc::mem_fun (*this, &SndFileSource::handle_header_position_change));
}
int
_session = &s;
if (_session) {
- _session->tick.connect(mem_fun (*this, &Ticker::tick));
- _session->GoingAway.connect(mem_fun (*this, &Ticker::going_away));
+ _session->tick.connect(sigc::mem_fun (*this, &Ticker::tick));
+ _session->GoingAway.connect(sigc::mem_fun (*this, &Ticker::going_away));
}
}
if (_session) {
_session->MIDIClock_PortChanged.connect(
- mem_fun (*this, &MidiClockTicker::update_midi_clock_port));
+ sigc::mem_fun (*this, &MidiClockTicker::update_midi_clock_port));
_session->TransportStateChange.connect(
- mem_fun (*this, &MidiClockTicker::transport_state_changed));
+ sigc::mem_fun (*this, &MidiClockTicker::transport_state_changed));
_session->PositionChanged.connect(
- mem_fun (*this, &MidiClockTicker::position_changed));
+ sigc::mem_fun (*this, &MidiClockTicker::position_changed));
_session->TransportLooped.connect(
- mem_fun (*this, &MidiClockTicker::transport_looped));
+ sigc::mem_fun (*this, &MidiClockTicker::transport_looped));
update_midi_clock_port();
}
}
#define __pbd_ui_callback_h__
#include <boost/function.hpp>
+#include <boost/bind.hpp> /* we don't need this here, but anything calling call_slot() probably will, so this is convenient */
#include <glibmm/thread.h>
namespace PBD
#include "i18n.h"
using namespace ARDOUR;
-using namespace sigc;
using namespace std;
using namespace Glib;
// "Application Hooks"
session_loaded (s);
- session->Exported.connect (mem_fun (*this, &OSC::session_exported));
+ session->Exported.connect (sigc::mem_fun (*this, &OSC::session_exported));
}
OSC::~OSC()
{
if (_osc_unix_server) {
Glib::RefPtr<IOSource> src = IOSource::create (lo_server_get_socket_fd (_osc_unix_server), IO_IN|IO_HUP|IO_ERR);
- src->connect (bind (sigc::mem_fun (*this, &OSC::osc_input_handler), _osc_unix_server));
+ src->connect (sigc::bind (sigc::mem_fun (*this, &OSC::osc_input_handler), _osc_unix_server));
src->attach (_main_loop->get_context());
local_server = src->gobj();
g_source_ref (local_server);
if (_osc_server) {
Glib::RefPtr<IOSource> src = IOSource::create (lo_server_get_socket_fd (_osc_server), IO_IN|IO_HUP|IO_ERR);
- src->connect (bind (sigc::mem_fun (*this, &OSC::osc_input_handler), _osc_server));
+ src->connect (sigc::bind (sigc::mem_fun (*this, &OSC::osc_input_handler), _osc_server));
src->attach (_main_loop->get_context());
remote_server = src->gobj();
g_source_ref (remote_server);
*/
if (!route_exists) {
- route->GoingAway.connect (bind (mem_fun (*this, &OSC::drop_route), boost::weak_ptr<Route> (route)));
+ route->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &OSC::drop_route), boost::weak_ptr<Route> (route)));
}
}
projects / ardour.git / commitdiff