ardour/livetrax
13
0
Fork 0
Code

Replace PBD::Signals (1/2)

Browse Source
This commit is contained in:
Robin Gareus 2024-10-18 18:01:28 +02:00
parent 5808ab5608
commit 2d7cce44f1
Signed by: rgareus
GPG Key ID: A090BCE02CF57F04
163 changed files with 519 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libs/ardour/ardour/analysis_graph.h
View File

@ -58,7 +58,7 @@ class LIBARDOUR_API AnalysisGraph {
bool canceled () const { return _canceled; }
void set_total_samples (samplecnt_t p) { _samples_end = p; }
PBD::Signal2<void, samplecnt_t, samplecnt_t> Progress;
PBD::Signal<void(samplecnt_t, samplecnt_t)> Progress;
private:
ARDOUR::Session* _session;

10
libs/ardour/ardour/ardour.h
View File

@ -50,11 +50,11 @@ namespace ARDOUR {
class AudioEngine;
class Session;
extern LIBARDOUR_API PBD::Signal1<void,std::string> BootMessage;
extern LIBARDOUR_API PBD::Signal3<void,std::string,std::string,bool> PluginScanMessage;
extern LIBARDOUR_API PBD::Signal1<void,int> PluginScanTimeout;
extern LIBARDOUR_API PBD::Signal0<void> GUIIdle;
extern LIBARDOUR_API PBD::Signal3<bool,std::string,std::string,int> CopyConfigurationFiles;
extern LIBARDOUR_API PBD::Signal<void(std::string)> BootMessage;
extern LIBARDOUR_API PBD::Signal<void(std::string,std::string,bool)> PluginScanMessage;
extern LIBARDOUR_API PBD::Signal<void(int)> PluginScanTimeout;
extern LIBARDOUR_API PBD::Signal<void()> GUIIdle;
extern LIBARDOUR_API PBD::Signal<bool(std::string,std::string,int)> CopyConfigurationFiles;
extern LIBARDOUR_API std::map<std::string, bool> reserved_io_names;
extern LIBARDOUR_API float ui_scale_factor;

24
libs/ardour/ardour/audioengine.h
View File

@ -159,39 +159,39 @@ class LIBARDOUR_API AudioEngine : public PortManager, public SessionHandlePtr
(the regular process() call to session->process() is not made)
*/
PBD::Signal1<void, pframes_t> Freewheel;
PBD::Signal<void(pframes_t)> Freewheel;
PBD::Signal0<void> Xrun;
PBD::Signal<void()> Xrun;
/** this signal is emitted if the sample rate changes */
PBD::Signal1<void, samplecnt_t> SampleRateChanged;
PBD::Signal<void(samplecnt_t)> SampleRateChanged;
/** this signal is emitted if the buffer size changes */
PBD::Signal1<void, pframes_t> BufferSizeChanged;
PBD::Signal<void(pframes_t)> BufferSizeChanged;
/** this signal is emitted if the device cannot operate properly */
PBD::Signal0<void> DeviceError;
PBD::Signal<void()> DeviceError;
/* this signal is emitted if the device list changed */
PBD::Signal0<void> DeviceListChanged;
PBD::Signal<void()> DeviceListChanged;
/* this signal is sent if the backend ever disconnects us */
PBD::Signal1<void,const char*> Halted;
PBD::Signal<void(const char*)> Halted;
/* these two are emitted when the engine itself is
started and stopped
*/
PBD::Signal1<void,uint32_t> Running;
PBD::Signal0<void> Stopped;
PBD::Signal<void(uint32_t)> Running;
PBD::Signal<void()> Stopped;
/* these two are emitted when a device reset is initiated/finished
*/
PBD::Signal0<void> DeviceResetStarted;
PBD::Signal0<void> DeviceResetFinished;
PBD::Signal<void()> DeviceResetStarted;
PBD::Signal<void()> DeviceResetFinished;
static AudioEngine* instance() { return _instance; }
static void destroy();
@ -242,7 +242,7 @@ class LIBARDOUR_API AudioEngine : public PortManager, public SessionHandlePtr
* value.
*/
PBD::Signal0<void> BecameSilent;
PBD::Signal<void()> BecameSilent;
void reset_silence_countdown ();
void add_pending_port_deletion (Port*);

2
libs/ardour/ardour/audiofilesource.h
View File

@ -78,7 +78,7 @@ public:
static void set_bwf_serial_number (int);
static void set_header_position_offset (samplecnt_t offset);
static PBD::Signal0<void> HeaderPositionOffsetChanged;
static PBD::Signal<void()> HeaderPositionOffsetChanged;
protected:
/** Constructor to be called for existing external-to-session files */

4
libs/ardour/ardour/audiosource.h
View File

@ -69,8 +69,8 @@ class LIBARDOUR_API AudioSource : virtual public Source, public ARDOUR::AudioRea
int build_peaks ();
bool peaks_ready (boost::function<void()> callWhenReady, PBD::ScopedConnection** connection_created_if_not_ready, PBD::EventLoop* event_loop) const;
mutable PBD::Signal0<void> PeaksReady;
mutable PBD::Signal2<void,samplepos_t,samplepos_t> PeakRangeReady;
mutable PBD::Signal<void()> PeaksReady;
mutable PBD::Signal<void(samplepos_t,samplepos_t)> PeakRangeReady;
XMLNode& get_state () const;
int set_state (const XMLNode&, int version);

2
libs/ardour/ardour/auditioner.h
View File

@ -70,7 +70,7 @@ public:
virtual ChanCount input_streams () const;
PBD::Signal2<void, ARDOUR::samplecnt_t, ARDOUR::samplecnt_t> AuditionProgress;
PBD::Signal<void(ARDOUR::samplecnt_t, ARDOUR::samplecnt_t)> AuditionProgress;
/* Track */
int roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool& need_butler);

2
libs/ardour/ardour/automatable.h
View File

@ -116,7 +116,7 @@ public:
int set_automation_xml_state (const XMLNode&, Evoral::Parameter default_param);
XMLNode& get_automation_xml_state() const;
PBD::Signal0<void> AutomationStateChanged;
PBD::Signal<void()> AutomationStateChanged;
void start_domain_bounce (Temporal::DomainBounceInfo&);
void finish_domain_bounce (Temporal::DomainBounceInfo&);

6
libs/ardour/ardour/automation_list.h
View File

@ -89,7 +89,7 @@ public:
void set_automation_state (AutoState);
AutoState automation_state() const;
PBD::Signal1<void, AutoState> automation_state_changed;
PBD::Signal<void(AutoState)> automation_state_changed;
bool automation_playback() const {
return (_state & Play) || ((_state & (Touch | Latch)) && !touching());
@ -98,9 +98,9 @@ public:
return ((_state & Write) || ((_state & (Touch | Latch)) && touching()));
}
PBD::Signal0<void> StateChanged;
PBD::Signal<void()> StateChanged;
static PBD::Signal1<void,AutomationList*> AutomationListCreated;
static PBD::Signal<void(AutomationList*)> AutomationListCreated;
void start_write_pass (timepos_t const & when);
void write_pass_finished (timepos_t const & when, double thinning_factor=0.0);

2
libs/ardour/ardour/bundle.h
View File

@ -137,7 +137,7 @@ class LIBARDOUR_API Bundle : public PBD::ScopedConnectionList
DirectionChanged = 0x10 ///< the direction (whether ports are inputs or outputs) has changed
};
PBD::Signal1<void,Change> Changed;
PBD::Signal<void(Change)> Changed;
protected:

2
libs/ardour/ardour/clip_library.h
View File

@ -33,7 +33,7 @@ namespace ARDOUR {
class Region;
extern LIBARDOUR_API PBD::Signal2<void, std::string, void*> LibraryClipAdded;
extern LIBARDOUR_API PBD::Signal<void(std::string, void*)> LibraryClipAdded;
LIBARDOUR_API std::string clip_library_dir (bool create_if_missing = false);
LIBARDOUR_API bool export_to_clip_library (std::shared_ptr<Region> r, void* src = NULL);

4
libs/ardour/ardour/control_protocol_manager.h
View File

@ -87,10 +87,10 @@ class LIBARDOUR_API ControlProtocolManager : public PBD::Stateful, public ARDOUR
int set_state (const XMLNode&, int version);
XMLNode& get_state () const;
PBD::Signal1<void,ControlProtocolInfo*> ProtocolStatusChange;
PBD::Signal<void(ControlProtocolInfo*)> ProtocolStatusChange;
void stripable_selection_changed (ARDOUR::StripableNotificationListPtr);
static PBD::Signal1<void,ARDOUR::StripableNotificationListPtr> StripableSelectionChanged;
static PBD::Signal<void(ARDOUR::StripableNotificationListPtr)> StripableSelectionChanged;
private:
ControlProtocolManager ();

4
libs/ardour/ardour/delivery.h
View File

@ -96,7 +96,7 @@ public:
BufferSet& output_buffers() { return *_output_buffers; }
PBD::Signal0<void> MuteChange;
PBD::Signal<void()> MuteChange;
int set_state (const XMLNode&, int version);
@ -153,7 +153,7 @@ private:
std::shared_ptr<AutomationControl> _polarity_control;
static bool panners_legal;
static PBD::Signal0<void> PannersLegal;
static PBD::Signal<void()> PannersLegal;
void panners_became_legal ();
PBD::ScopedConnection panner_legal_c;

4
libs/ardour/ardour/disk_io.h
View File

@ -87,8 +87,8 @@ public:
bool slaved() const { return _slaved; }
void set_slaved(bool yn) { _slaved = yn; }
PBD::Signal0<void> SpeedChanged;
PBD::Signal0<void> ReverseChanged;
PBD::Signal<void()> SpeedChanged;
PBD::Signal<void()> ReverseChanged;
int set_state (const XMLNode&, int version);

4
libs/ardour/ardour/disk_reader.h
View File

@ -69,7 +69,7 @@ public:
LIBARDOUR_API int set_state (const XMLNode&, int version);
PBD::Signal0<void> AlignmentStyleChanged;
PBD::Signal<void()> AlignmentStyleChanged;
LIBARDOUR_API float buffer_load () const;
@ -96,7 +96,7 @@ public:
LIBARDOUR_API void internal_playback_seek (sampleoffset_t distance);
LIBARDOUR_API int seek (samplepos_t sample, bool complete_refill = false);
LIBARDOUR_API static PBD::Signal0<void> Underrun;
LIBARDOUR_API static PBD::Signal<void()> Underrun;
LIBARDOUR_API void playlist_modified ();
LIBARDOUR_API void reset_tracker ();

10
libs/ardour/ardour/disk_writer.h
View File

@ -79,7 +79,7 @@ public:
AlignStyle alignment_style () const { return _alignment_style; }
void set_align_style (AlignStyle, bool force = false);
PBD::Signal0<void> AlignmentStyleChanged;
PBD::Signal<void()> AlignmentStyleChanged;
bool configure_io (ChanCount in, ChanCount out);
@ -103,7 +103,7 @@ public:
int seek (samplepos_t sample, bool complete_refill);
static PBD::Signal0<void> Overrun;
static PBD::Signal<void()> Overrun;
void set_note_mode (NoteMode m);
@ -111,10 +111,10 @@ public:
* Parameter is the source that it is destined for.
* A caller can get a copy of the data with get_gui_feed_buffer ()
*/
PBD::Signal1<void, std::weak_ptr<MidiSource> > DataRecorded;
PBD::Signal<void(std::weak_ptr<MidiSource> )> DataRecorded;
PBD::Signal0<void> RecordEnableChanged;
PBD::Signal0<void> RecordSafeChanged;
PBD::Signal<void()> RecordEnableChanged;
PBD::Signal<void()> RecordSafeChanged;
void transport_looped (samplepos_t transport_sample);
void transport_stopped_wallclock (struct tm&, time_t, bool abort);

4
libs/ardour/ardour/element_importer.h
View File

@ -73,10 +73,10 @@ class LIBARDOUR_API ElementImporter
bool broken () { return _broken; }
/// Signal that requests for anew name
static PBD::Signal2<std::pair<bool, std::string>,std::string, std::string> Rename;
static PBD::Signal<std::pair<bool, std::string>(std::string, std::string)> Rename;
/// Signal for ok/cancel prompting
static PBD::Signal1<bool,std::string> Prompt;
static PBD::Signal<bool(std::string)> Prompt;
protected:

4
libs/ardour/ardour/export_format_base.h
View File

@ -126,8 +126,8 @@ class LIBARDOUR_API ExportFormatBase {
: _selected (false), _compatible (true) { }
~SelectableCompatible () {}
PBD::Signal1<void,bool> SelectChanged;
PBD::Signal1<void,bool> CompatibleChanged;
PBD::Signal<void(bool)> SelectChanged;
PBD::Signal<void(bool)> CompatibleChanged;
bool selected () const { return _selected; }
bool compatible () const { return _compatible; }

4
libs/ardour/ardour/export_format_manager.h
View File

@ -84,8 +84,8 @@ class LIBARDOUR_API ExportFormatManager : public PBD::ScopedConnectionList
/* Signals */
PBD::Signal1<void,bool> CompleteChanged;
PBD::Signal0<void> DescriptionChanged;
PBD::Signal<void(bool)> CompleteChanged;
PBD::Signal<void()> DescriptionChanged;
/* Access to lists */

8
libs/ardour/ardour/export_formats.h
View File

@ -214,11 +214,11 @@ public:
DitherTypePtr get_selected_dither_type ();
/* Proxies for signals from sample formats and dither types */
PBD::Signal2<void, bool, WeakSampleFormatPtr> SampleFormatSelectChanged;
PBD::Signal2<void, bool, WeakSampleFormatPtr> SampleFormatCompatibleChanged;
PBD::Signal<void(bool, WeakSampleFormatPtr)> SampleFormatSelectChanged;
PBD::Signal<void(bool, WeakSampleFormatPtr)> SampleFormatCompatibleChanged;
PBD::Signal2<void, bool, WeakDitherTypePtr> DitherTypeSelectChanged;
PBD::Signal2<void, bool, WeakDitherTypePtr> DitherTypeCompatibleChanged;
PBD::Signal<void(bool, WeakDitherTypePtr)> DitherTypeSelectChanged;
PBD::Signal<void(bool, WeakDitherTypePtr)> DitherTypeCompatibleChanged;
static std::string get_sample_format_name (ExportFormatBase::SampleFormat format);

2
libs/ardour/ardour/export_handler.h
View File

@ -116,7 +116,7 @@ class LIBARDOUR_API ExportHandler : public ExportElementFactory, public sigc::tr
/** signal emitted when soundcloud export reports progress updates during upload.
* The parameters are total and current bytes downloaded, and the current filename
*/
PBD::Signal3<void, double, double, std::string> SoundcloudProgress;
PBD::Signal<void(double, double, std::string)> SoundcloudProgress;
/* upload credentials & preferences */
std::string soundcloud_username;

4
libs/ardour/ardour/export_multiplication.h
View File

@ -54,7 +54,7 @@
bool selected () const { return _selected; }
void select (bool value);
PBD::Signal1<void,bool> SelectChanged;
PBD::Signal<void(bool)> SelectChanged;
protected:
@ -169,7 +169,7 @@
void split_node (GraphNode * node, float position);
void remove_node (GraphNode * node);
PBD::Signal0<void> GraphChanged;
PBD::Signal<void()> GraphChanged;
private:

2
libs/ardour/ardour/export_profile_manager.h
View File

@ -217,7 +217,7 @@ public:
ExportFormatSpecPtr get_new_format (ExportFormatSpecPtr original);
PBD::Signal0<void> FormatListChanged;
PBD::Signal<void()> FormatListChanged;
private:
FormatStateList formats;

2
libs/ardour/ardour/export_status.h
View File

@ -53,7 +53,7 @@ class LIBARDOUR_API ExportStatus {
}
Glib::Threads::Mutex& lock () { return _run_lock; }
PBD::Signal1<void,TransportRequestSource> Finished;
PBD::Signal<void(TransportRequestSource)> Finished;
void finish (TransportRequestSource);
void cleanup ();

2
libs/ardour/ardour/file_source.h
View File

@ -85,7 +85,7 @@ public:
virtual void set_path (const std::string&);
void replace_file (const std::string&);
static PBD::Signal2<int,std::string,std::vector<std::string> > AmbiguousFileName;
static PBD::Signal<int(std::string,std::vector<std::string> )> AmbiguousFileName;
void existence_check ();
virtual void prevent_deletion ();

2
libs/ardour/ardour/instrument_info.h
View File

@ -72,7 +72,7 @@ public:
size_t master_controller_count () const;
uint16_t channels_for_control_list (std::string const& ctrl_name_list) const;
PBD::Signal0<void> Changed;
PBD::Signal<void()> Changed;
bool have_custom_plugin_info () const;

2
libs/ardour/ardour/internal_send.h
View File

@ -60,7 +60,7 @@ public:
void set_can_pan (bool yn);
uint32_t pan_outs () const;
static PBD::Signal1<void, pframes_t> CycleStart;
static PBD::Signal<void(pframes_t)> CycleStart;
protected:
XMLNode& state() const;

6
libs/ardour/ardour/io.h
View File

@ -148,7 +148,7 @@ public:
* IOChange contains ConfigurationChanged. In other cases,
* the process lock status is undefined.
*/
PBD::Signal2<void, IOChange, void *> changed;
PBD::Signal<void(IOChange, void *)> changed;
XMLNode& get_state () const;
@ -179,9 +179,9 @@ public:
* can attach to this, and return `true' if they want to prevent
* the change from happening.
*/
PBD::Signal1<bool, ChanCount, BoolCombiner> PortCountChanging;
PBD::SignalWithCombiner<BoolCombiner, bool(ChanCount)> PortCountChanging;
static PBD::Signal1<void, ChanCount> PortCountChanged; // emitted when the number of ports changes
static PBD::Signal<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&);

4
libs/ardour/ardour/io_processor.h
View File

@ -72,8 +72,8 @@ public:
virtual bool feeds (std::shared_ptr<Route> other) const;
PBD::Signal2<void,IOProcessor*,bool> AutomationPlaybackChanged;
PBD::Signal2<void,IOProcessor*,uint32_t> AutomationChanged;
PBD::Signal<void(IOProcessor*,bool)> AutomationPlaybackChanged;
PBD::Signal<void(IOProcessor*,uint32_t)> AutomationChanged;
XMLNode& state () const;
int set_state (const XMLNode&, int version);

4
libs/ardour/ardour/latent.h
View File

@ -83,8 +83,8 @@ public:
return _zero_latency;
}
static PBD::Signal0<void> DisableSwitchChanged;
PBD::Signal0<void> LatencyChanged;
static PBD::Signal<void()> DisableSwitchChanged;
PBD::Signal<void()> LatencyChanged;
protected:
int set_state (const XMLNode& node, int version);

44
libs/ardour/ardour/location.h
View File

@ -143,32 +143,32 @@ public:
* locations at once.
*/
static PBD::Signal1<void,Location*> name_changed;
static PBD::Signal1<void,Location*> end_changed;
static PBD::Signal1<void,Location*> start_changed;
static PBD::Signal1<void,Location*> flags_changed;
static PBD::Signal1<void,Location*> lock_changed;
static PBD::Signal1<void,Location*> cue_change;
static PBD::Signal1<void,Location*> scene_changed;
static PBD::Signal1<void,Location*> time_domain_changed; /* unused */
static PBD::Signal<void(Location*)> name_changed;
static PBD::Signal<void(Location*)> end_changed;
static PBD::Signal<void(Location*)> start_changed;
static PBD::Signal<void(Location*)> flags_changed;
static PBD::Signal<void(Location*)> lock_changed;
static PBD::Signal<void(Location*)> cue_change;
static PBD::Signal<void(Location*)> scene_changed;
static PBD::Signal<void(Location*)> time_domain_changed; /* unused */
/* this is sent only when both start and end change at the same time */
static PBD::Signal1<void,Location*> changed;
static PBD::Signal<void(Location*)> changed;
/* these are member signals for objects that care only about
* changes to this object
*/
PBD::Signal0<void> Changed;
PBD::Signal<void()> Changed;
PBD::Signal0<void> NameChanged;
PBD::Signal0<void> EndChanged;
PBD::Signal0<void> StartChanged;
PBD::Signal0<void> FlagsChanged;
PBD::Signal0<void> LockChanged;
PBD::Signal0<void> CueChanged;
PBD::Signal0<void> SceneChanged; /* unused */
PBD::Signal0<void> TimeDomainChanged;
PBD::Signal<void()> NameChanged;
PBD::Signal<void()> EndChanged;
PBD::Signal<void()> StartChanged;
PBD::Signal<void()> FlagsChanged;
PBD::Signal<void()> LockChanged;
PBD::Signal<void()> CueChanged;
PBD::Signal<void()> SceneChanged; /* unused */
PBD::Signal<void()> TimeDomainChanged;
/* CD Track / CD-Text info */
@ -334,15 +334,15 @@ public:
void time_domain_changed ();
PBD::Signal1<void,Location*> current_changed;
PBD::Signal<void(Location*)> current_changed;
/* Objects that care about individual addition and removal of Locations should connect to added/removed.
* If an object additionally cares about potential mass clearance of Locations, they should connect to changed.
*/
PBD::Signal1<void,Location*> added;
PBD::Signal1<void,Location*> removed;
PBD::Signal0<void> changed; /* emitted when any action that could have added/removed more than 1 location actually removed 1 or more */
PBD::Signal<void(Location*)> added;
PBD::Signal<void(Location*)> removed;
PBD::Signal<void()> changed; /* emitted when any action that could have added/removed more than 1 location actually removed 1 or more */
template<class T> void apply (T& obj, void (T::*method)(const LocationList&)) const {
/* We don't want to hold the lock while the given method runs, so take a copy

2
libs/ardour/ardour/luascripting.h
View File

@ -116,7 +116,7 @@ public:
LuaScriptList &scripts (LuaScriptInfo::ScriptType);
void refresh (bool run_scan = false);
PBD::Signal0<void> scripts_changed;
PBD::Signal<void()> scripts_changed;
LuaScriptInfoPtr by_name (const std::string&, LuaScriptInfo::ScriptType);

2
libs/ardour/ardour/meter.h
View File

@ -85,7 +85,7 @@ public:
void set_meter_type (MeterType t);
MeterType meter_type () const { return _meter_type; }
PBD::Signal1<void, MeterType> MeterTypeChanged;
PBD::Signal<void(MeterType)> MeterTypeChanged;
protected:
XMLNode& state () const;

4
libs/ardour/ardour/midi_channel_filter.h
View File

@ -85,8 +85,8 @@ public:
return _mode_mask.load() & 0x0000FFFF;
}
PBD::Signal0<void> ChannelMaskChanged;
PBD::Signal0<void> ChannelModeChanged;
PBD::Signal<void()> ChannelMaskChanged;
PBD::Signal<void()> ChannelModeChanged;
private:
std::atomic<uint32_t> _mode_mask; ///< 16 bits mode, 16 bits mask

2
libs/ardour/ardour/midi_cursor.h
View File

@ -34,7 +34,7 @@ namespace ARDOUR {
struct MidiCursor : public boost::noncopyable {
MidiCursor() {}
void connect(PBD::Signal1<void, bool>& invalidated) {
void connect(PBD::Signal<void(bool)>& invalidated) {
connections.drop_connections();
invalidated.connect_same_thread (connections, boost::bind(&MidiCursor::invalidate, this, _1));
}

4
libs/ardour/ardour/midi_model.h
View File

@ -312,8 +312,8 @@ public:
XMLNode& get_state() const;
int set_state(const XMLNode&) { return 0; }
PBD::Signal0<void> ContentsChanged;
PBD::Signal1<void, Temporal::timecnt_t> ContentsShifted;
PBD::Signal<void()> ContentsChanged;
PBD::Signal<void(Temporal::timecnt_t)> ContentsShifted;
std::shared_ptr<Evoral::Note<TimeType> > find_note (NotePtr);
PatchChangePtr find_patch_change (Evoral::event_id_t);

2
libs/ardour/ardour/midi_patch_manager.h
View File

@ -61,7 +61,7 @@ public:
return *_manager;
}
PBD::Signal0<void> PatchesChanged;
PBD::Signal<void()> PatchesChanged;
bool add_custom_midnam (const std::string& id, char const*);
bool update_custom_midnam (const std::string& id, char const*);

4
libs/ardour/ardour/midi_scene_changer.h
View File

@ -46,11 +46,11 @@ class MIDISceneChanger : public SceneChanger
/** Signal emitted whenever any relevant MIDI input is detected.
*/
PBD::Signal0<void> MIDIInputActivity;
PBD::Signal<void()> MIDIInputActivity;
/** Signal emitted whenever any relevant MIDI output is sent.
*/
PBD::Signal0<void> MIDIOutputActivity;
PBD::Signal<void()> MIDIOutputActivity;
private:
typedef std::multimap<samplepos_t,std::shared_ptr<MIDISceneChange> > Scenes;

8
libs/ardour/ardour/midi_source.h
View File

@ -178,7 +178,7 @@ class LIBARDOUR_API MidiSource : virtual public Source
void invalidate(const WriterLock& lock);
/** Thou shalt not emit this directly, use invalidate() instead. */
mutable PBD::Signal1<void, bool> Invalidated;
mutable PBD::Signal<void(bool)> Invalidated;
void set_note_mode(const WriterLock& lock, NoteMode mode);
@ -197,11 +197,11 @@ class LIBARDOUR_API MidiSource : virtual public Source
void copy_automation_state_from (MidiSource *);
/** Emitted when a different MidiModel is set */
PBD::Signal0<void> ModelChanged;
PBD::Signal<void()> ModelChanged;
/** Emitted when a parameter's interpolation style is changed */
PBD::Signal2<void, Evoral::Parameter, AutomationList::InterpolationStyle> InterpolationChanged;
PBD::Signal<void(Evoral::Parameter, AutomationList::InterpolationStyle)> InterpolationChanged;
/** Emitted when a parameter's automation state is changed */
PBD::Signal2<void, Evoral::Parameter, AutoState> AutomationStateChanged;
PBD::Signal<void(Evoral::Parameter, AutoState)> AutomationStateChanged;
protected:
virtual void flush_midi(const WriterLock& lock) = 0;

6
libs/ardour/ardour/midi_track.h
View File

@ -99,7 +99,7 @@ public:
void set_step_editing (bool yn);
MidiRingBuffer<samplepos_t>& step_edit_ring_buffer() { return _step_edit_ring_buffer; }
PBD::Signal1<void,bool> StepEditStatusChange;
PBD::Signal<void(bool)> StepEditStatusChange;
std::shared_ptr<SMFSource> write_source (uint32_t n = 0);
@ -121,7 +121,7 @@ public:
std::shared_ptr<MidiPlaylist> midi_playlist ();
PBD::Signal1<void, std::weak_ptr<MidiSource> > DataRecorded;
PBD::Signal<void(std::weak_ptr<MidiSource> )> DataRecorded;
std::shared_ptr<MidiBuffer> get_gui_feed_buffer () const;
MonitorState monitoring_state () const;
@ -134,7 +134,7 @@ public:
void set_input_active (bool);
bool input_active () const;
PBD::Signal0<void> InputActiveChanged;
PBD::Signal<void()> InputActiveChanged;
void set_restore_pgm_on_load (bool yn);
bool restore_pgm_on_load () const;

2
libs/ardour/ardour/mixer_scene.h
View File

@ -49,7 +49,7 @@ public:
XMLNode& get_state () const;
int set_state (XMLNode const&, int version);
static PBD::Signal0<void> Change;
static PBD::Signal<void()> Change;
private:
typedef std::map<PBD::ID, double> ControllableValueMap;

2
libs/ardour/ardour/monitor_port.h
View File

@ -47,7 +47,7 @@ public:
void set_active_monitors (std::list <std::string> const&);
void clear_ports (bool instantly);
PBD::Signal2<void, std::string, bool> MonitorInputChanged;
PBD::Signal<void(std::string, bool)> MonitorInputChanged;
protected:
friend class PortManager;

2
libs/ardour/ardour/monitor_processor.h
View File

@ -157,7 +157,7 @@ public:
bool monitor_active () const { return _monitor_active; }
PBD::Signal0<void> Changed;
PBD::Signal<void()> Changed;
std::shared_ptr<PBD::Controllable> channel_cut_control (uint32_t) const;
std::shared_ptr<PBD::Controllable> channel_dim_control (uint32_t) const;

2
libs/ardour/ardour/mute_master.h
View File

@ -75,7 +75,7 @@ public:
void set_muted_by_masters (bool);
PBD::Signal0<void> MutePointChanged;
PBD::Signal<void()> MutePointChanged;
XMLNode& get_state() const;
int set_state(const XMLNode&, int version);

2
libs/ardour/ardour/muteable.h
View File

@ -40,7 +40,7 @@ public:
return _mute_master;
}
PBD::Signal0<void> mute_points_changed;
PBD::Signal<void()> mute_points_changed;
protected:
std::shared_ptr<MuteMaster> _mute_master;

2
libs/ardour/ardour/pannable.h
View File

@ -53,7 +53,7 @@ public:
void set_automation_state (AutoState);
AutoState automation_state() const { return _auto_state; }
PBD::Signal1<void, AutoState> automation_state_changed;
PBD::Signal<void(AutoState)> automation_state_changed;
bool automation_playback() const {
return (_auto_state & Play) || ((_auto_state & (Touch | Latch)) && !touching());

2
libs/ardour/ardour/panner.h
View File

@ -103,7 +103,7 @@ public:
virtual void reset () = 0;
/* azimut, width or elevation updated -> recalc signal_position -> emit Changed */
PBD::Signal0<void> SignalPositionChanged;
PBD::Signal<void()> SignalPositionChanged;
/**
* Pan some input buffers to a number of output buffers.

4
libs/ardour/ardour/panner_shell.h
View File

@ -64,8 +64,8 @@ public:
XMLNode& get_state () const;
int set_state (const XMLNode&, int version);
PBD::Signal0<void> PannableChanged; /* Pannable changed -- l*/
PBD::Signal0<void> Changed; /* panner and/or outputs count and/or bypass state changed */
PBD::Signal<void()> PannableChanged; /* Pannable changed -- l*/
PBD::Signal<void()> Changed; /* panner and/or outputs count and/or bypass state changed */
std::shared_ptr<Panner> panner() const { return _panner; }
std::shared_ptr<Pannable> pannable() const { return _panlinked ? _pannable_route : _pannable_internal; }

16
libs/ardour/ardour/playlist.h
View File

@ -246,20 +246,20 @@ public:
virtual int set_state (const XMLNode&, int version);
XMLNode& get_template ();
PBD::Signal1<void, bool> InUse;
PBD::Signal0<void> ContentsChanged;
PBD::Signal1<void, std::weak_ptr<Region> > RegionAdded;
PBD::Signal1<void, std::weak_ptr<Region> > RegionRemoved;
PBD::Signal0<void> NameChanged;
PBD::Signal0<void> LayeringChanged;
PBD::Signal<void(bool)> InUse;
PBD::Signal<void()> ContentsChanged;
PBD::Signal<void(std::weak_ptr<Region> )> RegionAdded;
PBD::Signal<void(std::weak_ptr<Region> )> RegionRemoved;
PBD::Signal<void()> NameChanged;
PBD::Signal<void()> LayeringChanged;
/** Emitted when regions have moved (not when regions have only been trimmed) */
PBD::Signal2<void,std::list< Temporal::RangeMove> const &, bool> RangesMoved;
PBD::Signal<void(std::list< Temporal::RangeMove> const &, bool)> RangesMoved;
/** Emitted when regions are extended; the ranges passed are the new extra time ranges
that these regions now occupy.
*/
PBD::Signal1<void,std::list< Temporal::Range> const &> RegionsExtended;
PBD::Signal<void(std::list< Temporal::Range> const &)> RegionsExtended;
static std::string bump_name (std::string old_name, Session&);

2
libs/ardour/ardour/playlist_factory.h
View File

@ -31,7 +31,7 @@ class Session;
class LIBARDOUR_API PlaylistFactory {
public:
static PBD::Signal1<void,std::shared_ptr<Playlist>> PlaylistCreated;
static PBD::Signal<void(std::shared_ptr<Playlist>)> PlaylistCreated;
static std::shared_ptr<Playlist> create (Session&, const XMLNode&, bool hidden = false);
static std::shared_ptr<Playlist> create (DataType type, Session&, std::string name, bool hidden = false);

28
libs/ardour/ardour/plugin.h
View File

@ -213,17 +213,17 @@ public:
virtual bool has_inline_display () { return false; }
virtual bool inline_display_in_gui () { return false; }
virtual Display_Image_Surface* render_inline_display (uint32_t, uint32_t) { return NULL; }
PBD::Signal0<void> QueueDraw;
PBD::Signal<void()> QueueDraw;
virtual bool has_midnam () { return false; }
virtual bool read_midnam () { return false; }
virtual std::string midnam_model () { return ""; }
PBD::Signal0<void> UpdateMidnam;
PBD::Signal0<void> UpdatedMidnam;
PBD::Signal<void()> UpdateMidnam;
PBD::Signal<void()> UpdatedMidnam;
virtual bool knows_bank_patch () { return false; }
virtual uint32_t bank_patch (uint8_t chn) { return UINT32_MAX; }
PBD::Signal1<void, uint8_t> BankPatchChange;
PBD::Signal<void(uint8_t)> BankPatchChange;
struct PresetRecord {
PresetRecord () : valid (false) { }
@ -289,22 +289,22 @@ public:
virtual int first_user_preset_index () const { return 0; }
/** Emitted when a preset is added or removed, respectively */
PBD::Signal0<void> PresetAdded;
PBD::Signal0<void> PresetRemoved;
PBD::Signal<void()> PresetAdded;
PBD::Signal<void()> PresetRemoved;
/** Emitted when any preset has been changed */
static PBD::Signal3<void, std::string, Plugin*, bool> PresetsChanged;
static PBD::Signal<void(std::string, Plugin*, bool)> PresetsChanged;
/** Emitted when a preset has been loaded */
PBD::Signal0<void> PresetLoaded;
PBD::Signal<void()> PresetLoaded;
/** Emitted when a parameter is altered in a way that may have
* changed the settings with respect to any loaded preset.
*/
PBD::Signal0<void> PresetDirty;
PBD::Signal<void()> PresetDirty;
/** Emitted for preset-load to set a control-port */
PBD::Signal2<void, uint32_t, float> PresetPortSetValue;
PBD::Signal<void(uint32_t, float)> PresetPortSetValue;
/** @return true if plugin has a custom plugin GUI */
virtual bool has_editor () const = 0;
@ -312,7 +312,7 @@ public:
/** Emitted when a parameter is altered by something outside of our
* control, most typically a Plugin GUI/editor
*/
PBD::Signal2<void, uint32_t, float> ParameterChangedExternally;
PBD::Signal<void(uint32_t, float)> ParameterChangedExternally;
virtual bool reconfigure_io (ChanCount /*in*/, ChanCount /*aux_in*/, ChanCount /*out*/) { return true; }
virtual bool match_variable_io (ChanCount& /*in*/, ChanCount& /*aux_in*/, ChanCount& /*out*/) { return false; }
@ -377,10 +377,10 @@ public:
virtual void announce_property_values () {}
/** Emitted when a property is changed in the plugin. */
PBD::Signal2<void, uint32_t, Variant> PropertyChanged;
PBD::Signal<void(uint32_t, Variant)> PropertyChanged;
PBD::Signal1<void, uint32_t> StartTouch;
PBD::Signal1<void, uint32_t> EndTouch;
PBD::Signal<void(uint32_t)> StartTouch;
PBD::Signal<void(uint32_t)> EndTouch;
protected:
friend class PluginInsert;

8
libs/ardour/ardour/plugin_insert.h
View File

@ -264,10 +264,10 @@ public:
out = _configured_out;
}
PBD::Signal2<void,BufferSet*, BufferSet*> AnalysisDataGathered;
PBD::Signal0<void> PluginIoReConfigure;
PBD::Signal0<void> PluginMapChanged;
PBD::Signal0<void> PluginConfigChanged;
PBD::Signal<void(BufferSet*, BufferSet*)> AnalysisDataGathered;
PBD::Signal<void()> PluginIoReConfigure;
PBD::Signal<void()> PluginMapChanged;
PBD::Signal<void()> PluginConfigChanged;
protected:
XMLNode& state () const;

10
libs/ardour/ardour/plugin_manager.h
View File

@ -168,19 +168,19 @@ public:
/** plugins were added to or removed from one of the PluginInfoLists
* This implies PluginScanLogChanged.
*/
PBD::Signal0<void> PluginListChanged;
PBD::Signal<void()> PluginListChanged;
/** Plugin Statistics (use-count, recently-used) changed */
PBD::Signal0<void> PluginStatsChanged;
PBD::Signal<void()> PluginStatsChanged;
/** Plugin ScanLog changed */
PBD::Signal0<void> PluginScanLogChanged;
PBD::Signal<void()> PluginScanLogChanged;
/** A single plugin's Hidden/Favorite status changed */
PBD::Signal3<void, ARDOUR::PluginType, std::string, PluginStatusType> PluginStatusChanged; //PluginType t, string id, string tag
PBD::Signal<void(ARDOUR::PluginType, std::string, PluginStatusType)> PluginStatusChanged; //PluginType t, string id, string tag
/** A single plugin's Tags status changed */
PBD::Signal3<void, ARDOUR::PluginType, std::string, std::string> PluginTagChanged; //PluginType t, string id, string tag
PBD::Signal<void(ARDOUR::PluginType, std::string, std::string)> PluginTagChanged; //PluginType t, string id, string tag
private:
typedef std::shared_ptr<PluginScanLogEntry> PSLEPtr;

10
libs/ardour/ardour/port.h
View File

@ -141,12 +141,12 @@ public:
void decrement_internal_connections ();
PBD::Signal1<void,bool> MonitorInputChanged;
PBD::Signal3<void,std::shared_ptr<Port>,std::shared_ptr<Port>, bool > ConnectedOrDisconnected;
PBD::Signal<void(bool)> MonitorInputChanged;
PBD::Signal<void(std::shared_ptr<Port>,std::shared_ptr<Port>, bool )> ConnectedOrDisconnected;
static PBD::Signal0<void> PortDrop;
static PBD::Signal0<void> PortSignalDrop;
static PBD::Signal0<void> ResamplerQualityChanged;
static PBD::Signal<void()> PortDrop;
static PBD::Signal<void()> PortSignalDrop;
static PBD::Signal<void()> ResamplerQualityChanged;
static void set_varispeed_ratio (double s); //< varispeed playback
static bool set_engine_ratio (double session, double engine); //< SR mismatch

14
libs/ardour/ardour/port_manager.h
View File

@ -243,26 +243,26 @@ public:
void remove_midi_port_flags (std::string const&, MidiPortFlags);
/** Emitted if the list of ports to be used for MIDI selection tracking changes */
PBD::Signal0<void> MidiSelectionPortsChanged;
PBD::Signal<void()> MidiSelectionPortsChanged;
/** Emitted if anything other than the selection property for a MIDI port changes */
PBD::Signal0<void> MidiPortInfoChanged;
PBD::Signal<void()> MidiPortInfoChanged;
/** Emitted if pretty-name of a port changed */
PBD::Signal1<void, std::string> PortPrettyNameChanged;
PBD::Signal<void(std::string)> PortPrettyNameChanged;
/** Emitted if the backend notifies us of a graph order event */
PBD::Signal0<void> GraphReordered;
PBD::Signal<void()> GraphReordered;
/** Emitted if a Port is registered or unregistered */
PBD::Signal0<void> PortRegisteredOrUnregistered;
PBD::Signal<void()> PortRegisteredOrUnregistered;
/** Emitted if a Port is connected or disconnected.
* The Port parameters are the ports being connected / disconnected, or 0 if they are not known to Ardour.
* The std::string parameters are the (long) port names.
* The bool parameter is true if ports were connected, or false for disconnected.
*/
PBD::Signal5<void, std::weak_ptr<Port>, std::string, std::weak_ptr<Port>, std::string, bool> PortConnectedOrDisconnected;
PBD::Signal<void(std::weak_ptr<Port>, std::string, std::weak_ptr<Port>, std::string, bool)> PortConnectedOrDisconnected;
PBD::Signal3<void, DataType, std::vector<std::string>, bool> PhysInputChanged;
PBD::Signal<void(DataType, std::vector<std::string>, bool)> PhysInputChanged;
/* Input port meters and monitors */
void reset_input_meters ();

2
libs/ardour/ardour/presentation_info.h
View File

@ -260,7 +260,7 @@ class LIBARDOUR_API PresentationInfo : public PBD::Stateful
/* for things concerned about *any* PresentationInfo.
*/
static PBD::Signal1<void,PBD::PropertyChange const &> Change;
static PBD::Signal<void(PBD::PropertyChange const &)> Change;
static void send_static_change (const PBD::PropertyChange&);
static void make_property_quarks ();

12
libs/ardour/ardour/processor.h
View File

@ -148,16 +148,16 @@ class LIBARDOUR_API Processor : public SessionObject, public Automatable, public
virtual void set_pre_fader (bool);
virtual bool get_pre_fader () const { return _pre_fader; }
PBD::Signal0<void> ActiveChanged;
PBD::Signal0<void> BypassableChanged;
PBD::Signal2<void,ChanCount,ChanCount> ConfigurationChanged;
PBD::Signal<void()> ActiveChanged;
PBD::Signal<void()> BypassableChanged;
PBD::Signal<void(ChanCount,ChanCount)> ConfigurationChanged;
/* cross-thread signals.
* This allows control-surfaces to show/hide a plugin GUI.
*/
PBD::Signal0<void> ToggleUI;
PBD::Signal0<void> ShowUI;
PBD::Signal0<void> HideUI;
PBD::Signal<void()> ToggleUI;
PBD::Signal<void()> ShowUI;
PBD::Signal<void()> HideUI;
ProcessorWindowProxy * window_proxy () const { return _window_proxy; }
void set_window_proxy (ProcessorWindowProxy* wp) { _window_proxy = wp; }

4
libs/ardour/ardour/region.h
View File

@ -111,9 +111,9 @@ public:
static void make_property_quarks ();
static PBD::Signal2<void,std::shared_ptr<RegionList>, const PBD::PropertyChange&> RegionsPropertyChanged;
static PBD::Signal<void(std::shared_ptr<RegionList>, const PBD::PropertyChange&)> RegionsPropertyChanged;
PBD::Signal0<void> RegionFxChanged;
PBD::Signal<void()> RegionFxChanged;
typedef std::map <PBD::PropertyChange, RegionList> ChangeMap;

2
libs/ardour/ardour/region_factory.h
View File

@ -64,7 +64,7 @@ public:
* itself, to permit dynamic_cast<> to be used to
* infer the type of Region.
*/
static PBD::Signal1<void, std::shared_ptr<Region> > CheckNewRegion;
static PBD::Signal<void(std::shared_ptr<Region> )> CheckNewRegion;
/** create a "pure copy" of Region \p other */
static std::shared_ptr<Region> create (std::shared_ptr<const Region> other, bool announce, bool fork = false, ThawList* tl = 0);

24
libs/ardour/ardour/route.h
View File

@ -377,9 +377,9 @@ public:
samplecnt_t signal_latency() const { return _signal_latency; }
samplecnt_t playback_latency (bool incl_downstream = false) const;
PBD::Signal0<void> active_changed;
PBD::Signal0<void> denormal_protection_changed;
PBD::Signal0<void> comment_changed;
PBD::Signal<void()> active_changed;
PBD::Signal<void()> denormal_protection_changed;
PBD::Signal<void()> comment_changed;
bool is_track();
@ -388,7 +388,7 @@ public:
* nubers < 0 indicate busses
* zero is reserved for unnumbered special busses.
* */
PBD::Signal0<void> track_number_changed;
PBD::Signal<void()> track_number_changed;
int64_t track_number() const { return _track_number; }
void set_track_number(int64_t tn) {
@ -405,23 +405,23 @@ public:
};
/** ask GUI about port-count, fan-out when adding instrument */
static PBD::Signal3<int, std::shared_ptr<Route>, std::shared_ptr<PluginInsert>, PluginSetupOptions > PluginSetup;
static PBD::Signal<int(std::shared_ptr<Route>, std::shared_ptr<PluginInsert>, PluginSetupOptions )> PluginSetup;
/** used to signal the GUI to fan-out (track-creation) */
static PBD::Signal1<void, std::weak_ptr<Route> > FanOut;
static PBD::Signal<void(std::weak_ptr<Route> )> FanOut;
/** the processors have changed; the parameter indicates what changed */
PBD::Signal1<void,RouteProcessorChange> processors_changed;
PBD::Signal1<void,void*> record_enable_changed;
PBD::Signal<void(RouteProcessorChange)> processors_changed;
PBD::Signal<void(void*)> record_enable_changed;
/** a processor's latency has changed
* (emitted from PluginInsert::latency_changed)
*/
PBD::Signal0<void> processor_latency_changed;
PBD::Signal<void()> processor_latency_changed;
/** the metering point has changed */
PBD::Signal0<void> meter_change;
PBD::Signal<void()> meter_change;
/** Emitted with the process lock held */
PBD::Signal0<void> io_changed;
PBD::Signal<void()> io_changed;
/* stateful */
XMLNode& get_state() const;
@ -436,7 +436,7 @@ public:
int save_as_template (const std::string& path, const std::string& name, const std::string& description );
PBD::Signal1<void,void*> SelectedChanged;
PBD::Signal<void(void*)> SelectedChanged;
int add_aux_send (std::shared_ptr<Route>, std::shared_ptr<Processor>);
int add_foldback_send (std::shared_ptr<Route>, bool post_fader);

4
libs/ardour/ardour/route_group.h
View File

@ -145,9 +145,9 @@ public:
std::shared_ptr<RouteList> route_list() { return routes; }
/** Emitted when a route has been added to this group */
PBD::Signal2<void, RouteGroup *, std::weak_ptr<ARDOUR::Route> > RouteAdded;
PBD::Signal<void(RouteGroup *, std::weak_ptr<ARDOUR::Route> )> RouteAdded;
/** Emitted when a route has been removed from this group */
PBD::Signal2<void, RouteGroup *, std::weak_ptr<ARDOUR::Route> > RouteRemoved;
PBD::Signal<void(RouteGroup *, std::weak_ptr<ARDOUR::Route> )> RouteRemoved;
XMLNode& get_state () const;

2
libs/ardour/ardour/route_group_member.h
View File

@ -37,7 +37,7 @@ class LIBARDOUR_API RouteGroupMember
RouteGroup* route_group () const { return _route_group; }
/** Emitted when this member joins or leaves a route group */
PBD::Signal0<void> route_group_changed;
PBD::Signal<void()> route_group_changed;
protected:
RouteGroup* _route_group;

4
libs/ardour/ardour/scene_change.h
View File

@ -42,8 +42,8 @@ class SceneChange : public PBD::Stateful
bool active () const { return _active; }
void set_active (bool);
PBD::Signal0<void> ColorChanged;
PBD::Signal0<void> ActiveChanged;
PBD::Signal<void()> ColorChanged;
PBD::Signal<void()> ActiveChanged;
protected:
/* derived classes are responsible for serializing & deserializing this value */

6
libs/ardour/ardour/send.h
View File

@ -54,8 +54,8 @@ public:
virtual void set_delay_out (samplecnt_t, size_t bus = 0) = 0;
virtual void update_delaylines (bool rt_ok) = 0;
static PBD::Signal0<void> ChangedLatency;
static PBD::Signal0<void> QueueUpdate;
static PBD::Signal<void()> ChangedLatency;
static PBD::Signal<void()> QueueUpdate;
protected:
samplecnt_t _delay_in;
@ -78,7 +78,7 @@ public:
int set_state(const XMLNode&, int version);
PBD::Signal0<void> SelfDestruct;
PBD::Signal<void()> SelfDestruct;
void set_remove_on_disconnect (bool b) { _remove_on_disconnect = b; }
bool remove_on_disconnect () const { return _remove_on_disconnect; }

128
libs/ardour/ardour/session.h
View File

@ -261,14 +261,14 @@ public:
void end_unnamed_status () const;
PBD::Signal0<void> DirtyChanged;
PBD::Signal<void()> DirtyChanged;
const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
static PBD::Signal1<void,std::string> Dialog;
static PBD::Signal<void(std::string)> Dialog;
PBD::Signal0<void> BatchUpdateStart;
PBD::Signal0<void> BatchUpdateEnd;
PBD::Signal<void()> BatchUpdateStart;
PBD::Signal<void()> BatchUpdateEnd;
int ensure_subdirs ();
@ -417,24 +417,24 @@ public:
void maybe_write_autosave ();
PBD::Signal1<void, int> SurroundObjectCountChanged;
PBD::Signal<void(int)> SurroundObjectCountChanged;
/* Emitted when all i/o connections are complete */
PBD::Signal0<void> IOConnectionsComplete;
PBD::Signal<void()> IOConnectionsComplete;
/* Record status signals */
PBD::Signal0<void> RecordStateChanged; /* signals changes in recording state (i.e. are we recording) */
PBD::Signal<void()> RecordStateChanged; /* signals changes in recording state (i.e. are we recording) */
/* XXX may 2015: paul says: it isn't clear to me that this has semantics that cannot be inferrred
from the previous signal and session state.
*/
PBD::Signal0<void> RecordArmStateChanged; /* signals changes in recording arming */
PBD::Signal<void()> RecordArmStateChanged; /* signals changes in recording arming */
PBD::Signal0<void> UpdateRouteRecordState; /* signals potential change in route recording arming */
PBD::Signal<void()> UpdateRouteRecordState; /* signals potential change in route recording arming */
/* Emited when session is loaded */
PBD::Signal0<void> SessionLoaded;
PBD::Signal<void()> SessionLoaded;
/* Transport mechanism signals */
@ -445,38 +445,38 @@ public:
* - start (from the process thread)
* - engine halted
*/
PBD::Signal0<void> TransportStateChange;
PBD::Signal<void()> TransportStateChange;
PBD::Signal1<void,samplepos_t> PositionChanged; /* sent after any non-sequential motion */
PBD::Signal1<void,samplepos_t> Xrun;
PBD::Signal0<void> TransportLooped;
PBD::Signal<void(samplepos_t)> PositionChanged; /* sent after any non-sequential motion */
PBD::Signal<void(samplepos_t)> Xrun;
PBD::Signal<void()> TransportLooped;
/** emitted when a locate has occurred */
PBD::Signal0<void> Located;
PBD::Signal<void()> Located;
PBD::Signal1<void,RouteList&> RouteAdded;
PBD::Signal<void(RouteList&)> RouteAdded;
/** Emitted when a property of one of our route groups changes.
* The parameter is the RouteGroup that has changed.
*/
PBD::Signal1<void, RouteGroup *> RouteGroupPropertyChanged;
PBD::Signal<void(RouteGroup *)> RouteGroupPropertyChanged;
/** Emitted when a route is added to one of our route groups.
* First parameter is the RouteGroup, second is the route.
*/
PBD::Signal2<void, RouteGroup *, std::weak_ptr<Route> > RouteAddedToRouteGroup;
PBD::Signal<void(RouteGroup *, std::weak_ptr<Route> )> RouteAddedToRouteGroup;
/** Emitted when a route is removed from one of our route groups.
* First parameter is the RouteGroup, second is the route.
*/
PBD::Signal2<void, RouteGroup *, std::weak_ptr<Route> > RouteRemovedFromRouteGroup;
PBD::Signal<void(RouteGroup *, std::weak_ptr<Route> )> RouteRemovedFromRouteGroup;
/** Emitted when a foldback send is created or deleted
*/
PBD::Signal0<void> FBSendsChanged;
PBD::Signal<void()> FBSendsChanged;
/* Step Editing status changed */
PBD::Signal1<void,bool> StepEditStatusChange;
PBD::Signal<void(bool)> StepEditStatusChange;
/* Timecode state signals */
PBD::Signal0<void> MtcOrLtcInputPortChanged;
PBD::Signal<void()> MtcOrLtcInputPortChanged;
void queue_event (SessionEvent*);
@ -542,9 +542,9 @@ public:
Locations *locations() { return _locations; }
PBD::Signal1<void,Location*> auto_loop_location_changed;
PBD::Signal1<void,Location*> auto_punch_location_changed;
PBD::Signal0<void> locations_modified;
PBD::Signal<void(Location*)> auto_loop_location_changed;
PBD::Signal<void(Location*)> auto_punch_location_changed;
PBD::Signal<void()> locations_modified;
void set_auto_punch_location (Location *);
void set_auto_loop_location (Location *);
@ -560,7 +560,7 @@ public:
samplecnt_t worst_latency_preroll () const;
samplecnt_t worst_latency_preroll_buffer_size_ceil () const;
PBD::Signal1<void, bool> LatencyUpdated;
PBD::Signal<void(bool)> LatencyUpdated;
struct SaveAs {
std::string new_parent_folder; /* parent folder where new session folder will be created */
@ -583,7 +583,7 @@ public:
* Handler should return true for save-as to continue, or false
* to stop (and remove all evidence of partial save-as).
*/
PBD::Signal3<bool,float,int64_t,int64_t> Progress;
PBD::Signal<bool(float,int64_t,int64_t)> Progress;
/* if save_as() returns non-zero, this string will indicate the reason why.
*/
@ -632,8 +632,8 @@ public:
void set_nsm_state (bool state) { _under_nsm_control = state; }
bool save_default_options ();
PBD::Signal1<void,std::string> StateSaved;
PBD::Signal0<void> StateReady;
PBD::Signal<void(std::string)> StateSaved;
PBD::Signal<void()> StateReady;
/* emitted when session needs to be saved due to some internal
* event or condition (i.e. not in response to a user request).
@ -643,12 +643,12 @@ public:
*
* Argument is the snapshot name to use when saving.
*/
PBD::Signal1<void,std::string> SaveSessionRequested;
PBD::Signal<void(std::string)> SaveSessionRequested;
/* emitted during a session save to allow other entities to add state, via
* extra XML, to the session state
*/
PBD::Signal0<void> SessionSaveUnderway;
PBD::Signal<void()> SessionSaveUnderway;
std::vector<std::string> possible_states() const;
static std::vector<std::string> possible_states (std::string path);
@ -710,9 +710,9 @@ public:
RouteGroup* route_group_by_name (std::string);
RouteGroup& all_route_group() const;
PBD::Signal1<void,RouteGroup*> route_group_added;
PBD::Signal0<void> route_group_removed;
PBD::Signal0<void> route_groups_reordered;
PBD::Signal<void(RouteGroup*)> route_group_added;
PBD::Signal<void()> route_group_removed;
PBD::Signal<void()> route_groups_reordered;
void foreach_route_group (boost::function<void(RouteGroup*)> f) {
for (std::list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
@ -800,8 +800,8 @@ public:
samplecnt_t convert_to_samples (AnyTime const & position);
samplecnt_t any_duration_to_samples (samplepos_t position, AnyTime const & duration);
static PBD::Signal1<void, samplepos_t> StartTimeChanged;
static PBD::Signal1<void, samplepos_t> EndTimeChanged;
static PBD::Signal<void(samplepos_t)> StartTimeChanged;
static PBD::Signal<void(samplepos_t)> EndTimeChanged;
void request_sync_source (std::shared_ptr<TransportMaster>);
bool synced_to_engine() const;
@ -829,7 +829,7 @@ public:
bool punch_is_possible () const;
bool loop_is_possible () const;
PBD::Signal0<void> PunchLoopConstraintChange;
PBD::Signal<void()> PunchLoopConstraintChange;
void maybe_update_tempo_from_midiclock_tempo (float bpm);
@ -857,8 +857,8 @@ public:
int start_audio_export (samplepos_t position, bool realtime = false, bool region_export = false);
PBD::Signal1<int, samplecnt_t> ProcessExport;
static PBD::Signal4<void, std::string, std::string, bool, samplepos_t> Exported;
PBD::Signal<int(samplecnt_t)> ProcessExport;
static PBD::Signal<void(std::string, std::string, bool, samplepos_t)> Exported;
void add_source (std::shared_ptr<Source>);
void remove_source (std::weak_ptr<Source>, bool drop_references = true);
@ -878,26 +878,26 @@ public:
0 for "yes, delete this playlist",
1 for "no, don't delete this playlist".
*/
static PBD::Signal1<int,std::shared_ptr<Playlist> > AskAboutPlaylistDeletion;
static PBD::Signal<int(std::shared_ptr<Playlist> )> AskAboutPlaylistDeletion;
/** handlers should return 0 for "ignore the rate mismatch",
!0 for "do not use this session"
*/
static PBD::Signal2<int, samplecnt_t, samplecnt_t> AskAboutSampleRateMismatch;
static PBD::Signal<int(samplecnt_t, samplecnt_t)> AskAboutSampleRateMismatch;
/** non interactive message */
static PBD::Signal2<void, samplecnt_t, samplecnt_t> NotifyAboutSampleRateMismatch;
static PBD::Signal<void(samplecnt_t, samplecnt_t)> NotifyAboutSampleRateMismatch;
/** handlers should return !0 for use pending state, 0 for ignore it.
*/
static PBD::Signal0<int> AskAboutPendingState;
static PBD::Signal<int()> AskAboutPendingState;
/** after loading a session, once all ports have been created and connected
* signal is emitted to let objects that need to do some housekeeping
* post-connect.
*/
static PBD::Signal0<void> AfterConnect;
static PBD::Signal<void()> AfterConnect;
std::shared_ptr<AudioFileSource> create_audio_source_for_session (
size_t, std::string const &, uint32_t);
@ -923,7 +923,7 @@ public:
void cancel_audition ();
bool is_auditioning () const;
PBD::Signal1<void,bool> AuditionActive;
PBD::Signal<void(bool)> AuditionActive;
/* session script */
void register_lua_function (const std::string&, const std::string&, const LuaScriptParamList&);
@ -932,10 +932,10 @@ public:
uint32_t registered_lua_function_count () const { return _n_lua_scripts; }
void scripts_changed (); // called from lua, updates _n_lua_scripts
PBD::Signal0<void> LuaScriptsChanged;
PBD::Signal<void()> LuaScriptsChanged;
/* I/O Plugin */
PBD::Signal0<void> IOPluginsChanged;
PBD::Signal<void()> IOPluginsChanged;
void load_io_plugin (std::shared_ptr<IOPlug>);
bool unload_io_plugin (std::shared_ptr<IOPlug>);
@ -986,15 +986,15 @@ public:
void set_exclusive_input_active (std::shared_ptr<RouteList> rt, bool onoff, bool flip_others = false);
PBD::Signal1<void,bool> SoloActive;
PBD::Signal0<void> SoloChanged;
PBD::Signal0<void> MuteChanged;
PBD::Signal0<void> IsolatedChanged;
PBD::Signal0<void> MonitorChanged;
PBD::Signal0<void> MonitorBusAddedOrRemoved;
PBD::Signal0<void> SurroundMasterAddedOrRemoved;
PBD::Signal<void(bool)> SoloActive;
PBD::Signal<void()> SoloChanged;
PBD::Signal<void()> MuteChanged;
PBD::Signal<void()> IsolatedChanged;
PBD::Signal<void()> MonitorChanged;
PBD::Signal<void()> MonitorBusAddedOrRemoved;
PBD::Signal<void()> SurroundMasterAddedOrRemoved;
PBD::Signal0<void> session_routes_reconnected;
PBD::Signal<void()> session_routes_reconnected;
/* monitor/master out */
int add_master_bus (ChanCount const&);
@ -1060,7 +1060,7 @@ public:
void remove_bundle (std::shared_ptr<Bundle>);
std::shared_ptr<Bundle> bundle_by_name (std::string) const;
PBD::Signal0<void> BundleAddedOrRemoved;
PBD::Signal<void()> BundleAddedOrRemoved;
void midi_panic ();
@ -1149,7 +1149,7 @@ public:
float opt
);
static PBD::Signal0<void> SendFeedback;
static PBD::Signal<void()> SendFeedback;
/* Speakers */
@ -1236,12 +1236,12 @@ public:
processing path. Until it is fixed (by the user) some (unspecified)
routes will not be run.
*/
static PBD::Signal0<void> FeedbackDetected;
static PBD::Signal<void()> FeedbackDetected;
/** Emitted when a graph sort has successfully completed, which means
that it has no feedback cycles.
*/
static PBD::Signal0<void> SuccessfulGraphSort;
static PBD::Signal<void()> SuccessfulGraphSort;
/* handlers can return an integer value:
0: config.set_audio_search_path() or config.set_midi_search_path() was used
@ -1252,19 +1252,19 @@ public:
-1: just mark this one missing
any other value: as -1
*/
static PBD::Signal3<int,Session*,std::string,DataType> MissingFile;
static PBD::Signal<int(Session*,std::string,DataType)> MissingFile;
void set_missing_file_replacement (const std::string& mfr) {
_missing_file_replacement = mfr;
}
/** Emitted when the session wants Ardour to quit */
static PBD::Signal0<void> Quit;
static PBD::Signal<void()> Quit;
/** Emitted when Ardour is asked to load a session in an older session
* format, and makes a backup copy.
*/
static PBD::Signal2<void,std::string,std::string> VersionMismatch;
static PBD::Signal<void(std::string,std::string)> VersionMismatch;
SceneChanger* scene_changer() const { return _scene_changer; }
@ -1963,8 +1963,8 @@ private:
public:
/* Emited when a new source is added to the session */
PBD::Signal1< void, std::weak_ptr<Source> > SourceAdded;
PBD::Signal1< void, std::weak_ptr<Source> > SourceRemoved;
PBD::Signal< void(std::weak_ptr<Source> )> SourceAdded;
PBD::Signal< void(std::weak_ptr<Source> )> SourceRemoved;
typedef std::map<PBD::ID,std::shared_ptr<Source> > SourceMap;

4
libs/ardour/ardour/slavable.h
View File

@ -53,14 +53,14 @@ public:
virtual void assign (std::shared_ptr<VCA>);
void unassign (std::shared_ptr<VCA>);
PBD::Signal2<void,std::shared_ptr<VCA>,bool> AssignmentChange;
PBD::Signal<void(std::shared_ptr<VCA>,bool)> AssignmentChange;
virtual std::shared_ptr<AutomationControl> automation_control (const Evoral::Parameter&) = 0;
static std::string xml_node_name;
/* signal sent VCAManager once assignment is possible */
static PBD::Signal1<void,VCAManager*> Assign;
static PBD::Signal<void(VCAManager*)> Assign;
std::vector<std::shared_ptr<VCA> > masters (VCAManager*) const;

2
libs/ardour/ardour/slavable_automation_control.h
View File

@ -70,7 +70,7 @@ public:
*/
int32_t get_boolean_masters () const;
PBD::Signal0<void> MasterStatusChange;
PBD::Signal<void()> MasterStatusChange;
void use_saved_master_ratios ();

6
libs/ardour/ardour/source.h
View File

@ -94,14 +94,14 @@ public:
virtual bool length_mutable() const { return false; }
static PBD::Signal1<void,Source*> SourceCreated;
static PBD::Signal<void(Source*)> SourceCreated;
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();
PBD::Signal0<void> AnalysisChanged;
PBD::Signal<void()> AnalysisChanged;
AnalysisFeatureList transients;
std::string get_transients_path() const;
@ -118,7 +118,7 @@ public:
bool remove_cue_marker (CueMarker const &);
bool rename_cue_marker (CueMarker&, std::string const &);
bool clear_cue_markers ();
PBD::Signal0<void> CueMarkersChanged;
PBD::Signal<void()> CueMarkersChanged;
virtual timepos_t natural_position() const { return _natural_position; }
virtual void set_natural_position (timepos_t const & pos);

2
libs/ardour/ardour/source_factory.h
View File

@ -40,7 +40,7 @@ public:
static void init ();
static void terminate ();
static PBD::Signal1<void, std::shared_ptr<Source>> SourceCreated;
static PBD::Signal<void(std::shared_ptr<Source>)> SourceCreated;
static std::shared_ptr<Source> create (Session&, const XMLNode& node, bool async = false);
static std::shared_ptr<Source> createSilent (Session&, const XMLNode& node, samplecnt_t, float sample_rate);

2
libs/ardour/ardour/speaker.h
View File

@ -40,7 +40,7 @@ public:
int id;
/** emitted when this speaker's position has changed */
PBD::Signal0<void> PositionChanged;
PBD::Signal<void()> PositionChanged;
private:
PBD::CartesianVector _coords;

2
libs/ardour/ardour/speakers.h
View File

@ -54,7 +54,7 @@ public:
XMLNode& get_state () const;
int set_state (const XMLNode&, int version);
PBD::Signal0<void> Changed;
PBD::Signal<void()> Changed;
protected:
std::vector<Speaker> _speakers;

4
libs/ardour/ardour/stripable.h
View File

@ -102,7 +102,7 @@ class LIBARDOUR_API Stripable : public SessionObject,
/* gui's call this for their own purposes. */
PBD::Signal2<void,std::string,void*> gui_changed;
PBD::Signal<void(std::string,void*)> gui_changed;
/* *************************************************************
* Pure interface begins here
@ -148,7 +148,7 @@ class LIBARDOUR_API Stripable : public SessionObject,
/* ACs mapped to any control have changed. API user is to drop references,
* and query mapped ctrl again
*/
PBD::Signal0<void> MappedControlsChanged;
PBD::Signal<void()> MappedControlsChanged;
/* "well-known" controls for sends to well-known busses in this route. Any or all may
* be null.

2
libs/ardour/ardour/surround_pannable.h
View File

@ -55,7 +55,7 @@ public:
void set_automation_state (AutoState);
AutoState automation_state() const { return _auto_state; }
PBD::Signal1<void, AutoState> automation_state_changed;
PBD::Signal<void(AutoState)> automation_state_changed;
bool automation_playback() const {
return (_auto_state & Play) || ((_auto_state & (Touch | Latch)) && !touching());

4
libs/ardour/ardour/surround_send.h
View File

@ -41,8 +41,8 @@ public:
uint32_t n_pannables () const;
PBD::Signal0<void> NPannablesChanged;
PBD::Signal0<void> PanChanged;
PBD::Signal<void()> NPannablesChanged;
PBD::Signal<void()> PanChanged;
/* Route/processor interface */
bool can_support_io_configuration (const ChanCount& in, ChanCount& out) { return in == out; }

2
libs/ardour/ardour/tailtime.h
View File

@ -50,7 +50,7 @@ public:
void unset_user_tailtime ();
void set_user_tailtime (samplecnt_t val);
PBD::Signal0<void> TailTimeChanged;
PBD::Signal<void()> TailTimeChanged;
protected:
int set_state (const XMLNode& node, int version);

12
libs/ardour/ardour/track.h
View File

@ -183,12 +183,12 @@ public:
void time_domain_changed ();
PBD::Signal0<void> FreezeChange;
PBD::Signal0<void> PlaylistChanged;
PBD::Signal0<void> PlaylistAdded;
PBD::Signal0<void> SpeedChanged;
PBD::Signal0<void> AlignmentStyleChanged;
PBD::Signal0<void> ChanCountChanged;
PBD::Signal<void()> FreezeChange;
PBD::Signal<void()> PlaylistChanged;
PBD::Signal<void()> PlaylistAdded;
PBD::Signal<void()> SpeedChanged;
PBD::Signal<void()> AlignmentStyleChanged;
PBD::Signal<void()> ChanCountChanged;
protected:
XMLNode& state (bool save_template) const;

6
libs/ardour/ardour/transport_master_manager.h
View File

@ -53,8 +53,8 @@ class LIBARDOUR_API TransportMasterManager : public boost::noncopyable
int remove (std::string const & name);
void clear (bool emit = true);
PBD::Signal1<void,std::shared_ptr<TransportMaster> > Added;
PBD::Signal1<void,std::shared_ptr<TransportMaster> > Removed; // null argument means "clear"
PBD::Signal<void(std::shared_ptr<TransportMaster> )> Added;
PBD::Signal<void(std::shared_ptr<TransportMaster> )> Removed; // null argument means "clear"
double pre_process_transport_masters (pframes_t, samplepos_t session_transport_position);
@ -66,7 +66,7 @@ class LIBARDOUR_API TransportMasterManager : public boost::noncopyable
int set_current (SyncSource);
int set_current (std::string const &);
PBD::Signal2<void,std::shared_ptr<TransportMaster>, std::shared_ptr<TransportMaster> > CurrentChanged;
PBD::Signal<void(std::shared_ptr<TransportMaster>, std::shared_ptr<TransportMaster> )> CurrentChanged;
int set_state (XMLNode const &, int);
XMLNode& get_state() const;

24
libs/ardour/ardour/triggerbox.h
View File

@ -300,8 +300,8 @@ class LIBARDOUR_API Trigger : public PBD::Stateful {
virtual void arm();
virtual void disarm ();
bool armed() const { return _armed; }
PBD::Signal0<void> ArmChanged;
static PBD::Signal1<void,Trigger const *> TriggerArmChanged;
PBD::Signal<void()> ArmChanged;
static PBD::Signal<void(Trigger const *)> TriggerArmChanged;
Temporal::BBT_Argument compute_start (Temporal::TempoMap::SharedPtr const &, samplepos_t start, samplepos_t end, Temporal::BBT_Offset const & q, samplepos_t& start_samples, bool& will_start);
virtual timepos_t compute_end (Temporal::TempoMap::SharedPtr const &, Temporal::BBT_Time const &, samplepos_t, Temporal::Beats &) = 0;
@ -431,7 +431,7 @@ class LIBARDOUR_API Trigger : public PBD::Stateful {
virtual void check_edit_swap (timepos_t const & time, bool playing, BufferSet& bufs) {}
static PBD::Signal2<void,PBD::PropertyChange,Trigger*> TriggerPropertyChange;
static PBD::Signal<void(PBD::PropertyChange,Trigger*)> TriggerPropertyChange;
protected:
struct UIRequests {
@ -805,17 +805,17 @@ class LIBARDOUR_API TriggerBox : public Processor, public std::enable_shared_fro
static CueRecords cue_records;
static bool cue_recording () { return _cue_recording; }
static void set_cue_recording (bool yn);
static PBD::Signal0<void> CueRecordingChanged;
static PBD::Signal<void()> CueRecordingChanged;
void set_record_enabled (bool yn);
RecordState record_enabled() const { return _record_state; }
PBD::Signal0<void> RecEnableChanged;
static PBD::Signal0<void> TriggerRecEnableChanged;
PBD::Signal<void()> RecEnableChanged;
static PBD::Signal<void()> TriggerRecEnableChanged;
void arm_from_another_thread (Trigger& slot, samplepos_t, uint32_t chans);
void disarm();
bool armed() const { return (bool) _arm_info.load(); }
PBD::Signal0<void> ArmedChanged;
PBD::Signal<void()> ArmedChanged;
void run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool result_required);
void run_cycle (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes);
@ -823,7 +823,7 @@ class LIBARDOUR_API TriggerBox : public Processor, public std::enable_shared_fro
bool configure_io (ChanCount in, ChanCount out);
bool empty() const { return _active_slots == 0; }
PBD::Signal0<void> EmptyStatusChanged;
PBD::Signal<void()> EmptyStatusChanged;
int32_t order() const { return _order; }
void set_order(int32_t n);
@ -891,7 +891,7 @@ class LIBARDOUR_API TriggerBox : public Processor, public std::enable_shared_fro
/* valid only within the ::run() call tree */
int32_t active_scene() const { return _active_scene; }
PBD::Signal1<void,uint32_t> TriggerSwapped;
PBD::Signal<void(uint32_t)> TriggerSwapped;
enum TriggerMidiMapMode {
AbletonPush,
@ -935,13 +935,13 @@ class LIBARDOUR_API TriggerBox : public Processor, public std::enable_shared_fro
static PBD::PropertyChange all_trigger_props();
void send_property_change (PBD::PropertyChange pc);
static PBD::Signal2<void,PBD::PropertyChange,int> TriggerBoxPropertyChange;
static PBD::Signal<void(PBD::PropertyChange,int)> TriggerBoxPropertyChange;
std::shared_ptr<MidiBuffer> get_gui_feed_buffer () const;
void dump (std::ostream &) const;
PBD::Signal1<void,timecnt_t> Captured;
PBD::Signal<void(timecnt_t)> Captured;
private:
struct Requests {
@ -1051,7 +1051,7 @@ class LIBARDOUR_API TriggerBox : public Processor, public std::enable_shared_fro
static bool _learning;
static std::pair<int,int> learning_for;
static PBD::Signal0<void> TriggerMIDILearned;
static PBD::Signal<void()> TriggerMIDILearned;
static void init_pool();

2
libs/ardour/ardour/vca.h
View File

@ -60,7 +60,7 @@ class LIBARDOUR_API VCA : public Stripable,
XMLNode& get_state() const;
int set_state (XMLNode const&, int version);
PBD::Signal0<void> Drop; /* signal to slaves to drop control by this VCA */
PBD::Signal<void()> Drop; /* signal to slaves to drop control by this VCA */
/* Slavable API */

4
libs/ardour/ardour/vca_manager.h
View File

@ -52,8 +52,8 @@ public:
VCAList vcas() const;
VCAList::size_type n_vcas() const { return _vcas.size(); }
PBD::Signal1<void,VCAList&> VCAAdded;
PBD::Signal0<void> VCACreated; /*<< is not emitted during set_state */
PBD::Signal<void(VCAList&)> VCAAdded;
PBD::Signal<void()> VCACreated; /*<< is not emitted during set_state */
XMLNode& get_state() const;
int set_state (XMLNode const&, int version);

6
libs/ardour/ardour/vst3_plugin.h
View File

@ -100,7 +100,7 @@ public:
IPlugView* view ();
void close_view ();
void update_contoller_param ();
PBD::Signal2<void, int, int> OnResizeView;
PBD::Signal<void(int, int)> OnResizeView;
tresult PLUGIN_API queryInterface (const TUID _iid, void** obj) SMTG_OVERRIDE;
uint32 PLUGIN_API addRef () SMTG_OVERRIDE { return 1; }
@ -178,7 +178,7 @@ public:
ParamValueChanged
};
PBD::Signal3<void, ParameterChange, uint32_t, float> OnParameterChange;
PBD::Signal<void(ParameterChange, uint32_t, float)> OnParameterChange;
/* API for Ardour -- Setup/Processing */
uint32_t plugin_latency ();
@ -444,7 +444,7 @@ public:
void close_view ();
void update_contoller_param ();
PBD::Signal2<void, int, int> OnResizeView;
PBD::Signal<void(int, int)> OnResizeView;
private:
samplecnt_t plugin_latency () const;

4
libs/ardour/ardour/vst_plugin.h
View File

@ -63,8 +63,8 @@ public:
std::string describe_parameter (Evoral::Parameter);
std::set<Evoral::Parameter> automatable() const;
PBD::Signal0<void> LoadPresetProgram;
PBD::Signal0<void> VSTSizeWindow;
PBD::Signal<void()> LoadPresetProgram;
PBD::Signal<void()> VSTSizeWindow;
bool parameter_is_audio (uint32_t) const { return false; }
bool parameter_is_control (uint32_t) const { return true; }

2
libs/ardour/audiofilesource.cc
View File

@ -72,7 +72,7 @@ using namespace ARDOUR;
using namespace PBD;
using namespace Glib;
PBD::Signal0<void> AudioFileSource::HeaderPositionOffsetChanged;
PBD::Signal<void()> AudioFileSource::HeaderPositionOffsetChanged;
samplecnt_t AudioFileSource::header_position_offset = 0;
/* XXX maybe this too */

2
libs/ardour/automation_list.cc
View File

@ -49,7 +49,7 @@ using namespace std;
using namespace ARDOUR;
using namespace PBD;
PBD::Signal1<void,AutomationList *> AutomationList::AutomationListCreated;
PBD::Signal<void(AutomationList *)> AutomationList::AutomationListCreated;
#if 0
static void dumpit (const AutomationList& al, string prefix = "")

2
libs/ardour/clip_library.cc
View File

@ -40,7 +40,7 @@ using namespace ARDOUR;
using namespace std;
using namespace PBD;
PBD::Signal2<void, std::string, void*> ARDOUR::LibraryClipAdded;
PBD::Signal<void(std::string, void*)> ARDOUR::LibraryClipAdded;
string
ARDOUR::clip_library_dir (bool create_if_missing)

2
libs/ardour/control_protocol_manager.cc
View File

@ -63,7 +63,7 @@ using namespace PBD;
ControlProtocolManager* ControlProtocolManager::_instance = 0;
const string ControlProtocolManager::state_node_name = X_("ControlProtocols");
PBD::Signal1<void,StripableNotificationListPtr> ControlProtocolManager::StripableSelectionChanged;
PBD::Signal<void(StripableNotificationListPtr)> ControlProtocolManager::StripableSelectionChanged;
#ifdef HAVE_USB
static int

2
libs/ardour/delivery.cc
View File

@ -50,7 +50,7 @@ using namespace std;
using namespace PBD;
using namespace ARDOUR;
PBD::Signal0<void> Delivery::PannersLegal;
PBD::Signal<void()> Delivery::PannersLegal;
bool Delivery::panners_legal = false;
/* deliver to an existing IO object */

4
libs/ardour/disk_io.cc
View File

@ -45,8 +45,8 @@ using namespace std;
const string DiskIOProcessor::state_node_name = X_("DiskIOProcessor");
// PBD::Signal0<void> DiskIOProcessor::DiskOverrun;
// PBD::Signal0<void> DiskIOProcessor::DiskUnderrun;
// PBD::Signal<void()> DiskIOProcessor::DiskOverrun;
// PBD::Signal<void()> DiskIOProcessor::DiskUnderrun;
DiskIOProcessor::DiskIOProcessor (Session& s, Track& t, string const & str, Flag f, Temporal::TimeDomainProvider const & tdp)
: Processor (s, str, tdp)

2
libs/ardour/disk_reader.cc
View File

@ -48,7 +48,7 @@ using namespace PBD;
using namespace std;
ARDOUR::samplecnt_t DiskReader::_chunk_samples = default_chunk_samples ();
PBD::Signal0<void> DiskReader::Underrun;
PBD::Signal<void()> DiskReader::Underrun;
thread_local Sample* DiskReader::_sum_buffer = 0;
thread_local Sample* DiskReader::_mixdown_buffer = 0;
thread_local gain_t* DiskReader::_gain_buffer = 0;

2
libs/ardour/disk_writer.cc
View File

@ -45,7 +45,7 @@ using namespace PBD;
using namespace std;
ARDOUR::samplecnt_t DiskWriter::_chunk_samples = DiskWriter::default_chunk_samples ();
PBD::Signal0<void> DiskWriter::Overrun;
PBD::Signal<void()> DiskWriter::Overrun;
DiskWriter::DiskWriter (Session& s, Track& t, string const & str, DiskIOProcessor::Flag f)
: DiskIOProcessor (s, t, X_("recorder:") + str, f, Temporal::TimeDomainProvider (Config->get_default_automation_time_domain()))

4
libs/ardour/element_importer.cc
View File

@ -34,8 +34,8 @@ using namespace std;
using namespace PBD;
using namespace ARDOUR;
PBD::Signal2<std::pair<bool, string>,string, string> ElementImporter::Rename;
PBD::Signal1 <bool,string> ElementImporter::Prompt;
PBD::Signal<std::pair<bool, string>(string, string)> ElementImporter::Rename;
PBD::Signal<bool(string)> ElementImporter::Prompt;
ElementImporter::ElementImporter (XMLTree const & source, ARDOUR::Session & session) :
source (source),

2
libs/ardour/file_source.cc
View File

@ -56,7 +56,7 @@ using namespace ARDOUR;
using namespace PBD;
using namespace Glib;
PBD::Signal2<int,std::string,std::vector<std::string> > FileSource::AmbiguousFileName;
PBD::Signal<int(std::string,std::vector<std::string> )> FileSource::AmbiguousFileName;
FileSource::FileSource (Session& session, DataType type, const string& path, const string& origin, Source::Flag flag)
: Source(session, type, path, flag)

10
libs/ardour/globals.cc
View File

@ -155,11 +155,11 @@ mix_buffers_with_gain_t ARDOUR::mix_buffers_with_gain = 0;
mix_buffers_no_gain_t ARDOUR::mix_buffers_no_gain = 0;
copy_vector_t ARDOUR::copy_vector = 0;
PBD::Signal1<void, std::string> ARDOUR::BootMessage;
PBD::Signal3<void, std::string, std::string, bool> ARDOUR::PluginScanMessage;
PBD::Signal1<void, int> ARDOUR::PluginScanTimeout;
PBD::Signal0<void> ARDOUR::GUIIdle;
PBD::Signal3<bool, std::string, std::string, int> ARDOUR::CopyConfigurationFiles;
PBD::Signal<void(std::string)> ARDOUR::BootMessage;
PBD::Signal<void(std::string, std::string, bool)> ARDOUR::PluginScanMessage;
PBD::Signal<void(int)> ARDOUR::PluginScanTimeout;
PBD::Signal<void()> ARDOUR::GUIIdle;
PBD::Signal<bool(std::string, std::string, int)> ARDOUR::CopyConfigurationFiles;
std::map<std::string, bool> ARDOUR::reserved_io_names;

2
libs/ardour/internal_send.cc
View File

@ -47,7 +47,7 @@ using namespace PBD;
using namespace ARDOUR;
using namespace std;
PBD::Signal1<void, pframes_t> InternalSend::CycleStart;
PBD::Signal<void(pframes_t)> InternalSend::CycleStart;
InternalSend::InternalSend (Session& s,
std::shared_ptr<Pannable> p,

2
libs/ardour/io.cc
View File

@ -63,7 +63,7 @@ using namespace ARDOUR;
using namespace PBD;
const string IO::state_node_name = "IO";
PBD::Signal1<void,ChanCount> IO::PortCountChanged;
PBD::Signal<void(ChanCount)> IO::PortCountChanged;
static std::string
legalize_io_name (std::string n)

2
libs/ardour/latent.cc
View File

@ -23,7 +23,7 @@
using namespace ARDOUR;
bool ARDOUR::Latent::_zero_latency = false;
PBD::Signal0<void> Latent::DisableSwitchChanged;
PBD::Signal<void()> Latent::DisableSwitchChanged;
Latent::Latent ()
: HasLatency ()

18
libs/ardour/location.cc
View File

@ -55,15 +55,15 @@ using namespace ARDOUR;
using namespace PBD;
using namespace Temporal;
PBD::Signal1<void,Location*> Location::name_changed;
PBD::Signal1<void,Location*> Location::end_changed;
PBD::Signal1<void,Location*> Location::start_changed;
PBD::Signal1<void,Location*> Location::flags_changed;
PBD::Signal1<void,Location*> Location::lock_changed;
PBD::Signal1<void,Location*> Location::cue_change;
PBD::Signal1<void,Location*> Location::scene_changed;
PBD::Signal1<void,Location*> Location::time_domain_changed;
PBD::Signal1<void,Location*> Location::changed;
PBD::Signal<void(Location*)> Location::name_changed;
PBD::Signal<void(Location*)> Location::end_changed;
PBD::Signal<void(Location*)> Location::start_changed;
PBD::Signal<void(Location*)> Location::flags_changed;
PBD::Signal<void(Location*)> Location::lock_changed;
PBD::Signal<void(Location*)> Location::cue_change;
PBD::Signal<void(Location*)> Location::scene_changed;
PBD::Signal<void(Location*)> Location::time_domain_changed;
PBD::Signal<void(Location*)> Location::changed;
Location::Location (Session& s)
: SessionHandleRef (s)

2
libs/ardour/mixer_scene.cc
View File

@ -29,7 +29,7 @@
using namespace PBD;
using namespace ARDOUR;
PBD::Signal0<void> MixerScene::Change;
PBD::Signal<void()> MixerScene::Change;
MixerScene::MixerScene (Session& s)
: SessionHandleRef (s)

2
libs/ardour/playlist_factory.cc
View File

@ -32,7 +32,7 @@ using namespace std;
using namespace ARDOUR;
using namespace PBD;
PBD::Signal1<void,std::shared_ptr<Playlist>> PlaylistFactory::PlaylistCreated;
PBD::Signal<void(std::shared_ptr<Playlist>)> PlaylistFactory::PlaylistCreated;
std::shared_ptr<Playlist>
PlaylistFactory::create (Session& s, const XMLNode& node, bool hidden)

2
libs/ardour/plugin.cc
View File

@ -77,7 +77,7 @@ using namespace PBD;
namespace ARDOUR { class AudioEngine; }
PBD::Signal3<void, std::string, Plugin*, bool> Plugin::PresetsChanged;
PBD::Signal<void(std::string, Plugin*, bool)> Plugin::PresetsChanged;
bool
PluginInfo::needs_midi_input () const

6
libs/ardour/port.cc
View File

@ -39,9 +39,9 @@ using namespace std;
using namespace ARDOUR;
using namespace PBD;
PBD::Signal0<void> Port::PortDrop;
PBD::Signal0<void> Port::PortSignalDrop;
PBD::Signal0<void> Port::ResamplerQualityChanged;
PBD::Signal<void()> Port::PortDrop;
PBD::Signal<void()> Port::PortSignalDrop;
PBD::Signal<void()> Port::ResamplerQualityChanged;
bool Port::_connecting_blocked = false;
pframes_t Port::_global_port_buffer_offset = 0;

Some files were not shown because too many files have changed in this diff Show More