Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

▼Npongasoft
▼Npongasoft
▼NUtils
▼NCollection
CCircularBuffer
▼NConcurrent
►NLockFree
CAtomicValue	This is the lock free version of the AtomicValue
CSingleElementQueue	This is the lock free version of the SingleElementQueue
►CSingleElementStorage	This (internal) class stores a single element
CElement
►NWithSpinLock	The purpose of this namespace is to emphasize the fact that the implementation is using a spinlock
CAtomicValue	This class encapsulates a single atomic value
CSingleElementQueue	This class implements a queue which has at most 1 element (0 or 1)
▼Ncpp17
►Nexperimental	The code here is copied from <experimental/type_traits> because it is not implemented with Visual studio build tools 17
C_DETECTOR
C_DETECTOR< _Default, void_t< _Op< _Args... > >, _Op, _Args... >
Cnonesuch
▼NOperators
CDereferenceable	Implements all the various equality and relational operators for the type T which is assumed to encapsulate some value that can be accessed by dereferencing T or in other words T::operator*() returns the underlying value
CCast	Dynamic_cast<U *>(x) does not compile if x is not polymorphic
CDisposable	Classes who can release resources can implement this interface
CLerp	Util class to compute linear interpolation
CRange	Defines a range of values
▼NVST
▼NDebug
CParamDisplay	This helper class is used to display the parameters (vst/jmb) WARNING: this class is allocating memory and as a result should be used in RT only during development!
CParamLine	This helper class is used to display the parameters (vst/jmb) in a line WARNING: this class is allocating memory and as a result should be used in RT only during development!
CParamTable	This helper class is used to display the parameters (vst/jmb) in a table WARNING: this class is allocating memory and as a result should be used in RT only during development!
▼NGUI
►NParams
CDefaultEditorImpl	Default implementation of the editor interface
CDiscreteParamConverter	Simple wrapper to allow to treat any vst parameter as a discrete one: uses the vst sdk definition of what a discrete property is
CGUIDiscreteJmbParameter	Wraps a GUIJmbParameter<T> to interpret it as a discrete parameter using the converter
CGUIDiscreteValParameter	Simple extension class to treat a Val parameter as a discrete one
CGUIJmbParam	This is the main class that the plugin should use as it exposes only the necessary methods of the param as well as redefine a couple of operators which helps in writing simpler and natural code (the param behaves like T in many ways)
CGUIJmbParameter	This is the templated version providing serializer methods, very similar to the GUIVstParameter concept
►CGUIOptionalParam	Represents an optional parameter (Jmb, Vst or no param at all)
CValue	The purpose of this class is to copy the value so that it can be accessed via -> thus allowing to write param->x to access the underlying type (T) when it is a struct or a class
CGUIParamCx	Wrapper class which maintains the connection between a parameter and its listener
CGUIParamCxAware	Code has been moved to ParamAware class
CGUIParamCxMgr	Maintains the connections established between parameters and its listeners/callbacks
CGUIRawVstParam	This is the main class that the plugin should use as it exposes only the necessary methods of the param as well as redefine a couple of operators which helps in writing simpler and natural code (the param behaves like T in many ways)
►CGUIRawVstParameter	Encapsulates a vst parameter and how to access it (read/write) as well as how to "connect" to it in order to be notified of changes
CEditor	Wrapper to edit a single parameter
CGUIValParameter	This parameter is not tied to any parameter definition/registration and is primarily used by the optional parameter
►CGUIVstParam	This is the main class that the plugin should use as it exposes only the necessary methods of the param as well as redefine a couple of operators which helps in writing simpler and natural code (the param behaves like T in many ways)
CValue	The purpose of this class is to copy the value so that it can be accessed via -> thus allowing to write param->x to access the underlying type (T) when it is a struct or a class
►CGUIVstParameter	This class wraps a GUIRawVstParameter to deal with any type T
CEditor	Wrapper to edit a single parameter
CIGUIJmbParameter	Base class for a Jamba (Jmb) GUI parameter
CIGUIParam	Wrapper instance returned by ParamAware::registerBaseParam() methods
►CIGUIParameter	This is the base class of all GUI parameters
CEditor	Defines the basic and common API of all parameter editors (allow to commit/rollback)
►CITGUIParameter	Represents a gui parameter with its underlying backing type T (aka ParamType)
CITEditor	Defines the API for the editor which can be obtained by calling ITGUIParameter::edit()
CParamAware	This class is inherited by classes who want to be aware of parameters and be notified when they change
CParamAwareView	This subclass allows for registering callbacks to any kind of view without having to inherit from it
CUTF8StringParamSerializer	A parameter backed by a UTF8String
CViewGUIParamCxAware
CVstParameters	This class acts as a facade/proxy to the vst parameters managed by the host daw
►NViews
CCustomController	Base class that a custom controller can inherit from
►CCustomControlView	Base class for custom views which are tied to one parameter only (similar to CControl)
CCreator
►CCustomDiscreteControlView	Specialization of TCustomControlView for discrete values
CCreator
CCustomUIViewFactory	Custom view factory to give access to vst parameters
►CCustomView	Class you should inherit from if you want to write a custom view
CCreator	Defines and registers the attributes exposed in the VSTGUI Editor and XML file (.uidesc) for CustomView
►CCustomViewAdapter	This class can be used to extend VSTGUI classes directly while still benefiting from the extensions added by Jamba
CCreator	Defines and registers the attributes exposed in the VSTGUI Editor and XML file (.uidesc) for CustomViewAdapter
CCustomViewCreator	Inherit from this class to provide the factory for a custom view
►CDebugParamDisplayView	This parameter simply extends ParamDisplayView to "highlight" the parameter for highlight-duration-ms milliseconds (by default 1s) when its value changes
CCreator
►CDiscreteButtonView	A discrete button behaves like a toggle button except that it is on only if the control value (tied to a parameter) is equal to the step value (DiscreteButtonView::getStep() / step property in the xml)
CCreator
CGlobalKeyboardHook	The CView class provides 2 methods to handle keyboard events (CView::onKeyDown and CView::onKeyUp) which only works as long as the view itself has focus
CICustomViewLifecycle	This interface defines some methods that are important in the lifecycle of a custom view
CJambaViews	Defines/Registers the views exported by the framework (since jamba is a static library defining the creators as global variables does not work)
►CMomentaryButtonView	A momentary button is a button that lets you set the value of a parameter to its "on" value when pressed, otherwise its "off" value
CCreator
►CParamDisplayView	This view extends CParamDisplay to work for both Vst and Jmb parameters
CCreator
CPluginAccessor
CPluginCustomController
CPluginCustomView
CPluginCustomViewAdapter
CPluginView
►CScrollbarView	Generic scrollbar which handles scrolling and (optional) zooming via handles
CCreator
CZoomBox	Represents the box (dimension and position point of view) containing the zoom handles and scrollbar
CSelfContainedViewListener	The purpose of this class is to implement a view listener that is "self-contained":
CStateAware	This class is used to get access to the GUI state and parameters of the plugin with their actual type
CStateAwareCustomController	Override from this class if you need to implement a controller specific to a given plugin
CStateAwareCustomViewAdapter	This class can be used to extend VST SDK classes directly while still benefiting from the extensions added by this framework (multiple param access and state access)
CStateAwareView	Override from this class if you need to implement a (custom) view specific to a given plugin
►CStepButtonView	A step button lets you step through the values of a parameter by repeatedly clicking on the button
CCreator
►CSwitchViewContainer	This view offers dynamic switching between multiple views
CCreator
CTCustomControlView	Base class which extends CustomControlView to provide the type (T) of the underlying parameter this view is managing
►CTCustomViewCreator	Generic custom view creator base class
CBitmapAttribute	Specialization for a bitmap attribute
CBooleanAttribute	Specialization for the boolean attribute
CColorAttribute	Specialization for the color attribute
CFloatAttribute	Specialization for an float attribute (which can be a double or a float, etc..)
CFontAttribute	Specialization for a bitmap attribute
CGradientAttribute	Specialization for the color attribute
CIntegerAttribute	Specialization for an Integer attribute (which can be any kind of integer, like short, int32_t, etc..)
CListAttribute	Specialization for a list of possible values defined by the AttributeMap
CMarginAttribute	Specialization for the margin attribute
CRangeAttribute	Specialization for the range attribute
CTagAttribute	Specialization for a tag attribute (vst type TagID)
CTAttribute	Generic base class that implements the logic for a ViewAttribute that uses a getter and setter in TView
CVectorStringAttribute	Specialization for a vector of strings
►CTextButtonView	Extension of the CTextButton view to add more functionality
CCreator
CTextEdit	The purpose of this class is to adapt the constructor signature to a single element, required in the framework
►CTextEditView	Extends the CTextEdit view to tie it to a GUIJmbParam<UTF8String>
CCreator
►CToggleButtonView	A toggle button is a button that lets you toggle the value of a parameter between an "on" value and an "off" value
CCreator
CViewAttribute	Base abstract class for an attribute of a view
CGUIController	Base class from which the actual controller inherits from
CGUIPluginState	Simple templated extension to expose the plugin parameters as its real type
CGUIState
CIJmbParamDef	Base class for jamba parameters (non templated)
CIParamDef	Base class for all ParamDef
CJmbParamDef	Base class for all non vst parameters (need to provide serialization/deserialization)
CMargin	Margin is a similar concept to css: used to create space around elements, outside of any defined borders
CParamAwareViews	This class manages the views that have been made "param aware"
CRawVstParamDef	Base class for a raw vst parameter definition
CRelativeDrawContext	Encapsulates the draw context provided by VSTGUI to reason in relative coordinates (0,0) is top,left
CRelativeView
CStringDrawContext
CVstParamDef	Typed parameter definition
▼NRT
CIRTJmbInParameter	Base (non templated) class for RT Jamba (Inbound) parameters
CIRTJmbOutParameter	Base (non templated) class for RT Jamba (Outbound) parameters
CRTJmbInParam	This is the main class that the plugin should use as it exposes only the necessary methods of the param as well as redefine a couple of operators which helps in writing simpler and natural code (the param behaves like T in many ways)
CRTJmbInParameter	Templated class for RT Jamba Inbound parameter
CRTJmbOutParam	This is the main class that the plugin should use as it exposes only the necessary methods of the param
CRTJmbOutParameter	Templated class for RT Jamba parameter
►CRTProcessor	Base class from which the actual processor inherits from
CGUITimerCallback
CRTRawVstParam	This is the main class that the plugin should use as it exposes only the necessary methods of the param as well as redefine a couple of operators which helps in writing simpler and natural code (the param behaves like T in many ways)
CRTRawVstParameter	Base class which deals with the "raw"/untyped parameter and keep the normalized value (ParamValue in the range [0.0,1.0])
CRTState	Manages the state used by the processor: you add all the parameters that the state manages using the add method
CRTVstParam	This is the main class that the plugin should use as it exposes only the necessary methods of the param as well as redefine a couple of operators which helps in writing simpler and natural code (the param behaves like T in many ways)
CRTVstParameter	The typed version
▼CAudioBuffers	Represents all the buffers (example for a stereo channel there is 2 underlying sample buffers)
CAbsoluteMaxOp	Unary operator adapter for computing the absolute max
CChannel	Represents a single channel (for example left audio channel)
CAutoReleaseTimer	Simple wrapper class around Steinberg::Timer which will automatically release the timer on delete
CBooleanParamConverter	Manages the very common case when a param represents a boolean value
CBooleanParamSerializer	This parameter handles serializing a bool parameter
CBufferStream	Internal class to override the BufferStream class and give access to the buffer
CCStringParamSerializer	A parameter backed by a C type string (char[size])
CDiscreteTypeParamConverter	This converters maps a list of values of type T to discrete values
CDiscreteTypeParamSerializer	This converters maps a list of values of type T to discrete values
CDiscreteValueParamConverter	A converter to deal with a discrete value which has StepCount steps
CDoubleParamSerializer	This parameter handles serializing a double parameter
CEnumParamConverter	A converter to deal with an enum (assumes that the enum is contiguous, starts at 0 and that MaxValue is the latest value in the enum)
CFObjectCx	Wrapper class which maintains a connection between the target and this object
CFObjectCxCallback	Wrapper class which will invoke the callback when the target is changed
CIDiscreteConverter	Interface that defines a converter from a type T to an int32 given a number of steps (provided by getStepCount)
CIMessageHandler	Interface defining a message handler
CIMessageProducer	Abstraction for allocating and sending a message
CInt32ParamSerializer	This parameter handles serializing a int32 parameter
CInt64ParamSerializer	This parameter handles serializing a int64 parameter
CIParamConverter	A vst parameter is represented by a ParamValue type which is a double in the range [0,1]
CIParamSerializer	A vst parameter is represented by a ParamValue type which is a double in the range [0,1]
CMessage	Simple wrapper class with better api
CMessageHandler	Simple implementation of IMessageHandler which will delegate the message handling based on MessageID
▼CNormalizedState	Used to communicate the state between the UI and the RT and read/write to stream
CSaveOrder	Maintains the order used to save/restore the RT and GUI state
▼CParameters	This is the class which maintains all the registered parameters
CIChangeListener	Interface to implement to receive parameter changes
CJmbParamDefBuilder	Implements the builder pattern for ease of build
CRawVstParamDefBuilder	Implements the builder pattern for ease of build
CVstParamDefBuilder	Implements the builder pattern for ease of build
CPercentParamConverter	A trivial percent converter
CRawParamConverter	This parameter is just a no-op wrapper to the ParamValue to adapt it to the use of the ParamConverter concept
CRawParamSerializer	This parameter handles serializing a raw parameter (ParamValue)
▼CSampleRateBasedClock	The purpose of this class is to deal with timing based on the sample rate and do the proper conversions
CRateLimiter	Keeps track of the time in number of samples processed vs sample rate
CStaticCastDiscreteConverter	This implementation simply cast T to an int32 (and vice-versa)
CVstParameterImpl	Internal class which extends the Vst::Parameter to override toString and delegate to the param def
▼CSpinLock	A simple implementation of a spin lock using the std::atomic_flag which is guaranteed to be atomic and lock free
CLock