diff --git a/_manual/24_lua-scripting/02_class_reference.html b/_manual/24_lua-scripting/02_class_reference.html new file mode 100644 index 00000000..8f71da02 --- /dev/null +++ b/_manual/24_lua-scripting/02_class_reference.html @@ -0,0 +1,1843 @@ +--- +layout: default +style: luadoc +title: Class Reference +--- + +
+This documention is far from complete may be inaccurate and subject to change. +
+ ++The top-level entry point are ARDOUR:Session and ArdourUI:Editor. +Most other Classes are used indirectly starting with a Session function. e.g. Session:get_routes(). +
++A few classes are dedicated to certain script types, e.g. Lua DSP processors have exclusive access to +ARDOUR.DSP and ARDOUR:ChanMapping. Action Hooks Scripts to +LuaSignal:Set etc. +
++Detailed documentation (parameter names, method description) is not yet available. Please stay tuned. +
++Ardour's structure is object oriented. The main object is the Session. A Session contains Audio Tracks, Midi Tracks and Busses. +Audio and Midi tracks are derived from a more general "Track" Object, which in turn is derived from a "Route" (aka Bus). +(We say "An Audio Track is-a Track is-a Route"). +Tracks contain specifics. For Example a track has-a diskstream (for file i/o). +
+
+Operations are performed on objects. One gets a reference to an object and then calls a method.
+e.g obj = Session:route_by_name("Audio") obj:set_name("Guitar").
+
+Object lifetimes are managed by the Session. Most Objects cannot be directly created, but one asks the Session to create or destroy them. This is mainly due to realtime constrains: +you cannot simply remove a track that is currently processing audio. There are various factory methods for object creation or removal. +
++Since lua functions are closures, C++ methods that pass arguments by reference cannot be used as-is. +All parameters passed to a C++ method which uses references are returned as Lua Table. +If the C++ method also returns a value it is prefixed. Two parameters are returned: the value and a Lua Table holding the parameters. +
+ +void set_ref (int& var, long& val)
+{
+ printf ("%d %ld\n", var, val);
+ var = 5;
+ val = 7;
+}
++ +local var = 0; +ref = set_ref (var, 2); +-- output from C++ printf() +0 2+-- var is still 0 here +print (ref[1], ref[2]) +5 7
int set_ref2 (int &var, std::string unused)
+{
+ var = 5;
+ return 3;
+}
+rv, ref = set_ref2 (0, "hello");
+print (rv, ref[1], ref[2])
+3 5 hello
+Libardour makes extensive use of reference counted boost::shared_ptr to manage lifetimes.
+The Lua bindings provide a complete abstration of this. There are no pointers in lua.
+For example a ARDOUR:Route is a pointer in C++, but lua functions operate on it like it was a class instance.
+
+shared_ptr are reference counted. Once assigned to a lua variable, the C++ object will be kept and remains valid.
+It is good practice to assign references to lua local variables or reset the variable to nil to drop the ref.
+
+All pointer classes have a isnil () method. This is for two cases:
+Construction may fail. e.g. ARDOUR.LuaAPI.newplugin()
+may not be able to find the given plugin and hence cannot create an object.
+
+The second case if for boost::weak_ptr. As opposed to boost::shared_ptr weak-pointers are not reference counted.
+The object may vanish at any time.
+If lua code calls a method on a nil object, the interpreter will raise an exception and the script will not continue.
+This is not unlike a = nil a:test() which results in en error "attempt to index a nil value".
+
+From the lua side of things there is no distinction between weak and shared pointers. They behave identically. +Below they're inidicated in orange and have an arrow to indicate the pointer type. +Pointer Classes cannot be created in lua scripts. It always requires a call to C++ to create the Object and obtain a reference to it. +
+ + +C‡: boost::shared_ptr< ARDOUR::AudioBackend >, boost::weak_ptr< ARDOUR::AudioBackend >
+ +| Methods | ||
|---|---|---|
| unsigned int | buffer_size () | |
| std::string | device_name () | |
| std::string | driver_name () | |
override this if this implementation returns true from requires_driver_selection() | ||
| float | dsp_load () | |
return the fraction of the time represented by the current buffer size that is being used for each buffer process cycle, as a value from 0.0 to 1.0 E.g. if the buffer size represents 5msec and current processing takes 1msec, the returned value should be 0.2. Implementations can feel free to smooth the values returned over time (e.g. high pass filtering, or its equivalent). | ||
| DeviceStatusVector | enumerate_devices () | |
Returns a collection of DeviceStatuses identifying devices discovered by this backend since the start of the process. Any of the names in each DeviceStatus may be used to identify a device in other calls to the backend, though any of them may become invalid at any time. | ||
| StringVector | enumerate_drivers () | |
If the return value of requires_driver_selection() is true, then this function can return the list of known driver names. If the return value of requires_driver_selection() is false, then this function should not be called. If it is called its return value is an empty vector of strings. | ||
| DeviceStatusVector | enumerate_input_devices () | |
Returns a collection of DeviceStatuses identifying input devices discovered by this backend since the start of the process. Any of the names in each DeviceStatus may be used to identify a device in other calls to the backend, though any of them may become invalid at any time. | ||
| DeviceStatusVector | enumerate_output_devices () | |
Returns a collection of DeviceStatuses identifying output devices discovered by this backend since the start of the process. Any of the names in each DeviceStatus may be used to identify a device in other calls to the backend, though any of them may become invalid at any time. | ||
| AudioBackendInfo | info () | |
Return the AudioBackendInfo object from which this backend was constructed. | ||
| unsigned int | input_channels () | |
| std::string | input_device_name () | |
| bool | isnil () | |
| unsigned int | output_channels () | |
| std::string | output_device_name () | |
| unsigned int | period_size () | |
| float | sample_rate () | |
| int | set_buffer_size (unsigned int) | |
Set the buffer size to be used. The device is assumed to use a double buffering scheme, so that one buffer's worth of data can be processed by hardware while software works on the other buffer. All known suitable audio APIs support this model (though ALSA allows for alternate numbers of buffers, and CoreAudio doesn't directly expose the concept). | ||
| int | set_device_name (std::string) | |
Set the name of the device to be used | ||
| int | set_driver (std::string) | |
Returns zero if the backend can successfully use Should not be used unless the backend returns true from requires_driver_selection()
| ||
| int | set_input_device_name (std::string) | |
Set the name of the input device to be used if using separate input/output devices. use_separate_input_and_output_devices() | ||
| int | set_output_device_name (std::string) | |
Set the name of the output device to be used if using separate input/output devices. use_separate_input_and_output_devices() | ||
| int | set_peridod_size (unsigned int) | |
Set the period size to be used. must be called before starting the backend. | ||
| int | set_sample_rate (float) | |
Set the sample rate to be used | ||
| bool | use_separate_input_and_output_devices () | |
An optional alternate interface for backends to provide a facility to select separate input and output devices. If a backend returns true then enumerate_input_devices() and enumerate_output_devices() will be used instead of enumerate_devices() to enumerate devices. Similarly set_input/output_device_name() should be used to set devices instead of set_device_name(). | ||
C‡: ARDOUR::AudioBackendInfo
+ +| Data Members | ||
|---|---|---|
| char* | name | |
C‡: ARDOUR::AudioBuffer
+ +Buffer containing audio data.
| Methods | ||
|---|---|---|
| void | apply_gain (float, long) | |
| FloatArray | data (long) | |
| void | silence (long, long) | |
Clear (eg zero, or empty) buffer | ||
C‡: ARDOUR::AudioEngine
+ +| Methods | ||
|---|---|---|
| BackendVector | available_backends () | |
| std::string | current_backend_name () | |
| float | get_dsp_load () | |
| std::string | get_last_backend_error () | |
| AudioBackend | set_backend (std::string, std::string, std::string) | |
| int | set_buffer_size (unsigned int) | |
| int | set_device_name (std::string) | |
| int | set_sample_rate (float) | |
| bool | setup_required () | |
| int | start (bool) | |
| int | stop (bool) | |
C‡: boost::shared_ptr< ARDOUR::AudioSource >, boost::weak_ptr< ARDOUR::AudioSource >
+is-a: ARDOUR:Source
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
| unsigned int | n_channels () | |
| long | readable_length () | |
C‡: boost::shared_ptr< ARDOUR::AudioTrack >, boost::weak_ptr< ARDOUR::AudioTrack >
+is-a: ARDOUR:Track
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
| Methods | ||
|---|---|---|
| bool | can_record () | |
| bool | record_enabled () | |
| bool | record_safe () | |
| bool | set_name (std::string) | |
| void | set_record_enabled (bool, GroupControlDisposition) | |
| void | set_record_safe (bool, GroupControlDisposition) | |
| Methods | ||
|---|---|---|
| bool | active () | |
| int | add_processor_by_index (Processor, int, ProcessorStreams, bool) | |
| std::string | comment () | |
| ChanCount | n_inputs () | |
| ChanCount | n_outputs () | |
| Processor | nth_plugin (unsigned int) | |
| int | remove_processor (Processor, ProcessorStreams, bool) | |
| int | replace_processor (Processor, Processor, ProcessorStreams) | |
| void | set_active (bool, void*) | |
| void | set_comment (std::string, void*) | |
| bool | set_strict_io (bool) | |
| bool | strict_io () | |
| Methods | ||
|---|---|---|
| std::string | name () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: std::list<boost::shared_ptr<ARDOUR::AudioTrack> >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.AudioTrackList () | |
| Methods | ||
| LuaTable | add (LuaTable {AudioTrack}) | |
| bool | empty () | |
| LuaIter | iter () | |
| void | push_back (AudioTrack) | |
| void | reverse () | |
| unsigned long | size () | |
| LuaTable | table () | |
| void | unique () | |
C‡: boost::shared_ptr< ARDOUR::Automatable >, boost::weak_ptr< ARDOUR::Automatable >
+is-a: Evoral:ControlSet
+ +| Methods | ||
|---|---|---|
| AutomationControl | automation_control (Parameter, bool) | |
| bool | isnil () | |
C‡: boost::shared_ptr< ARDOUR::AutomationControl >, boost::weak_ptr< ARDOUR::AutomationControl >
+is-a: Evoral:Control
+ +| Methods | ||
|---|---|---|
| AutoState | automation_state () | |
| double | get_value () | |
| bool | isnil () | |
| void | set_automation_style (AutoStyle) | |
| void | set_value (double, GroupControlDisposition) | |
Get and Set `internal' value All derived classes must implement this. Basic derived classes will ignore
| ||
| void | start_touch (double) | |
| void | stop_touch (bool, double) | |
| bool | writable () | |
| Methods | ||
|---|---|---|
| ControlList | list () | |
C‡: std::vector<ARDOUR::AudioBackendInfo const* >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.BackendVector () | |
| Methods | ||
| LuaTable | add (LuaTable {ARDOUR::AudioBackendInfo* }) | |
| AudioBackendInfo | at (unsigned long) | |
| bool | empty () | |
| LuaIter | iter () | |
| void | push_back (AudioBackendInfo) | |
| unsigned long | size () | |
| LuaTable | table () | |
C‡: ARDOUR::BufferSet
+ +A set of buffers of various types.
These are mainly accessed from Session and passed around as scratch buffers (eg as parameters to run() methods) to do in-place signal processing.
There are two types of counts associated with a BufferSet - available, and the 'use count'. Available is the actual number of allocated buffers (and so is the maximum acceptable value for the use counts).
The use counts are how things determine the form of their input and inform others the form of their output (eg what they did to the BufferSet). Setting the use counts is realtime safe.
| Methods | ||
|---|---|---|
| ChanCount | count () | |
| AudioBuffer | get_audio (unsigned long) | |
C‡: ARDOUR::ChanCount
+ +A count of channels, possibly with many types.
Operators are defined so this may safely be used as if it were a simple (single-typed) integer count of channels.
| Methods | ||
|---|---|---|
| unsigned int | n_audio () | |
C‡: ARDOUR::ChanMapping
+ +A mapping from one set of channels to another (e.g. how to 'connect' two BufferSets).
| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.ChanMapping () | |
| Methods | ||
| unsigned int | get (DataType, unsigned int) | |
| void | set (DataType, unsigned int, unsigned int) | |
| Methods | ||
|---|---|---|
| float | accurate_coefficient_to_dB (float) | |
| void | apply_gain_to_buffer (FloatArray, unsigned int, float) | |
| float | compute_peak (FloatArray, unsigned int, float) | |
| void | copy_vector (FloatArray, FloatArray, unsigned int) | |
| float | dB_to_coefficient (float) | |
| float | fast_coefficient_to_dB (float) | |
| void | find_peaks (FloatArray, unsigned int, FloatArray, FloatArray) | |
| float | log_meter (float) | |
non-linear power-scale meter deflection
Returns deflected value | ||
| float | log_meter_coeff (float) | |
non-linear power-scale meter deflection
Returns deflected value | ||
| void | memset (FloatArray, float, unsigned int) | |
lua wrapper to memset() | ||
| void | mix_buffers_no_gain (FloatArray, FloatArray, unsigned int) | |
| void | mix_buffers_with_gain (FloatArray, FloatArray, unsigned int, float) | |
| void | mmult (FloatArray, FloatArray, unsigned int) | |
matrix multiply multiply every sample of `data' with the corresponding sample at `mult'.
| ||
| LuaTable(...) | peaks (FloatArray, float&, float&, unsigned int) | |
calculate peaks
| ||
C‡: ARDOUR::DSP::BiQuad
+ +Biquad Filter
| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.DSP.Biquad (double) | |
| Methods | ||
| void | compute (Type, double, double, double) | |
setup filter, compute coefficients
| ||
| void | reset () | |
reset filter state | ||
| void | run (FloatArray, unsigned int) | |
process audio data
| ||
C‡: ARDOUR::DSP::DspShm
+ +C/C++ Shared Memory
A convenience class representing a C array of float[] or int32_t[] data values. This is useful for lua scripts to perform DSP operations directly using C/C++ with CPU Hardware acceleration.
Access to this memory area is always 4 byte aligned. The data is interpreted either as float or as int.
This memory area can also be shared between different instances or the same lua plugin (DSP, GUI).
Since memory allocation is not realtime safe it should be allocated during dsp_init() or dsp_configure(). The memory is free()ed automatically when the lua instance is destroyed.
| Methods | ||
|---|---|---|
| void | allocate (unsigned long) | |
[re] allocate memory in host's memory space
| ||
| int | atomic_get_int (unsigned long) | |
atomically read integer at offset This involves a memory barrier. This call is intended for buffers which are shared with another instance.
Returns value at offset | ||
| void | atomic_set_int (unsigned long, int) | |
atomically set integer at offset This involves a memory barrier. This call is intended for buffers which are shared with another instance.
| ||
| void | clear () | |
clear memory (set to zero) | ||
| FloatArray | to_float (unsigned long) | |
access memory as float array
Returns float[] | ||
| IntArray | to_int (unsigned long) | |
access memory as integer array
Returns int_32_t[] | ||
C‡: ARDOUR::DSP::LowPass
+ +1st order Low Pass filter
| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.DSP.LowPass (double, float) | |
instantiate a LPF
| ||
| Methods | ||
| void | ctrl (FloatArray, float, unsigned int) | |
filter control data This is useful for parameter smoothing.
| ||
| void | proc (FloatArray, unsigned int) | |
process audio data
| ||
| void | reset () | |
reset filter state | ||
| void | set_cutoff (float) | |
update filter cut-off frequency
| ||
C‡: ARDOUR::DataType
+ +A type of Data Ardour is capable of processing.
The majority of this class is dedicated to conversion to and from various other type representations, simple comparison between then, etc. This code is deliberately 'ugly' so other code doesn't have to be.
| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.DataType (std::string) | |
C‡: ARDOUR::AudioBackend::DeviceStatus
+ +used to list device names along with whether or not they are currently available.
| Data Members | ||
|---|---|---|
| bool | available | |
| std::string | name | |
C‡: std::vector<ARDOUR::AudioBackend::DeviceStatus >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.DeviceStatusVector () | |
| Methods | ||
| LuaTable | add (LuaTable {DeviceStatus}) | |
| DeviceStatus | at (unsigned long) | |
| bool | empty () | |
| LuaIter | iter () | |
| void | push_back (DeviceStatus) | |
| unsigned long | size () | |
| LuaTable | table () | |
C‡: ARDOUR::Location
+is-a: PBD:StatefulDestructible
+ +Base class for objects with saveable and undoable state
| Methods | ||
|---|---|---|
| long | end () | |
| long | length () | |
| void | lock () | |
| bool | locked () | |
| int | move_to (long) | |
| int | set_end (long, bool, bool) | |
| int | set_length (long, long, bool) | |
| int | set_start (long, bool, bool) | |
| long | start () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
| Methods | ||
|---|---|---|
| Processor | new_luaproc (Session, std::string) | |
create a new Lua Processor (Plugin)
Returns Processor object (may be nil) | ||
| Processor | new_plugin (Session, std::string, PluginType, std::string) | |
create a new Plugin Instance
Returns Processor or nil | ||
| PluginInfo | new_plugin_info (std::string, PluginType) | |
search a Plugin
Returns PluginInfo or nil if not found | ||
| bool | set_plugin_insert_param (PluginInsert, unsigned int, float) | |
set a plugin control-input parameter value This is a wrapper around set_processor_param which looks up the Processor by plugin-insert.
Returns true on success, false on error or out-of-bounds value | ||
| bool | set_processor_param (Processor, unsigned int, float) | |
set a plugin control-input parameter value
Returns true on success, false on error or out-of-bounds value | ||
C‡: ARDOUR::LuaOSC::Address
+ +OSC transmitter
A Class to send OSC messages.
| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.LuaOSC.Address (std::string) | |
Construct a new OSC transmitter object
| ||
| Methods | ||
| ... | send (--lua--) | |
Transmit an OSC message Path (string) and type (string) must always be given. The number of following args must match the type. Supported types are: 'i': integer (lua number) 'f': float (lua number) 'd': double (lua number) 'h': 64bit integer (lua number) 's': string (lua string) 'c': character (lua string) 'T': boolean (lua bool) -- this is not implicily True, a lua true/false must be given 'F': boolean (lua bool) -- this is not implicily False, a lua true/false must be given
Returns boolean true if successful, false on error. | ||
C‡: ARDOUR::Meter
+ +Meter, or time signature (beats per bar, and which note type is a beat).
| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.Meter (double, double) | |
| Methods | ||
| double | divisions_per_bar () | |
| double | frames_per_bar (Tempo, long) | |
| double | frames_per_grid (Tempo, long) | |
| double | note_divisor () | |
C‡: ARDOUR::MidiBuffer
+ +Buffer containing 8-bit unsigned char (MIDI) data.
| Methods | ||
|---|---|---|
| bool | empty () | |
| void | silence (long, long) | |
Clear (eg zero, or empty) buffer | ||
C‡: boost::shared_ptr< ARDOUR::MidiTrack >, boost::weak_ptr< ARDOUR::MidiTrack >
+is-a: ARDOUR:Track
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
| Methods | ||
|---|---|---|
| bool | can_record () | |
| bool | record_enabled () | |
| bool | record_safe () | |
| bool | set_name (std::string) | |
| void | set_record_enabled (bool, GroupControlDisposition) | |
| void | set_record_safe (bool, GroupControlDisposition) | |
| Methods | ||
|---|---|---|
| bool | active () | |
| int | add_processor_by_index (Processor, int, ProcessorStreams, bool) | |
| std::string | comment () | |
| ChanCount | n_inputs () | |
| ChanCount | n_outputs () | |
| Processor | nth_plugin (unsigned int) | |
| int | remove_processor (Processor, ProcessorStreams, bool) | |
| int | replace_processor (Processor, Processor, ProcessorStreams) | |
| void | set_active (bool, void*) | |
| void | set_comment (std::string, void*) | |
| bool | set_strict_io (bool) | |
| bool | strict_io () | |
| Methods | ||
|---|---|---|
| std::string | name () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: std::list<boost::shared_ptr<ARDOUR::MidiTrack> >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.MidiTrackList () | |
| Methods | ||
| LuaTable | add (LuaTable {MidiTrack}) | |
| bool | empty () | |
| LuaIter | iter () | |
| void | push_back (MidiTrack) | |
| void | reverse () | |
| unsigned long | size () | |
| LuaTable | table () | |
| void | unique () | |
C‡: PBD::OwnedPropertyList
+is-a: ARDOUR:PropertyList
+ +A variant of PropertyList that does not delete its property list in its destructor. Objects with their own Properties store them in an OwnedPropertyList to avoid having them deleted at the wrong time.
This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.
+C‡: ARDOUR::ParameterDescriptor
+is-a: Evoral:ParameterDescriptor
+ +Descriptor of a parameter or control.
Essentially a union of LADSPA, VST and LV2 info.
| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.ParameterDescriptor () | |
| Data Members | ||
| std::string | label | |
| bool | logarithmic | |
| Constructor | ||
|---|---|---|
| ℂ | Evoral.ParameterDescriptor () | |
| Data Members | ||
| float | lower | |
| float | normal | |
| bool | toggled | |
| float | upper | |
C‡: boost::shared_ptr< ARDOUR::Plugin >, boost::weak_ptr< ARDOUR::Plugin >
+is-a: PBD:StatefulDestructiblePtr
+ +| Methods | ||
|---|---|---|
| std::string | get_docs () | |
| LuaTable(int, ...) | get_parameter_descriptor (unsigned int, ParameterDescriptor&) | |
| std::string | get_parameter_docs (unsigned int) | |
| bool | isnil () | |
| char* | label () | |
| bool | load_preset (PresetRecord) | |
| char* | maker () | |
| char* | name () | |
| LuaTable(unsigned int, ...) | nth_parameter (unsigned int, bool&) | |
| unsigned int | parameter_count () | |
| bool | parameter_is_input (unsigned int) | |
| PresetRecord | preset_by_label (std::string) | |
| PresetRecord | preset_by_uri (std::string) | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: boost::shared_ptr< ARDOUR::PluginInsert::PluginControl >, boost::weak_ptr< ARDOUR::PluginInsert::PluginControl >
+is-a: ARDOUR:AutomationControl
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
| Methods | ||
|---|---|---|
| AutoState | automation_state () | |
| double | get_value () | |
| void | set_automation_style (AutoStyle) | |
| void | set_value (double, GroupControlDisposition) | |
Get and Set `internal' value All derived classes must implement this. Basic derived classes will ignore
| ||
| void | start_touch (double) | |
| void | stop_touch (bool, double) | |
| bool | writable () | |
| Methods | ||
|---|---|---|
| ControlList | list () | |
C‡: boost::shared_ptr< ARDOUR::PluginInfo >, boost::weak_ptr< ARDOUR::PluginInfo >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.PluginInfo () | |
| Methods | ||
| bool | isnil () | |
C‡: boost::shared_ptr< ARDOUR::PluginInsert >, boost::weak_ptr< ARDOUR::PluginInsert >
+is-a: ARDOUR:Processor
+ +| Methods | ||
|---|---|---|
| void | activate () | |
| void | deactivate () | |
| ChanMapping | input_map (unsigned int) | |
| bool | isnil () | |
| bool | no_inplace () | |
| ChanMapping | output_map (unsigned int) | |
| Plugin | plugin (unsigned int) | |
| void | set_input_map (unsigned int, ChanMapping) | |
| void | set_no_inplace (bool) | |
| void | set_output_map (unsigned int, ChanMapping) | |
| void | set_strict_io (bool) | |
| bool | strict_io_configured () | |
| Methods | ||
|---|---|---|
| bool | active () | |
| AutomationControl | automation_control (Parameter, bool) | |
| Control | control (Parameter, bool) | |
| std::string | display_name () | |
| PluginInsert | to_insert () | |
| Methods | ||
|---|---|---|
| std::string | name () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: ARDOUR::Plugin::PresetRecord
+ +| Data Members | ||
|---|---|---|
| std::string | label | |
| std::string | uri | |
| bool | user | |
| bool | valid | |
C‡: boost::shared_ptr< ARDOUR::Processor >, boost::weak_ptr< ARDOUR::Processor >
+is-a: ARDOUR:Automatable, ARDOUR:SessionObject
+ +| Methods | ||
|---|---|---|
| void | activate () | |
| bool | active () | |
| AutomationControl | automation_control (Parameter, bool) | |
| Control | control (Parameter, bool) | |
| void | deactivate () | |
| std::string | display_name () | |
| bool | isnil () | |
| bool | isnil () | |
| PluginInsert | to_insert () | |
| Methods | ||
|---|---|---|
| std::string | name () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: PBD::PropertyDescriptor<bool>
+ +This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.
+C‡: PBD::PropertyDescriptor<float>
+ +This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.
+C‡: PBD::PropertyDescriptor<long>
+ +This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.
+C‡: PBD::PropertyChange
+ +A list of IDs of Properties that have changed in some situation or other
| Methods | ||
|---|---|---|
| bool | containsBool (BoolProperty) | |
| bool | containsFloat (FloatProperty) | |
| bool | containsFramePos (FrameposProperty) | |
C‡: PBD::PropertyList
+ +A list of properties, mapped using their ID
This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.
+C‡: boost::shared_ptr< ARDOUR::Region >, boost::weak_ptr< ARDOUR::Region >
+is-a: ARDOUR:SessionObject
+ +| Methods | ||
|---|---|---|
| bool | at_natural_position () | |
| bool | automatic () | |
| bool | can_move () | |
| bool | captured () | |
| void | clear_sync_position () | |
| bool | covers (long) | |
| void | cut_end (long) | |
| void | cut_front (long) | |
| DataType | data_type () | |
| bool | external () | |
| bool | hidden () | |
| bool | import () | |
| bool | is_compound () | |
| bool | isnil () | |
| unsigned int | layer () | |
| long | length () | |
| bool | locked () | |
| void | lower () | |
| void | lower_to_bottom () | |
| void | move_start (long) | |
| void | move_to_natural_position () | |
| bool | muted () | |
| void | nudge_position (long) | |
| bool | opaque () | |
| long | position () | |
How the region parameters play together: POSITION: first frame of the region along the timeline START: first frame of the region within its source(s) LENGTH: number of frames the region represents | ||
| bool | position_locked () | |
| void | raise () | |
| void | raise_to_top () | |
| void | set_hidden (bool) | |
| void | set_initial_position (long) | |
| void | set_length (long) | |
| void | set_locked (bool) | |
| void | set_muted (bool) | |
| void | set_opaque (bool) | |
| void | set_position (long) | |
| void | set_position_locked (bool) | |
| void | set_start (long) | |
| void | set_sync_position (long) | |
| void | set_video_locked (bool) | |
| float | shift () | |
| long | start () | |
| float | stretch () | |
| bool | sync_marked () | |
| LuaTable(long, ...) | sync_offset (int&) | |
| long | sync_position () | |
| void | trim_end (long) | |
| void | trim_front (long) | |
| void | trim_to (long, long) | |
| bool | valid_transients () | |
| bool | video_locked () | |
| bool | whole_file () | |
| Methods | ||
|---|---|---|
| std::string | name () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: ARDOUR::RegionFactory
+ +| Methods | ||
|---|---|---|
| Region | region_by_id (ID) | |
C‡: boost::shared_ptr< ARDOUR::Route >, boost::weak_ptr< ARDOUR::Route >
+is-a: ARDOUR:SessionObject
+ +| Methods | ||
|---|---|---|
| bool | active () | |
| int | add_processor_by_index (Processor, int, ProcessorStreams, bool) | |
| std::string | comment () | |
| bool | isnil () | |
| ChanCount | n_inputs () | |
| ChanCount | n_outputs () | |
| Processor | nth_plugin (unsigned int) | |
| int | remove_processor (Processor, ProcessorStreams, bool) | |
| int | replace_processor (Processor, Processor, ProcessorStreams) | |
| void | set_active (bool, void*) | |
| void | set_comment (std::string, void*) | |
| bool | set_name (std::string) | |
| bool | set_strict_io (bool) | |
| bool | strict_io () | |
| Methods | ||
|---|---|---|
| std::string | name () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: ARDOUR::Route::ProcessorStreams
+ +A record of the stream configuration at some point in the processor list. Used to return where and why an processor list configuration request failed.
| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.Route.ProcessorStreams () | |
C‡: std::list<boost::shared_ptr<ARDOUR::Route> >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.RouteList () | |
| Methods | ||
| bool | empty () | |
| LuaIter | iter () | |
| void | reverse () | |
| unsigned long | size () | |
| LuaTable | table () | |
C‡: boost::shared_ptr<std::list<boost::shared_ptr<ARDOUR::Route> > >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.RouteListPtr () | |
| Methods | ||
| LuaTable | add (LuaTable {Route}) | |
| bool | empty () | |
| LuaIter | iter () | |
| void | push_back (Route) | |
| void | reverse () | |
| unsigned long | size () | |
| LuaTable | table () | |
| void | unique () | |
C‡: ARDOUR::Session
+ +Base class for objects with saveable and undoable state
| Methods | ||
|---|---|---|
| bool | actively_recording () | |
| Controllable | controllable_by_id (ID) | |
| long | current_end_frame () | |
| long | current_start_frame () | |
| long | frame_rate () | |
"actual" sample rate of session, set by current audioengine rate, pullup/down etc. | ||
| double | frames_per_timecode_frame () | |
| RouteListPtr | get_routes () | |
| BufferSet | get_scratch_buffers (ChanCount, bool) | |
| BufferSet | get_silent_buffers (ChanCount) | |
| RouteListPtr | get_tracks () | |
| void | goto_end () | |
| void | goto_start () | |
| long | last_transport_start () | |
| std::string | name () | |
| RouteList | new_route_from_template (unsigned int, std::string, std::string, PlaylistDisposition) | |
| long | nominal_frame_rate () | |
"native" sample rate of session, regardless of current audioengine rate, pullup/down etc | ||
| std::string | path () | |
| Processor | processor_by_id (ID) | |
| RecordState | record_status () | |
| void | request_locate (long, bool) | |
| void | request_stop (bool, bool) | |
| void | request_transport_speed (double, bool) | |
| Route | route_by_id (ID) | |
| Route | route_by_name (std::string) | |
| Route | route_by_remote_id (unsigned int) | |
| int | save_state (std::string, bool, bool, bool) | |
| void | scripts_changed () | |
| void | set_dirty () | |
| std::string | snap_name () | |
| Source | source_by_id (ID) | |
| TempoMap | tempo_map () | |
| bool | timecode_drop_frames () | |
| long | timecode_frames_per_hour () | |
| double | timecode_frames_per_second () | |
| Track | track_by_diskstream_id (ID) | |
| long | transport_frame () | |
| bool | transport_rolling () | |
| double | transport_speed () | |
| StringList | unknown_processors () | |
C‡: boost::shared_ptr< ARDOUR::SessionObject >, boost::weak_ptr< ARDOUR::SessionObject >
+is-a: PBD:StatefulDestructiblePtr
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
| std::string | name () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: boost::shared_ptr< ARDOUR::Source >, boost::weak_ptr< ARDOUR::Source >
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
C‡: ARDOUR::Tempo
+ +Tempo, the speed at which musical time progresses (BPM).
| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.Tempo (double, double) | |
| ||
| Methods | ||
| double | beats_per_minute () | |
| double | frames_per_beat (long) | |
audio samples per beat
| ||
| double | note_type () | |
C‡: ARDOUR::TempoMap
+ +Base class for objects with saveable and undoable state
| Methods | ||
|---|---|---|
| void | add_meter (Meter, BBT_TIME) | |
| void | add_tempo (Tempo, BBT_TIME) | |
C‡: boost::shared_ptr< ARDOUR::Track >, boost::weak_ptr< ARDOUR::Track >
+is-a: ARDOUR:Route
+ +| Methods | ||
|---|---|---|
| bool | can_record () | |
| bool | isnil () | |
| bool | record_enabled () | |
| bool | record_safe () | |
| bool | set_name (std::string) | |
| void | set_record_enabled (bool, GroupControlDisposition) | |
| void | set_record_safe (bool, GroupControlDisposition) | |
| Methods | ||
|---|---|---|
| bool | active () | |
| int | add_processor_by_index (Processor, int, ProcessorStreams, bool) | |
| std::string | comment () | |
| ChanCount | n_inputs () | |
| ChanCount | n_outputs () | |
| Processor | nth_plugin (unsigned int) | |
| int | remove_processor (Processor, ProcessorStreams, bool) | |
| int | replace_processor (Processor, Processor, ProcessorStreams) | |
| void | set_active (bool, void*) | |
| void | set_comment (std::string, void*) | |
| bool | set_strict_io (bool) | |
| bool | strict_io () | |
| Methods | ||
|---|---|---|
| std::string | name () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: std::list<boost::weak_ptr<ARDOUR::AudioSource> >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.WeakAudioSourceList () | |
| Methods | ||
| bool | empty () | |
| LuaIter | iter () | |
| void | reverse () | |
| unsigned long | size () | |
| LuaTable | table () | |
C‡: std::set<boost::weak_ptr<ARDOUR::AudioPort> > >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.WeakPortSet () | |
| Methods | ||
| LuaTable | add (LuaTable {ARDOUR::AudioPort}) | |
| void | clear () | |
| bool | empty () | |
| LuaIter | iter () | |
| unsigned long | size () | |
| LuaTable | table () | |
C‡: std::list<boost::weak_ptr<ARDOUR::Route> >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.WeakRouteList () | |
| Methods | ||
| bool | empty () | |
| LuaIter | iter () | |
| void | reverse () | |
| unsigned long | size () | |
| LuaTable | table () | |
C‡: std::list<boost::weak_ptr<ARDOUR::Source> >
+ +| Constructor | ||
|---|---|---|
| ℂ | ARDOUR.WeakSourceList () | |
| Methods | ||
| bool | empty () | |
| LuaIter | iter () | |
| void | reverse () | |
| unsigned long | size () | |
| LuaTable | table () | |
C‡: ArdourMarker
+ +Base class for objects with auto-disconnection. trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.
add_destroy_notify_callback() and remove_destroy_notify_callback() can be used to manually install and remove callbacks when notification of the object dying is needed.
notify_callbacks() invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.
Note that there is no virtual destructor. Don't use trackable* as pointer type for managing your data or the destructors of your derived types won't be called when deleting your objects.
signal
This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.
+C‡: PublicEditor
+ +| Methods | ||
|---|---|---|
| void | access_action (std::string, std::string) | |
| void | add_location_from_playhead_cursor () | |
| void | center_screen (long) | |
| void | consider_auditioning (Region) | |
Possibly start the audition of a region. If
| ||
| MouseMode | current_mouse_mode () | |
Returns The current mouse mode (gain, object, range, timefx etc.) (defined in editing_syms.h) | ||
| long | current_page_samples () | |
| void | deselect_all () | |
| LuaTable(...) | do_embed (StringVector, ImportDisposition, ImportMode, long&, PluginInfo) | |
| LuaTable(...) | do_import (StringVector, ImportDisposition, ImportMode, SrcQuality, long&, PluginInfo) | |
| bool | dragging_playhead () | |
Returns true if the playhead is currently being dragged, otherwise false | ||
| MouseMode | effective_mouse_mode () | |
| void | export_audio () | |
Open main export dialog | ||
| void | export_range () | |
Open export dialog with current range pre-selected | ||
| void | export_selection () | |
Open export dialog with current selection pre-selected | ||
| LuaTable(Location, ...) | find_location_from_marker (ArdourMarker, bool&) | |
| ArdourMarker | find_marker_from_location_id (ID, bool) | |
| bool | follow_playhead () | |
Returns true if the editor is following the playhead | ||
| long | get_current_zoom () | |
| unsigned int | get_grid_beat_divisions (long) | |
| LuaTable(Beats, ...) | get_grid_type_as_beats (bool&, long) | |
| LuaTable(long, ...) | get_nudge_distance (long, long&) | |
| long | get_paste_offset (long, unsigned int, long) | |
| LuaTable(...) | get_pointer_position (double&, double&) | |
| bool | get_smart_mode () | |
| int | get_videotl_bar_height () | |
| double | get_y_origin () | |
| ZoomFocus | get_zoom_focus () | |
| void | goto_nth_marker (int) | |
| long | leftmost_sample () | |
| void | maximise_editing_space () | |
| void | maybe_locate_with_edit_preroll (long) | |
| void | mouse_add_new_marker (long, bool) | |
| void | new_region_from_selection () | |
| void | override_visible_track_count () | |
| long | pixel_to_sample (double) | |
| void | play_selection () | |
| void | play_with_preroll () | |
| void | redo (unsigned int) | |
Redo some transactions.
| ||
| void | remove_last_capture () | |
| void | remove_location_at_playhead_cursor () | |
| void | remove_tracks () | |
| void | reset_x_origin (long) | |
| void | reset_y_origin (double) | |
| void | reset_zoom (long) | |
| void | restore_editing_space () | |
| double | sample_to_pixel (long) | |
| bool | scroll_down_one_track (bool) | |
| void | scroll_tracks_down_line () | |
| void | scroll_tracks_up_line () | |
| bool | scroll_up_one_track (bool) | |
| void | select_all_tracks () | |
| void | separate_region_from_selection () | |
| void | set_follow_playhead (bool, bool) | |
Set whether the editor should follow the playhead.
| ||
| void | set_mouse_mode (MouseMode, bool) | |
Set the mouse mode (gain, object, range, timefx etc.)
| ||
| void | set_show_measures (bool) | |
| void | set_snap_mode (SnapMode) | |
Set the snap mode.
| ||
| void | set_snap_threshold (double) | |
Set the snap threshold.
| ||
| void | set_stationary_playhead (bool) | |
| void | set_video_timeline_height (int) | |
| void | set_zoom_focus (ZoomFocus) | |
| bool | show_measures () | |
| SnapMode | snap_mode () | |
| SnapType | snap_type () | |
| bool | stationary_playhead () | |
| void | stem_export () | |
Open stem export dialog | ||
| void | temporal_zoom_step (bool) | |
| void | toggle_meter_updating () | |
| void | toggle_ruler_video (bool) | |
| void | toggle_xjadeo_proc (int) | |
| void | undo (unsigned int) | |
Undo some transactions.
| ||
| double | visible_canvas_height () | |
C‡: RegionSelection
+ +Class to represent list of selected regions.
| Methods | ||
|---|---|---|
| void | clear_all () | |
| long | end_frame () | |
| unsigned long | n_midi_regions () | |
| long | start () | |
C‡: std::vector<double >
+ +| Constructor | ||
|---|---|---|
| ℂ | C.DoubleVector () | |
| Methods | ||
| LuaTable | add (LuaTable {double}) | |
| double | at (unsigned long) | |
| bool | empty () | |
| LuaIter | iter () | |
| void | push_back (double) | |
| unsigned long | size () | |
| LuaTable | table () | |
C‡: float*
+ +| Methods | ||
|---|---|---|
| LuaMetaTable | array () | |
| LuaTable | get_table () | |
| void | set_table (LuaTable {float}) | |
C‡: int*
+ +| Methods | ||
|---|---|---|
| LuaMetaTable | array () | |
| LuaTable | get_table () | |
| void | set_table (LuaTable {int}) | |
C‡: std::list<std::string >
+ +| Constructor | ||
|---|---|---|
| ℂ | C.StringList () | |
| Methods | ||
| LuaTable | add (LuaTable {std::string}) | |
| bool | empty () | |
| LuaIter | iter () | |
| void | push_back (std::string) | |
| void | reverse () | |
| unsigned long | size () | |
| LuaTable | table () | |
| void | unique () | |
C‡: std::vector<std::string >
+ +| Constructor | ||
|---|---|---|
| ℂ | C.StringVector () | |
| Methods | ||
| LuaTable | add (LuaTable {std::string}) | |
| std::string | at (unsigned long) | |
| bool | empty () | |
| LuaIter | iter () | |
| void | push_back (std::string) | |
| unsigned long | size () | |
| LuaTable | table () | |
C‡: Cairo::Context
+ +Context is the main class used to draw in cairomm. It contains the current state of the rendering device, including coordinates of yet to be drawn shapes.
In the simplest case, create a Context with its target Surface, set its drawing options (line width, color, etc), create shapes with methods like move_to() and line_to(), and then draw the shapes to the Surface using methods such as stroke() or fill().
Context is a reference-counted object that should be used via Cairo::RefPtr.
| Methods | ||
|---|---|---|
| void | arc (double, double, double, double, double) | |
Adds a circular arc of the given radius to the current path. The arc is centered at (xc, yc), begins at angle1 and proceeds in the direction of increasing angles to end at angle2. If angle2 is less than angle1 it will be progressively increased by 2*M_PI until it is greater than angle1. If there is a current point, an initial line segment will be added to the path to connect the current point to the beginning of the arc. If this initial line is undesired, it can be avoided by calling begin_new_sub_path() before calling arc(). Angles are measured in radians. An angle of 0 is in the direction of the positive X axis (in user-space). An angle of M_PI/2.0 radians (90 degrees) is in the direction of the positive Y axis (in user-space). Angles increase in the direction from the positive X axis toward the positive Y axis. So with the default transformation matrix, angles increase in a clockwise direction. ( To convert from degrees to radians, use degrees * (M_PI / 180.0). ) This function gives the arc in the direction of increasing angles; see arc_negative() to get the arc in the direction of decreasing angles. The arc is circular in user-space. To achieve an elliptical arc, you can scale the current transformation matrix by different amounts in the X and Y directions. For example, to draw an ellipse in the box given by x, y, width, height: context->save(); + context->translate(x, y); + context->scale(width / 2.0, height / 2.0); + context->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI); + context->restore();
| ||
| void | arc_negative (double, double, double, double, double) | |
Adds a circular arc of the given radius to the current path. The arc is centered at (xc, yc), begins at angle1 and proceeds in the direction of decreasing angles to end at angle2. If angle2 is greater than angle1 it will be progressively decreased by 2*M_PI until it is greater than angle1. See arc() for more details. This function differs only in the direction of the arc between the two angles.
| ||
| void | begin_new_path () | |
Clears the current path. After this call there will be no current point. | ||
| void | begin_new_sub_path () | |
Begin a new subpath. Note that the existing path is not affected. After this call there will be no current point. In many cases, this call is not needed since new subpaths are frequently started with move_to(). A call to begin_new_sub_path() is particularly useful when beginning a new subpath with one of the arc() calls. This makes things easier as it is no longer necessary to manually compute the arc's initial coordinates for a call to move_to(). 1.2 | ||
| void | clip () | |
Establishes a new clip region by intersecting the current clip region with the current Path as it would be filled by fill() and according to the current fill rule. After clip(), the current path will be cleared from the cairo Context. The current clip region affects all drawing operations by effectively masking out any changes to the surface that are outside the current clip region. Calling clip() can only make the clip region smaller, never larger. But the current clip is part of the graphics state, so a temporary restriction of the clip region can be achieved by calling clip() within a save()/restore() pair. The only other means of increasing the size of the clip region is reset_clip(). set_fill_rule() | ||
| void | clip_preserve () | |
Establishes a new clip region by intersecting the current clip region with the current path as it would be filled by fill() and according to the current fill rule. Unlike clip(), clip_preserve preserves the path within the cairo Context. clip() set_fill_rule() | ||
| void | close_path () | |
Adds a line segment to the path from the current point to the beginning of the current subpath, (the most recent point passed to move_to()), and closes this subpath. After this call the current point will be at the joined endpoint of the sub-path. The behavior of close_path() is distinct from simply calling line_to() with the equivalent coordinate in the case of stroking. When a closed subpath is stroked, there are no caps on the ends of the subpath. Instead, there is a line join connecting the final and initial segments of the subpath. If there is no current point before the call to close_path(), this function will have no effect. | ||
| void | curve_to (double, double, double, double, double, double) | |
Adds a cubic Bezier spline to the path from the current point to position (x3, y3) in user-space coordinates, using (x1, y1) and (x2, y2) as the control points. After this call the current point will be (x3, y3). If there is no current point before the call to curve_to() this function will behave as if preceded by a call to move_to(x1, y1).
| ||
| void | fill () | |
A drawing operator that fills the current path according to the current fill rule, (each sub-path is implicitly closed before being filled). After fill(), the current path will be cleared from the cairo context. set_fill_rule() fill_preserve() | ||
| void | fill_preserve () | |
A drawing operator that fills the current path according to the current fill rule, (each sub-path is implicitly closed before being filled). Unlike fill(), fill_preserve() preserves the path within the cairo Context. set_fill_rule() fill(). | ||
| void | line_to (double, double) | |
Adds a line to the path from the current point to position (x, y) in user-space coordinates. After this call the current point will be (x, y). If there is no current point before the call to line_to() this function will behave as move_to(x, y).
| ||
| void | move_to (double, double) | |
If the current subpath is not empty, begin a new subpath. After this call the current point will be (x, y).
| ||
| void | paint () | |
A drawing operator that paints the current source everywhere within the current clip region. | ||
| void | paint_with_alpha (double) | |
A drawing operator that paints the current source everywhere within the current clip region using a mask of constant alpha value alpha. The effect is similar to paint(), but the drawing is faded out using the alpha value.
| ||
| void | rectangle (double, double, double, double) | |
Adds a closed-subpath rectangle of the given size to the current path at position (x, y) in user-space coordinates. This function is logically equivalent to: context->move_to(x, y); + context->rel_line_to(width, 0); + context->rel_line_to(0, height); + context->rel_line_to(-width, 0); + context->close_path();
| ||
| void | rel_curve_to (double, double, double, double, double, double) | |
Relative-coordinate version of curve_to(). All offsets are relative to the current point. Adds a cubic Bezier spline to the path from the current point to a point offset from the current point by (dx3, dy3), using points offset by (dx1, dy1) and (dx2, dy2) as the control points. After this call the current point will be offset by (dx3, dy3). Given a current point of (x, y), rel_curve_to(dx1, dy1, dx2, dy2, dx3, dy3) is logically equivalent to curve_to(x + dx1, y + dy1, x + dx2, y + dy2, x + dx3, y + dy3). It is an error to call this function with no current point. Doing so will cause this to shutdown with a status of CAIRO_STATUS_NO_CURRENT_POINT. Cairomm will then throw an exception.
| ||
| void | rel_line_to (double, double) | |
Relative-coordinate version of line_to(). Adds a line to the path from the current point to a point that is offset from the current point by (dx, dy) in user space. After this call the current point will be offset by (dx, dy). Given a current point of (x, y), rel_line_to(dx, dy) is logically equivalent to line_to(x + dx, y + dy). It is an error to call this function with no current point. Doing so will cause this to shutdown with a status of CAIRO_STATUS_NO_CURRENT_POINT. Cairomm will then throw an exception.
| ||
| void | rel_move_to (double, double) | |
If the current subpath is not empty, begin a new subpath. After this call the current point will offset by (x, y). Given a current point of (x, y), rel_move_to(dx, dy) is logically equivalent to move_to(x + dx, y + dy) It is an error to call this function with no current point. Doing so will cause this to shutdown with a status of CAIRO_STATUS_NO_CURRENT_POINT. Cairomm will then throw an exception.
| ||
| void | reset_clip () | |
Reset the current clip region to its original, unrestricted state. That is, set the clip region to an infinitely large shape containing the target surface. Equivalently, if infinity is too hard to grasp, one can imagine the clip region being reset to the exact bounds of the target surface. Note that code meant to be reusable should not call reset_clip() as it will cause results unexpected by higher-level code which calls clip(). Consider using save() and restore() around clip() as a more robust means of temporarily restricting the clip region. | ||
| void | restore () | |
Restores cr to the state saved by a preceding call to save() and removes that state from the stack of saved states. save() | ||
| void | rotate (double) | |
Modifies the current transformation matrix (CTM) by rotating the user-space axes by angle radians. The rotation of the axes takes places after any existing transformation of user space. The rotation direction for positive angles is from the positive X axis toward the positive Y axis.
| ||
| void | save () | |
Makes a copy of the current state of the Context and saves it on an internal stack of saved states. When restore() is called, it will be restored to the saved state. Multiple calls to save() and restore() can be nested; each call to restore() restores the state from the matching paired save(). It isn't necessary to clear all saved states before a cairo_t is freed. Any saved states will be freed when the Context is destroyed. restore() | ||
| void | scale (double, double) | |
Modifies the current transformation matrix (CTM) by scaling the X and Y user-space axes by sx and sy respectively. The scaling of the axes takes place after any existing transformation of user space.
| ||
| void | set_dash (DoubleVector&, double) | |
| void | set_font_size (double) | |
Sets the current font matrix to a scale by a factor of size, replacing any font matrix previously set with set_font_size() or set_font_matrix(). This results in a font size of size user space units. (More precisely, this matrix will result in the font's em-square being a by size square in user space.) If text is drawn without a call to set_font_size(), (nor set_font_matrix() nor set_scaled_font()), the default font size is 10.0.
| ||
| void | set_line_cap (LineCap) | |
Sets the current line cap style within the cairo Context. See LineCap for details about how the available line cap styles are drawn. As with the other stroke parameters, the current line cap style is examined by stroke(), stroke_extents(), and stroke_to_path(), but does not have any effect during path construction. The default line cap style is Cairo::LINE_CAP_BUTT.
| ||
| void | set_line_join (LineJoin) | |
Sets the current line join style within the cairo Context. See LineJoin for details about how the available line join styles are drawn. As with the other stroke parameters, the current line join style is examined by stroke(), stroke_extents(), and stroke_to_path(), but does not have any effect during path construction. The default line join style is Cairo::LINE_JOIN_MITER.
| ||
| void | set_line_width (double) | |
Sets the current line width within the cairo Context. The line width specifies the diameter of a pen that is circular in user-space, (though device-space pen may be an ellipse in general due to scaling/shear/rotation of the CTM). Note: When the description above refers to user space and CTM it refers to the user space and CTM in effect at the time of the stroking operation, not the user space and CTM in effect at the time of the call to set_line_width(). The simplest usage makes both of these spaces identical. That is, if there is no change to the CTM between a call to set_line_width() and the stroking operation, then one can just pass user-space values to set_line_width() and ignore this note. As with the other stroke parameters, the current line cap style is examined by stroke(), stroke_extents(), and stroke_to_path(), but does not have any effect during path construction. The default line width value is 2.0.
| ||
| void | set_operator (Operator) | |
Sets the compositing operator to be used for all drawing operations. See Operator for details on the semantics of each available compositing operator.
| ||
| void | set_source_rgb (double, double, double) | |
Sets the source pattern within the Context to an opaque color. This opaque color will then be used for any subsequent drawing operation until a new source pattern is set. The color components are floating point numbers in the range 0 to 1. If the values passed in are outside that range, they will be clamped. set_source_rgba() set_source()
| ||
| void | set_source_rgba (double, double, double, double) | |
Sets the source pattern within the Context to a translucent color. This color will then be used for any subsequent drawing operation until a new source pattern is set. The color and alpha components are floating point numbers in the range 0 to 1. If the values passed in are outside that range, they will be clamped. set_source_rgb() set_source()
| ||
| void | show_text (std::string) | |
A drawing operator that generates the shape from a string of UTF-8 characters, rendered according to the current font_face, font_size (font_matrix), and font_options. This function first computes a set of glyphs for the string of text. The first glyph is placed so that its origin is at the current point. The origin of each subsequent glyph is offset from that of the previous glyph by the advance values of the previous glyph. After this call the current point is moved to the origin of where the next glyph would be placed in this same progression. That is, the current point will be at the origin of the final glyph offset by its advance values. This allows for easy display of a single logical string with multiple calls to show_text(). Note: The show_text() function call is part of what the cairo designers call the "toy" text API. It is convenient for short demos and simple programs, but it is not expected to be adequate for serious text-using applications. See show_glyphs() for the "real" text display API in cairo.
| ||
| void | stroke () | |
A drawing operator that strokes the current Path according to the current line width, line join, line cap, and dash settings. After stroke(), the current Path will be cleared from the cairo Context. set_line_width() set_line_join() set_line_cap() set_dash() stroke_preserve(). Note: Degenerate segments and sub-paths are treated specially and provide a useful result. These can result in two different situations: 1. Zero-length "on" segments set in set_dash(). If the cap style is Cairo::LINE_CAP_ROUND or Cairo::LINE_CAP_SQUARE then these segments will be drawn as circular dots or squares respectively. In the case of Cairo::LINE_CAP_SQUARE, the orientation of the squares is determined by the direction of the underlying path. 2. A sub-path created by move_to() followed by either a close_path() or one or more calls to line_to() to the same coordinate as the move_to(). If the cap style is Cairo::LINE_CAP_ROUND then these sub-paths will be drawn as circular dots. Note that in the case of Cairo::LINE_CAP_SQUARE a degenerate sub-path will not be drawn at all, (since the correct orientation is indeterminate). In no case will a cap style of Cairo::LINE_CAP_BUTT cause anything to be drawn in the case of either degenerate segments or sub-paths. | ||
| void | stroke_preserve () | |
A drawing operator that strokes the current Path according to the current line width, line join, line cap, and dash settings. Unlike stroke(), stroke_preserve() preserves the Path within the cairo Context. set_line_width() set_line_join() set_line_cap() set_dash() stroke_preserve(). | ||
| void | translate (double, double) | |
Modifies the current transformation matrix (CTM) by translating the user-space origin by (tx, ty). This offset is interpreted as a user-space coordinate according to the CTM in place before the new call to translate. In other words, the translation of the user-space origin takes place after any existing transformation.
| ||
| void | unset_dash () | |
This function disables a dash pattern that was set with set_dash() | ||
C‡: Evoral::Beats
+ +Musical time in beats.
| Methods | ||
|---|---|---|
| double | to_double () | |
C‡: boost::shared_ptr< Evoral::Control >, boost::weak_ptr< Evoral::Control >
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
| ControlList | list () | |
C‡: boost::shared_ptr< Evoral::ControlList >, boost::weak_ptr< Evoral::ControlList >
+ +| Methods | ||
|---|---|---|
| void | add (double, double, bool, bool) | |
| bool | isnil () | |
C‡: boost::shared_ptr< Evoral::ControlSet >, boost::weak_ptr< Evoral::ControlSet >
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
C‡: Evoral::Event<long>
+ +| Methods | ||
|---|---|---|
| unsigned char* | buffer () | |
| void | clear () | |
| void | set_buffer (unsigned int, unsigned char*, bool) | |
| unsigned int | size () | |
C‡: Evoral::MIDIEvent<long>
+is-a: Evoral:Event
+ +| Methods | ||
|---|---|---|
| unsigned char | channel () | |
| unsigned char | set_channel () | |
| unsigned char | set_type () | |
| unsigned char | type () | |
| Methods | ||
|---|---|---|
| unsigned char* | buffer () | |
| void | clear () | |
| void | set_buffer (unsigned int, unsigned char*, bool) | |
| unsigned int | size () | |
C‡: Evoral::Parameter
+ +ID of a [play|record|automate]able parameter.
A parameter is defined by (type, id, channel). Type is an integer which can be used in any way by the application (e.g. cast to a custom enum, map to/from a URI, etc). ID is type specific (e.g. MIDI controller #).
This class defines a < operator which is a strict weak ordering, so Parameter may be stored in a std::set, used as a std::map key, etc.
| Constructor | ||
|---|---|---|
| ℂ | Evoral.Parameter (unsigned int, unsigned char, unsigned int) | |
| Methods | ||
| unsigned char | channel () | |
| unsigned int | id () | |
| unsigned int | type () | |
C‡: Evoral::ParameterDescriptor
+ +Description of the value range of a parameter or control.
| Constructor | ||
|---|---|---|
| ℂ | Evoral.ParameterDescriptor () | |
| Data Members | ||
| float | lower | |
| float | normal | |
| bool | toggled | |
| float | upper | |
C‡: std::bitset<47ul>
+ +| Constructor | ||
|---|---|---|
| ℂ | LuaSignal.Set () | |
| Methods | ||
| LuaTable | add (LuaTable {47ul}) | |
| bool | any () | |
| unsigned long | count () | |
| bool | none () | |
| Set | reset () | |
| Set | set (unsigned long, bool) | |
| unsigned long | size () | |
| LuaTable | table () | |
| bool | test (unsigned long) | |
C‡: boost::shared_ptr< PBD::Controllable >, boost::weak_ptr< PBD::Controllable >
+is-a: PBD:StatefulDestructiblePtr
+ +| Methods | ||
|---|---|---|
| double | get_value () | |
| bool | isnil () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: PBD::ID
+ +| Constructor | ||
|---|---|---|
| ℂ | PBD.ID (std::string) | |
| Methods | ||
| std::string | to_s () | |
C‡: PBD::Stateful
+ +Base class for objects with saveable and undoable state
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: PBD::StatefulDestructible
+is-a: PBD:Stateful
+ +Base class for objects with saveable and undoable state
This class object is only used indirectly as return-value and function-parameter. It provides no methods by itself.
+| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: boost::shared_ptr< PBD::StatefulDestructible >, boost::weak_ptr< PBD::StatefulDestructible >
+is-a: PBD:StatefulPtr
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
| Methods | ||
|---|---|---|
| OwnedPropertyList | properties () | |
C‡: boost::shared_ptr< PBD::Stateful >, boost::weak_ptr< PBD::Stateful >
+ +| Methods | ||
|---|---|---|
| bool | isnil () | |
| OwnedPropertyList | properties () | |
C‡: Timecode::BBT_Time
+ +Bar, Beat, Tick Time (i.e. Tempo-Based Time)
| Constructor | ||
|---|---|---|
| ℂ | Timecode.BBT_TIME (unsigned int, unsigned int, unsigned int) | |