| Njuce | |
| Nuniversal_midi_packets | |
| CBytesOnGroup | Holds a UMP group, and a span of bytes that were received or are to be sent on that group |
| CDeviceInfo | Holds MIDI device info that may be required by certain UMP messages and MIDI-CI messages |
| CStringUtils | Holds utility functions for extracting textual representations of Universal MIDI Packets |
| CBlock | Represents a Function Block (FB) or Group Terminal Block (GTB) |
| CDisconnectionListener | An interface class for entities that are interested in disconnection notifications |
| CEndpoint | Represents a single MIDI endpoint, which may have up to one input and up to one output |
| CEndpointId | Identifies a MIDI endpoint |
| CEndpointsListener | An interface class for types that are interested in receiving updates about changes to available MIDI endpoints |
| CEndpoints | Endpoints known to the system |
| CConsumer | An interface class for entities that consume Universal MIDI Packets from some producer |
| CInput | An input (from the JUCE project's perspective) that receives messages sent by an endpoint |
| CLegacyVirtualInput | Represents a virtual MIDI 1.0 input port |
| CLegacyVirtualOutput | Represents a virtual MIDI 1.0 output port |
| COutput | An output (from the JUCE project's perspective) that sends messages to an endpoint |
| CSession | Allows creating new connections to endpoints, and also creating new virtual endpoints |
| CStaticDeviceInfo | Static information about a particular MIDI device that can be queried without opening a connection to the device |
| CVirtualEndpoint | Represents a virtual device that allows this program to advertise itself to other MIDI-aware applications on the system |
| NValueSmoothingTypes | A namespace containing a set of types used for specifying the smoothing behaviour of the SmoothedValue class |
| CLinear | Used to indicate a linear smoothing between values |
| CMultiplicative | Used to indicate a smoothing between multiplicative values |
| NARAHostModel | |
| CConversionFunctions | Allows converting, without warnings, between pointers of two unrelated types |
| CManagedARAHandle | This class is used by the various ARA model object helper classes, such as MusicalContext, AudioSource etc |
| CAudioSource | Helper class for the host side implementation of the ARA AudioSource model object |
| CAudioModification | Helper class for the host side implementation of the ARA AudioModification model object |
| CDeletionListener | This class is used internally by PlaybackRegionRegistry to be notified when a PlaybackRegion object is deleted |
| CPlaybackRegion | Helper class for the host side implementation of the ARA PlaybackRegion model object |
| CMusicalContext | Helper class for the host side implementation of the ARA MusicalContext model object |
| CRegionSequence | Helper class for the host side implementation of the ARA RegionSequence model object |
| CPlaybackRegionRegistry | Base class used by the ::PlaybackRendererInterface and ::EditorRendererInterface plugin extension interfaces |
| CPlugInExtensionInstance | Wrapper class for ARA::ARAPlugInExtensionInstance* |
| NTypeHelpers | This namespace contains a few template classes for helping work out class type variations |
| CParameterType | The ParameterType struct is used to find the best type to use when passing some kind of object as a parameter |
| CUnsignedTypeWithSize | These templates are designed to take an integer type, and return an unsigned int version with the same size |
| Ndsp | |
| NDelayLineInterpolationTypes | A collection of structs to pass as the template argument when setting the interpolation type for the DelayLine class |
| CNone | No interpolation between successive samples in the delay line will be performed |
| CLinear | Successive samples in the delay line will be linearly interpolated |
| CLagrange3rd | Successive samples in the delay line will be interpolated using a 3rd order Lagrange interpolator |
| CThiran | Successive samples in the delay line will be interpolated using 1st order Thiran interpolation |
| NFIR | Classes for FIR filter processing |
| CCoefficients | A set of coefficients for use in an FIRFilter object |
| CFilter | A processing class that can perform FIR filtering on an audio signal, in the time domain |
| NIIR | Classes for IIR filter processing |
| CArrayCoefficients | A set of coefficients for use in an Filter object |
| CCoefficients | A set of coefficients for use in an Filter object |
| CFilter | A processing class that can perform IIR filtering on an audio signal, using the Transposed Direct Form II digital structure |
| NStateVariableFilter | Classes for state variable filter processing |
| CParameters | Structure used for the state variable filter parameters |
| CFilter | An IIR filter that can perform low, band and high-pass filtering on an audio signal, with 12 dB of attenuation per octave, using a TPT structure, designed for fast modulation (see Vadim Zavalishin's documentation about TPT structures for more information) |
| CAudioBlock | Minimal and lightweight data-structure which contains a list of pointers to channels containing some kind of sample data |
| CSIMDRegister | A wrapper around the platform's native SIMD register type |
| CElementAccess | |
| CFilterDesign | This class provides a set of functions which generates FIR::Coefficients and IIR::Coefficients, of high-order low-pass filters |
| CIIRPolyphaseAllpassStructure | The structure returned by the function designIIRLowpassHalfBandPolyphaseAllpassMethod |
| CConvolutionMessageQueue | Used by the Convolution to dispatch engine-update messages on a background thread |
| CConvolution | Performs stereo partitioned convolution of an input signal with an impulse response in the frequency domain, using the JUCE FFT class |
| CLatency | Contains configuration information for a convolution with a fixed latency |
| CNonUniform | Contains configuration information for a non-uniform convolution |
| CFFT | Performs a fast fourier transform |
| CWindowingFunction | A class which provides multiple windowing functions useful for filter design and spectrum analyzers |
| CFastMathApproximations | This class contains various fast mathematical function approximations |
| CLogRampedValue | Utility class for logarithmically smoothed linear values |
| CLookupTable | Class for efficiently approximating expensive arithmetic operations |
| CLookupTableTransform | Class for approximating expensive arithmetic operations |
| CMatrix | General matrix and vectors class, meant for classic math manipulation such as additions, multiplications, and linear systems of equations solving |
| CPhase | Represents an increasing phase value between 0 and 2*pi |
| CPolynomial | A class representing a polynomial |
| CSpecialFunctions | Contains miscellaneous filter design and windowing functions |
| CBallisticsFilter | A processor to apply standard attack / release ballistics to an input signal |
| CDelayLine | A delay line processor featuring several algorithms for the fractional delay calculation, block processing, and sample-by-sample processing useful when modulating the delay in real time or creating a standard delay effect with feedback |
| CDryWetMixer | A processor to handle dry/wet mixing of two audio signals, where the wet signal may have additional latency |
| CFirstOrderTPTFilter | A first order filter class using the TPT (Topology-Preserving Transform) structure |
| CLinkwitzRileyFilter | A filter class designed to perform multi-band separation using the TPT (Topology-Preserving Transform) structure |
| COversampling | A processor that performs multi-channel oversampling |
| CPanner | A processor to perform panning operations on stereo buffers |
| CProcessSpec | This structure is passed into a DSP algorithm's prepare() method, and contains information about various aspects of the context in which it can expect to be called |
| CProcessorState | This is a handy base class for the state of a processor (such as parameter values) which is typically shared among several processors |
| CProcessContextReplacing | Contains context information that is passed into an algorithm's process method |
| CProcessContextNonReplacing | Contains context information that is passed into an algorithm's process method |
| CProcessorChain | This variadically-templated class lets you join together any number of processor classes into a single processor which will call process() on them all in sequence |
| CProcessorDuplicator | Converts a mono processor class into a multi-channel version by duplicating it and applying multichannel buffers across an array of instances |
| CProcessorBase | Acts as a polymorphic base class for processors |
| CProcessorWrapper | Wraps an instance of a given processor class, and exposes it through the ProcessorBase interface |
| CStateVariableTPTFilter | An IIR filter that can perform low, band and high-pass filtering on an audio signal, with 12 dB of attenuation per octave, using a TPT structure, designed for fast modulation (see Vadim Zavalishin's documentation about TPT structures for more information) |
| CBias | Adds a DC offset (voltage bias) to the audio samples |
| CChorus | A simple chorus DSP widget that modulates the delay of a delay line in order to create sweeping notches in the magnitude frequency response |
| CCompressor | A simple compressor with standard threshold, ratio, attack time and release time controls |
| CGain | Applies a gain to audio samples as single samples or AudioBlocks |
| CLadderFilter | Multi-mode filter based on the Moog ladder filter |
| CLimiter | A simple limiter with standard threshold and release time controls, featuring two compressors and a hard clipper at 0 dB |
| CNoiseGate | A simple noise gate with standard threshold, ratio, attack time and release time controls |
| COscillator | Generates a signal based on a user-supplied function |
| CPhaser | A 6 stage phaser that modulates first order all-pass filters to create sweeping notches in the magnitude frequency response |
| CReverb | Processor wrapper around juce::Reverb for easy integration into ProcessorChain |
| CWaveShaper | Applies waveshaping to audio samples as single samples or AudioBlocks |
| NAnimatedPositionBehaviours | Contains classes for different types of physics behaviours - these classes are used as template parameters for the AnimatedPosition class |
| CContinuousWithMomentum | A non-snapping behaviour that allows the content to be freely flicked in either direction, with momentum based on the velocity at which it was released, and variable friction to make it come to a halt |
| CSnapToPageBoundaries | A behaviour that gravitates an AnimatedPosition object towards the nearest integer position when released |
| Nmidi_ci | |
| NMessage | Namespace containing structs representing different kinds of MIDI-CI message |
| CComparableRange | Wraps a span, providing equality operators that compare the span contents elementwise |
| CHeader | Holds fields that can be found at the beginning of every MIDI CI message |
| CGeneric | Groups together a CI message header, and some number of trailing bytes |
| CDiscoveryResponse | See the MIDI-CI specification |
| CDiscovery | See the MIDI-CI specification |
| CEndpointInquiryResponse | See the MIDI-CI specification |
| CEndpointInquiry | See the MIDI-CI specification |
| CInvalidateMUID | See the MIDI-CI specification |
| CACK | See the MIDI-CI specification |
| CNAK | See the MIDI-CI specification |
| CProfileInquiryResponse | See the MIDI-CI specification |
| CProfileInquiry | See the MIDI-CI specification |
| CProfileAdded | See the MIDI-CI specification |
| CProfileRemoved | See the MIDI-CI specification |
| CProfileDetailsResponse | See the MIDI-CI specification |
| CProfileDetails | See the MIDI-CI specification |
| CProfileOn | See the MIDI-CI specification |
| CProfileOff | See the MIDI-CI specification |
| CProfileEnabledReport | See the MIDI-CI specification |
| CProfileDisabledReport | See the MIDI-CI specification |
| CProfileSpecificData | See the MIDI-CI specification |
| CPropertyExchangeCapabilitiesResponse | See the MIDI-CI specification |
| CPropertyExchangeCapabilities | See the MIDI-CI specification |
| CStaticSizePropertyExchange | A property-exchange message that has no payload, and must therefore be contained in a single chunk |
| CDynamicSizePropertyExchange | A property-exchange message that may form part of a multi-chunk message sequence |
| CPropertyGetDataResponse | See the MIDI-CI specification |
| CPropertyGetData | See the MIDI-CI specification |
| CPropertySetDataResponse | See the MIDI-CI specification |
| CPropertySetData | See the MIDI-CI specification |
| CPropertySubscribeResponse | See the MIDI-CI specification |
| CPropertySubscribe | See the MIDI-CI specification |
| CPropertyNotify | See the MIDI-CI specification |
| CProcessInquiryResponse | See the MIDI-CI specification |
| CProcessInquiry | See the MIDI-CI specification |
| CProcessMidiMessageReportResponse | See the MIDI-CI specification |
| CProcessMidiMessageReport | See the MIDI-CI specification |
| CProcessEndMidiMessageReport | See the MIDI-CI specification |
| CParsed | A message with a header and optional body |
| CChannelAddress | Identifies a channel or set of channels in a multi-group MIDI endpoint |
| CDevice | Instances of this type are responsible for parsing and interpreting incoming MIDI-CI messages, and for sending MIDI-CI messages to other devices |
| CDeviceFeatures | Flags indicating the features that are supported by a given CI device |
| CPropertySubscriptionData | Contains information relating to a subscription update |
| CDeviceListener | An interface that receives callbacks when certain messages are received by a Device |
| CDeviceMessageHandler | An interface that will receive a callback every time a Device wishes to send a new MIDI-CI message |
| CDeviceOptions | Configuration options for a Device |
| CEncodingUtils | Utility functions for working with the Encoding enum |
| CEncodings | Utility functions for working with data formats used by property exchange messages |
| CFunctionBlock | Contains information about a MIDI 2.0 function block |
| CChannelInGroupUtils | Utility functions for working with the ChannelInGroup enum |
| CMUID | A 28-bit ID that uniquely identifies a device taking part in a series of MIDI-CI transactions |
| CParser | Parses CI messages |
| CProfileAtAddress | Holds a profile ID, and the address of a group/channel |
| CProfileDelegate | An interface with methods that can be overridden to customise how a Device implementing profiles responds to profile inquiries |
| CProfileHost | Acting as a ResponderListener, instances of this class can formulate appropriate replies to profile transactions initiated by remote devices |
| CProfileStateEntry | Holds a profile ID, along with the number of supported and active channels corresponding to that profile |
| CChannelProfileStates | Holds the number of channels that are supported and activated for all profiles at a particular channel address |
| CGroupProfileStates | Contains profile states for each channel in a group, along with the state of profiles that apply to the group itself |
| CBlockProfileStates | Contains profile states for each group and channel in a function block, along with the state of profiles that apply to the function block itself |
| CPropertySubscriptionCommandUtils | Functions to use with PropertySubscriptionCommand |
| CPropertySubscriptionHeader | A struct containing data members that correspond to common fields in a property subscription header |
| CPagination | Contains information about the pagination of a request |
| CPropertyRequestHeader | A struct containing data members that correspond to common fields in a property request header |
| CPropertyRequestData | Bundles together a property request header and a data payload |
| CPropertyReplyHeader | A struct containing data members that correspond to common fields in a reply to a property exchange request |
| CPropertyReplyData | Bundles together a property reply header and a data payload |
| CPropertyDelegate | An interface with methods that can be overridden to customise how a Device implementing properties responds to property inquiries |
| CRequestID | A strongly-typed identifier for a 7-bit request ID with a nullable state |
| CInitiatorPropertyExchangeCache | Accumulates message chunks that have been sent by another device in response to a transaction initiated by a local device |
| CResponderPropertyExchangeCache | Accumulates message chunks that form a request initiated by a remote device |
| CCacheProvider | An interface for objects that provide resources for property exchange transactions |
| CPropertyExchangeResult | Contains data returned by a responder in response to a request |
| CRequestKey | A key used to uniquely identify ongoing transactions initiated by a ci::Device |
| CPropertyHost | Acting as a ResponderListener, instances of this class can formulate appropriate replies to property transactions initiated by remote devices |
| CResponderDelegate | An interface for types that implement responses for certain message types |
| CBufferOutput | Represents a destination into which MIDI-CI messages can be written |
| CResponderOutput | A buffer output that additionally provides information about an incoming message, so that an appropriate reply can be constructed for that message |
| CSubscription | Matches a subscription ID to a resource name |
| CSubscriptionKey | A key used to uniquely identify ongoing property subscriptions initiated by a ci::Device |
| CSubscriptionManagerDelegate | Functions used by a SubscriptionManager to negotiate subscriptions |
| CSubscriptionManager | Manages subscriptions to properties on remote devices |
| CSupportedAndActive | Holds the maximum number of channels that may be activated for a MIDI-CI profile, along with the number of channels that are currently active |
| CAnalytics | A singleton class to manage analytics data |
| CButtonTracker | A class that automatically sends analytics events to the Analytics singleton when a button is clicked |
| CAnalyticsDestination | An interface for handling analytics events collected by an Analytics object |
| CAnalyticsEvent | Contains information about an event to be logged |
| CThreadedAnalyticsDestination | A base class for dispatching analytics events on a dedicated thread |
| CAnimator | Wrapper class for managing the lifetime of all the different animator kinds created through the builder classes |
| CCompare | Comparison function used by the implementation to store Animators in ordered collections |
| CWeak | |
| CAnimatorSetBuilder | A builder class that can be used to construct an Animator wrapping an AnimatorSet implementation |
| CAnimatorUpdater | Helper class to update several animators at once, without owning or otherwise extending the lifetimes of those animators |
| CSpringEasingOptions | A selection of options available for customising a spring style easing function |
| CEasings | Holds a number of easing functions that you can pass into ValueAnimatorBuilder::withEasing to transform the linear progression of animations |
| CStaticAnimationLimits | Helper class for using linear interpolation between a begin and an end value |
| CValueAnimatorBuilder | A builder class that can be used to construct an Animator wrapping a ValueAnimator implementation |
| CVBlankAnimatorUpdater | Similar to AnimatorUpdater, but automatically calls update() whenever the screen refreshes |
| CAudioPlayHead | A subclass of AudioPlayHead can supply information about the position and status of a moving play head during audio playback |
| CFrameRate | More descriptive frame rate type |
| CTimeSignature | Describes a musical time signature |
| CLoopPoints | Holds the begin and end points of a looped region |
| CCurrentPositionInfo | This type is deprecated; prefer PositionInfo instead |
| CPositionInfo | Describes the time at the start of the current audio callback |
| CAudioChannelSet | Represents a set of audio channel types |
| CAudioData | This class a container which holds all the classes pertaining to the AudioData::Pointer audio sample format class |
| CPointer | Used as a template parameter for AudioData::Pointer |
| CConverter | A base class for objects that are used to convert between two different sample formats |
| CConverterInstance | A class that converts between two templated AudioData::Pointer types, and which implements the AudioData::Converter interface |
| CFormat | A struct that contains a SampleFormat and Endianness to be used with the source and destination types when calling the interleaveSamples() and deinterleaveSamples() helpers |
| CAudioProcessLoadMeasurer | Maintains an ongoing measurement of the proportion of time which is being spent inside an audio callback |
| CScopedTimer | This class measures the time between its construction and destruction and adds it to an AudioProcessLoadMeasurer |
| CAudioBuffer | A multi-channel buffer containing floating point audio samples |
| CFloatVectorOperationsBase | A collection of simple vector operations on arrays of floating point numbers, accelerated with SIMD instructions where possible, usually accessed from the FloatVectorOperations class |
| CFloatVectorOperations | A collection of simple vector operations on arrays of floating point numbers, accelerated with SIMD instructions where possible and providing all methods from FloatVectorOperationsBase |
| CScopedNoDenormals | Helper class providing an RAII-based mechanism for temporarily disabling denormals on your CPU |
| CMidiMessageMetadata | A view of MIDI message data stored in a contiguous buffer |
| CMidiBufferIterator | An iterator to move over contiguous raw MIDI data, which Allows iterating over a MidiBuffer using C++11 range-for syntax |
| CMidiBuffer | Holds a sequence of time-stamped midi events |
| CBytestreamSysexExtractor | |
| CMidiDataConcatenator | Helper class that takes chunks of incoming midi bytes, packages them into messages, and dispatches them to a midi callback |
| CMidiFile | Reads/writes standard midi format files |
| CMidiKeyboardState | Represents a piano keyboard, keeping track of which keys are currently pressed |
| CListener | Receives events from a MidiKeyboardState object |
| CMidiMessage | Encapsulates a MIDI message |
| CVariableLengthValue | Holds information about a variable-length value which was parsed from a stream of bytes |
| CMidiMessageSequence | A sequence of timestamped midi messages |
| CMidiEventHolder | Structure used to hold midi events in the sequence |
| CMidiRPNMessage | Represents a MIDI RPN (registered parameter number) or NRPN (non-registered parameter number) message |
| CMidiRPNDetector | Parses a stream of MIDI data to assemble RPN and NRPN messages from their constituent MIDI CC messages |
| CMidiRPNGenerator | Generates an appropriate sequence of MIDI CC messages to represent an RPN or NRPN message |
| CMPEInstrument | This class represents an instrument handling MPE |
| CListener | Derive from this class to be informed about any changes in the MPE notes played by this instrument, and any changes to its zone layout |
| CMPEMessages | This helper class contains the necessary helper functions to generate MIDI messages that are exclusive to MPE, such as defining the upper and lower MPE zones and setting per-note and master pitchbend ranges |
| CMPENote | This struct represents a playing MPE note |
| CMPESynthesiser | Base class for an MPE-compatible musical device that can play sounds |
| CMPESynthesiserBase | Derive from this class to create a basic audio generator capable of MPE |
| CMPESynthesiserVoice | Represents an MPE voice that an MPESynthesiser can use to play a sound |
| CMPEChannelAssigner | This class handles the assignment of new MIDI notes to member channels of an active MPE zone |
| CMPEChannelRemapper | This class handles the logic for remapping MIDI note messages from multiple MPE sources onto a specified MPE zone |
| CMPEValue | This class represents a single value for any of the MPE dimensions of control |
| CMPEZone | This struct represents an MPE zone |
| CMPEZoneLayout | This class represents the current MPE zone layout of a device capable of handling MPE |
| CListener | Listener class |
| CAudioSourceChannelInfo | Used by AudioSource::getNextAudioBlock() |
| CAudioSource | Base class for objects that can produce a continuous stream of audio |
| CBufferingAudioSource | An AudioSource which takes another source as input, and buffers it using a thread |
| CChannelRemappingAudioSource | An AudioSource that takes the audio from another source, and re-maps its input and output channels to a different arrangement |
| CIIRFilterAudioSource | An AudioSource that performs an IIR filter on another source |
| CMemoryAudioSource | An AudioSource which takes some float audio data as an input |
| CMixerAudioSource | An AudioSource that mixes together the output of a set of other AudioSources |
| CPositionableAudioSource | A type of AudioSource which can be repositioned |
| CResamplingAudioSource | A type of AudioSource that takes an input source and changes its sample rate |
| CReverbAudioSource | An AudioSource that uses the Reverb class to apply a reverb to another AudioSource |
| CToneGeneratorAudioSource | A simple AudioSource that generates a sine wave |
| CSynthesiserSound | Describes one of the sounds that a Synthesiser can play |
| CSynthesiserVoice | Represents a voice that a Synthesiser can use to play a SynthesiserSound |
| CSynthesiser | Base class for a musical device that can play sounds |
| CADSR | A very simple ADSR envelope class |
| CParameters | Holds the parameters being used by an ADSR object |
| CWorkgroupToken | Created by AudioWorkgroup to join the calling thread to a workgroup |
| CAudioWorkgroup | A handle to an audio workgroup, which is a collection of realtime threads working together to produce audio by a common deadline |
| CDecibels | This class contains some helpful static methods for dealing with decibel values |
| CGenericInterpolator | An interpolator base class for resampling streams of floats |
| CIIRCoefficients | A set of coefficients for use in an IIRFilter object |
| CIIRFilterBase | An IIR filter that can perform low, high, or band-pass filtering on an audio signal |
| CIIRFilter | An IIR filter that can perform low, high, or band-pass filtering on an audio signal, and which attempts to implement basic thread-safety |
| CSingleThreadedIIRFilter | An IIR filter that can perform low, high, or band-pass filtering on an audio signal, with no thread-safety guarantees |
| CInterpolators | A collection of different interpolators for resampling streams of floats |
| CReverb | Performs a simple reverb effect on a stream of audio data |
| CParameters | Holds the parameters being used by a Reverb object |
| CSmoothedValueBase | A base class for the smoothed value classes |
| CSmoothedValue | A utility class for values that need smoothing to avoid audio glitches |
| CAudioDeviceManager | Manages the state of some audio and midi i/o devices |
| CAudioDeviceSetup | This structure holds a set of properties describing the current audio setup |
| CLevelMeter | A simple reference-counted struct that holds a level-meter value that can be read using getCurrentLevel() |
| CAudioIODeviceCallbackContext | Additional information that may be passed to the AudioIODeviceCallback |
| CAudioIODeviceCallback | One of these is passed to an AudioIODevice object to stream the audio data in and out |
| CAudioIODevice | Base class for an audio device with synchronised input and output channels |
| CAudioIODeviceType | Represents a type of audio driver, such as DirectSound, ASIO, CoreAudio, etc |
| CListener | A class for receiving events when audio devices are inserted or removed |
| CSystemAudioVolume | Contains functions to control the system's master volume |
| CMidiDeviceListConnection | To find out when the available MIDI devices change, call MidiDeviceListConnection::make(), passing a lambda that will be called on each configuration change |
| CMidiDeviceInfo | This struct contains information about a MIDI 1.0 input or output port |
| CMidiInput | Represents a midi input device using the old bytestream format |
| CMidiInputCallback | Receives incoming messages from a physical MIDI input device |
| CMidiOutput | Represents a midi output device using the old bytestream format |
| CMidiMessageCollector | Collects incoming realtime MIDI messages and turns them into blocks suitable for processing by a block-based audio callback |
| CScheduledEventThread | |
| CWaitFreeListeners | |
| CAudioSourcePlayer | Wrapper class to continuously stream audio from an audio source to an AudioIODevice |
| CAudioTransportSource | An AudioSource that takes a PositionableAudioSource and allows it to be played, stopped, started, etc |
| CAiffAudioFormat | Reads and Writes AIFF format audio files |
| CCoreAudioFormat | OSX and iOS only - This uses the AudioToolbox framework to read any audio format that the system has a codec for |
| CFlacAudioFormat | Reads and writes the lossless-compression FLAC audio format |
| CLAMEEncoderAudioFormat | An AudioFormat class which can use an installed version of the LAME mp3 encoder to encode a file |
| CMP3AudioFormat | Software-based MP3 decoding format (doesn't currently provide an encoder) |
| COggVorbisAudioFormat | Reads and writes the Ogg-Vorbis audio format |
| CWavAudioFormat | Reads and Writes WAV format audio files |
| CWindowsMediaAudioFormat | Audio format which uses the Windows Media codecs (Windows only) |
| CARAAudioSourceReader | Subclass of AudioFormatReader that reads samples from a single ARA audio source |
| CARAPlaybackRegionReader | Subclass of AudioFormatReader that reads samples from a group of playback regions |
| CAudioFormat | Subclasses of AudioFormat are used to read and write different audio file formats |
| CAudioFormatManager | A class for keeping a list of available audio formats, and for deciding which one to use to open a given file |
| CAudioFormatReader | Reads samples from an audio file stream |
| CReadHelper | Used by AudioFormatReader subclasses to copy data to different formats |
| CAudioFormatReaderSource | A type of AudioSource that will read from an AudioFormatReader |
| CAudioFormatWriter | Writes samples to an audio file stream |
| CThreadedWriter | Provides a FIFO for an AudioFormatWriter, allowing you to push incoming data into a buffer which will be flushed to disk by a background thread |
| CIncomingDataReceiver | Receiver for incoming data |
| CWriteHelper | Used by AudioFormatWriter subclasses to copy data to different formats |
| CAudioFormatWriterOptions | Options that affect the output data format produced by an AudioFormatWriter |
| CAudioSubsectionReader | This class is used to wrap an AudioFormatReader and only read from a subsection of the file |
| CBufferingAudioReader | An AudioFormatReader that uses a background thread to pre-read data from another reader |
| CMemoryMappedAudioFormatReader | A specialised type of AudioFormatReader that uses a MemoryMappedFile to read directly from an audio file |
| CSamplerSound | A subclass of SynthesiserSound that represents a sampled audio clip |
| CSamplerVoice | A subclass of SynthesiserVoice that can play a SamplerSound |
| CStandalonePluginHolder | An object that creates and plays a standalone instance of an AudioProcessor |
| CPluginInOuts | Structure used for the number of inputs and outputs |
| CStandaloneFilterWindow | A class that can be used to run a simple standalone application containing your filter |
| CAudioUnitPluginFormat | Implements a plugin format manager for AudioUnits |
| CLADSPAPluginFormat | Provided for backwards compatibility; LADSPA plugins are always headless |
| CLV2PluginFormat | Implements a plugin format for LV2 plugins |
| CVSTPluginFormat | Implements a plugin format manager for VSTs |
| CAudioProcessorEditor | Base class for the component that acts as the GUI for an AudioProcessor |
| CParameterControlHighlightInfo | Used by the setParameterHighlighting() method |
| CHostProvidedContextMenu | This wraps a context menu for a specific parameter, as provided by the host |
| CAudioProcessorEditorHostContext | Calling AudioProcessorEditor::getHostContext() may return a pointer to an instance of this class |
| CGenericAudioProcessorEditor | A type of UI component that displays the parameters of an AudioProcessor as a simple list of sliders, combo boxes and switches |
| CKnownPluginList | Manages a list of plugin types |
| CPluginTree | A structure that recursively holds a tree of plugins |
| CCustomScanner | Class to define a custom plugin scanner |
| CPluginDirectoryScanner | Scans a directory for plugins, and adds them to a KnownPluginList |
| CPluginListComponent | A component displaying a list of plugins, with options to scan for them, add, remove and sort them |
| CAudioProcessorValueTreeStateParameterAttributes | Advanced properties of an AudioProcessorValueTreeState::Parameter |
| CAudioProcessorValueTreeState | This class contains a ValueTree that is used to manage an AudioProcessor's entire state |
| CParameterLayout | A class to contain a set of RangedAudioParameters and AudioProcessorParameterGroups containing RangedAudioParameters |
| CListener | A listener class that can be attached to an AudioProcessorValueTreeState |
| CParameter | A parameter class that maintains backwards compatibility with deprecated AudioProcessorValueTreeState functionality |
| CSliderAttachment | An object of this class maintains a connection between a Slider and a parameter in an AudioProcessorValueTreeState |
| CComboBoxAttachment | An object of this class maintains a connection between a ComboBox and a parameter in an AudioProcessorValueTreeState |
| CButtonAttachment | An object of this class maintains a connection between a Button and a parameter in an AudioProcessorValueTreeState |
| CNSViewComponentWithParent | |
| CParameterAttachment | Used to implement 'attachments' or 'controllers' that link a plug-in parameter to a UI element |
| CSliderParameterAttachment | An object of this class maintains a connection between a Slider and a plug-in parameter |
| CComboBoxParameterAttachment | An object of this class maintains a connection between a ComboBox and a plug-in parameter |
| CButtonParameterAttachment | An object of this class maintains a connection between a Button and a plug-in parameter |
| CWebSliderParameterAttachment | An object of this class maintains a connection between a WebSliderRelay and a plug-in parameter |
| CWebToggleButtonParameterAttachment | An object of this class maintains a connection between a WebToggleButtonRelay and a plug-in parameter |
| CWebComboBoxParameterAttachment | An object of this class maintains a connection between a WebComboBoxRelay and a plug-in parameter |
| CPluginHostType | A useful utility class to determine the host or DAW in which your plugin is loaded |
| CAudioPluginFormat | The base class for a type of plugin format, such as VST, AudioUnit, LADSPA, etc |
| CAudioPluginFormatManager | This maintains a list of known AudioPluginFormats |
| CARAFactoryWrapper | Encapsulates an ARAFactory pointer and makes sure that it remains in a valid state for the lifetime of the ARAFactoryWrapper object |
| CARAFactoryResult | Represents the result of AudioPluginFormatManager::createARAFactoryAsync() |
| CARAEditGuard | Reference counting helper class to ensure that the DocumentController is in editable state |
| CARAHostDocumentController | Wrapper class for ARA::Host::DocumentController |
| CAudioUnitPluginFormatHeadless | Implements a plugin format manager for AudioUnits |
| CLADSPAPluginFormatHeadless | Implements a plugin format manager for LADSPA plugins |
| CLegacyAudioParameter | |
| CLegacyAudioParametersWrapper | |
| CLV2PluginFormatHeadless | Implements a plugin format for LV2 plugins |
| CVST3PluginFormatHeadless | Implements a plugin format for VST3s |
| CSpeakerMappings | Structure for VST speaker mappings |
| CMapping | Structure describing a mapping |
| CVstSpeakerConfigurationHolder | Class to hold a speaker configuration |
| CVSTMidiEventList | Holds a set of VSTMidiEvent objects and makes it easy to add events to the list |
| CVSTPluginFormatHeadless | Implements a plugin format manager for VSTs |
| CExtraFunctions | Base class for some extra functions that can be attached to a VST plugin instance |
| CAudioPluginInstance | Base class for an active instance of a plugin |
| CParameter | Structure used to describe plugin parameters |
| CAudioProcessor | Base class for audio processing classes or plugins |
| CBusesLayout | Represents the bus layout state of a plug-in |
| CBus | Describes the layout and properties of an audio bus |
| CCurveData | Some plug-ins support sharing response curve data with the host so that it can display this curve on a console or in the mixer panel |
| CTrackProperties | A struct containing information about the DAW track inside which your AudioProcessor is loaded |
| CBusProperties | Structure used for AudioProcessor Callbacks |
| CBusesProperties | Structure used for AudioProcessor Callbacks |
| CParameterChangeForwarder | |
| CAudioProcessorGraph | A type of AudioProcessor which plays back a graph of other AudioProcessors |
| CNodeID | Each node in the graph has a UID of this type |
| CNodeAndChannel | Represents an input or output channel of a node in an AudioProcessorGraph |
| CNode | Represents one of the nodes, or processors, in an AudioProcessorGraph |
| CConnection | Represents a connection between two channels of two nodes in an AudioProcessorGraph |
| CAudioGraphIOProcessor | A special type of AudioProcessor that can live inside an AudioProcessorGraph in order to use the audio that comes into and out of the graph itself |
| CAudioProcessorListener | Base class for listeners that want to know about changes to an AudioProcessor |
| CChangeDetails | Provides details about aspects of an AudioProcessor which have changed |
| CAudioProcessorParameter | An abstract base class for parameter objects that can be added to an AudioProcessor |
| CListener | A base class for listeners that want to know about changes to an AudioProcessorParameter |
| CAudioProcessorParameterGroup | A class encapsulating a group of AudioProcessorParameters and nested AudioProcessorParameterGroups |
| CAudioProcessorParameterNode | A child of an AudioProcessorParameterGroup |
| CHostedAudioProcessorParameter | A parameter with functions that are useful for plugin hosts |
| CPluginDescription | A small class to represent some facts about a particular type of plug-in |
| CARADocumentControllerSpecialisation | This class contains the customisation points for the JUCE provided ARA document controller implementation |
| CARAInputStream | Used to read persisted ARA archives - see doRestoreObjectsFromStream() for details |
| CARAOutputStream | Used to write persistent ARA archives - see doStoreObjectsToStream() for details |
| CARADocumentController | |
| CARAListenableModelClass | Base class used by the JUCE ARA model objects to provide listenable interfaces |
| CARAObjectVisitor | Create a derived implementation of this class and pass it to ARAObject::visit() to retrieve the concrete type of a model object |
| CARAObject | Common base class for all JUCE ARA model objects to aid with the discovery and traversal of the entire ARA model graph |
| CARADocumentListener | A base class for listeners that want to know about changes to an ARADocument object |
| CARADocument | Base class representing an ARA document |
| CARAMusicalContextListener | A base class for listeners that want to know about changes to an ARAMusicalContext object |
| CARAMusicalContext | Base class representing an ARA musical context |
| CARAPlaybackRegionListener | A base class for listeners that want to know about changes to an ARAPlaybackRegion object |
| CARAPlaybackRegion | Base class representing an ARA playback region |
| CARARegionSequenceListener | A base class for listeners that want to know about changes to an ARARegionSequence object |
| CARARegionSequence | Base class representing an ARA region sequence |
| CARAAudioSourceListener | A base class for listeners that want to know about changes to an ARAAudioSource object |
| CARAAudioSource | Base class representing an ARA audio source |
| CARAAudioModificationListener | A base class for listeners that want to know about changes to an ARAAudioModification object |
| CARAAudioModification | Base class representing an ARA audio modification |
| CARARenderer | Base class for a renderer fulfilling either the ARAPlaybackRenderer or the ARAEditorRenderer role |
| CARAPlaybackRenderer | Base class for a renderer fulfilling the ARAPlaybackRenderer role as described in the ARA SDK |
| CARAEditorRenderer | Base class for a renderer fulfilling the ARAEditorRenderer role as described in the ARA SDK |
| CARAEditorView | Base class for fulfilling the ARAEditorView role as described in the ARA SDK |
| CListener | A base class for listeners that want to know about changes to an ARAEditorView object |
| CAudioProcessorARAExtension | Extension class meant to be subclassed by the plugin's implementation of |
| CAudioProcessorEditorARAExtension | Extension class meant to be subclassed by the plugin's implementation of |
| CAAXClientExtensions | An interface to allow an AudioProcessor to implement extended AAX-specific functionality |
| CAudioParameterBoolAttributes | Properties of an AudioParameterBool |
| CAudioParameterBool | Provides a class of AudioProcessorParameter that can be used as a boolean value |
| CAudioParameterChoiceAttributes | Properties of an AudioParameterChoice |
| CAudioParameterChoice | Provides a class of AudioProcessorParameter that can be used to select an indexed, named choice from a list |
| CAudioParameterFloatAttributes | Properties of an AudioParameterFloat |
| CAudioParameterFloat | A subclass of AudioProcessorParameter that provides an easy way to create a parameter which maps onto a given NormalisableRange |
| CAudioParameterIntAttributes | Properties of an AudioParameterInt |
| CAudioParameterInt | Provides a class of AudioProcessorParameter that can be used as an integer value with a given range |
| CParameterID | Combines a parameter ID and a version hint |
| CAudioProcessorParameterWithIDAttributes | An instance of this class may be passed to the constructor of an AudioProcessorParameterWithID to set optional characteristics of that parameter |
| CAudioProcessorParameterWithID | This abstract base class is used by some AudioProcessorParameter helper classes |
| CExtensionsVisitor | Create a derived implementation of this class and pass it to AudioPluginInstance::getExtensions() to retrieve format-specific information about a plugin instance |
| CUnknown | Indicates that there is no platform specific information available |
| CVST3Client | Can be used to retrieve information about a VST3 that is wrapped by an AudioProcessor |
| CAudioUnitClient | Can be used to retrieve information about an AudioUnit that is wrapped by an AudioProcessor |
| CVSTClient | Can be used to retrieve information about a VST that is wrapped by an AudioProcessor |
| CARAClient | Can be used to retrieve information about a plugin that provides ARA extensions |
| CRangedAudioParameterAttributes | |
| CRangedAudioParameter | This abstract base class is used by some AudioProcessorParameter helper classes |
| CVST2ClientExtensions | An interface to allow an AudioProcessor to implement extended VST2-specific functionality |
| CVST3ClientExtensions | An interface to allow an AudioProcessor to implement extended VST3-specific functionality |
| CVST3Interface | Useful functions and classes for defining VST3 Interface Ids |
| CAudioCDBurner | |
| CBurnProgressListener | Receives progress callbacks during a cd-burn operation |
| CAudioCDReader | A type of AudioFormatReader that reads from an audio CD |
| CAudioAppComponent | A base class for writing audio apps that stream from the audio i/o devices |
| CAudioDeviceSelectorComponent | A component containing controls to let the user change the audio settings of an AudioDeviceManager object |
| CAudioThumbnail | Makes it easy to quickly draw scaled views of the waveform shape of an audio file |
| CAudioThumbnailBase | Provides a base for classes that can store and draw scaled views of an audio waveform |
| CAudioThumbnailCache | An instance of this class is used to manage multiple AudioThumbnail objects |
| CAudioVisualiserComponent | A simple component that can be used to show a scrolling waveform of audio data |
| CBluetoothMidiDevicePairingDialogue | Opens a Bluetooth MIDI pairing dialogue that allows the user to view and connect to Bluetooth MIDI devices that are currently found nearby |
| CKeyboardComponentBase | A base class for drawing a custom MIDI keyboard component |
| CNoteAndVelocity | This structure is returned by the getNoteAndVelocityAtPosition() method |
| CMidiKeyboardComponent | A component that displays a piano keyboard, whose notes can be clicked on |
| CMPEKeyboardComponent | A component that displays an MPE-compatible keyboard, whose notes can be clicked on |
| CAudioProcessorPlayer | An AudioIODeviceCallback object which streams audio through an AudioProcessor |
| CSoundPlayer | A simple sound player that you can add to the AudioDeviceManager to play simple sounds |
| CBox2DRenderer | A simple implementation of the b2Draw class, used to draw a Box2D world |
| CAbstractFifo | Encapsulates the logic required to implement a lock-free FIFO |
| CScopedReadWrite | Class for a scoped reader/writer |
| CArray | Holds a resizable array of primitive or copy-by-value objects |
| CArrayAllocationBase | Implements some basic array storage allocation functions |
| CArrayBase | A basic object container |
| CDynamicObject | Represents a dynamically implemented object |
| CDefaultElementComparator | A simple ElementComparator class that can be used to sort an array of objects that support the '<' operator |
| CEnumerated | Returned when dereferencing an EnumerateIterator |
| CEnumerateIterator | An iterator that wraps some other iterator, keeping track of the relative position of that iterator based on calls to arithmetic operators such as operator++(), operator--(), operator+(), and operator-() |
| CIteratorPair | Wraps a pair of iterators, providing member begin() and end() functions that return those iterators |
| CFixedSizeFunction< len, Ret(Args...)> | A type similar to std::function that holds a callable object |
| CDefaultHashFunctions | A simple class to generate hash functions for some primitive types, intended for use with the HashMap class |
| CHashMap | Holds a set of mappings between some key/value pairs |
| CIterator | Iterates over the items in a HashMap |
| CLinkedListPointer | Helps to manipulate singly-linked lists of objects |
| CAppender | Allows efficient repeated insertions into a list |
| CListenerList | Holds a set of objects and can invoke a member function callback on each object in the set with a single call |
| CDummyBailOutChecker | A dummy bail-out checker that always returns false |
| CLightweightListenerList | A lightweight version of the ListenerList that doesn't provide any guarantees when mutating the list from a callback, but allows callbacks to be triggered concurrently without a mutex |
| CNamedValueSet | Holds a set of named var objects |
| CNamedValue | Structure for a named var object |
| COptional | A simple optional type |
| COwnedArray | An array designed for holding objects |
| CPropertySet | A set of named property values, which can be strings, integers, floating point, etc |
| CReferenceCountedArray | Holds a list of objects derived from ReferenceCountedObject, or which implement basic reference-count handling methods |
| CScopedValueSetter | Helper class providing an RAII-based mechanism for temporarily setting and then re-setting a value |
| CSingleThreadedAbstractFifo | Encapsulates the logic for a single-threaded FIFO |
| CSortedSet | Holds a set of unique primitive objects, such as ints or doubles |
| CSpan | A non-owning view over contiguous objects stored in an Array or vector or other similar container |
| CSparseSet | Holds a set of primitive values, storing them as a set of ranges |
| Cvar | A variant class, that can be used to hold a range of primitive values |
| CNativeFunctionArgs | This structure is passed to a NativeFunction callback, and contains invocation details about the function's arguments and context |
| CAndroidDocumentInfo | Some information about a document |
| CAndroidDocumentPermission | Represents a permission granted to an application to read and/or write to a particular document or tree |
| CAndroidDocument | Provides access to a document on Android devices |
| CAndroidDocumentIterator | An iterator that visits child documents in a directory |
| CFile | Represents a local file or directory |
| CNaturalFileComparator | Comparator for files |
| CFileFilter | Interface for deciding which files are suitable for something |
| CFileInputStream | An input stream that reads from a local file |
| CFileOutputStream | An output stream that writes into a local file |
| CFileSearchPath | Represents a set of folders that make up a search path |
| CMemoryMappedFile | Maps a file into virtual memory for easy reading and/or writing |
| CDirectoryEntry | Describes the attributes of a file or folder |
| CRangedDirectoryIterator | Allows iterating over files and folders using C++11 range-for syntax |
| CTemporaryFile | Manages a temporary file, which will be deleted when this object is deleted |
| CWildcardFileFilter | A type of FileFilter that works by wildcard pattern matching |
| CJSON | Contains static methods for converting JSON-formatted text to and from var objects |
| CFormatOptions | Allows formatting var objects as JSON with various configurable options |
| CToVarOptions | Options that control conversion from arbitrary types to juce::var |
| CToVar | Allows converting an object of arbitrary type to var |
| CFromVar | Allows converting a var to an object of arbitrary type |
| CVariantConverter | This template-overloaded class can be used to convert between var and custom types |
| CStrictVariantConverter | A helper type that can be used to implement specialisations of VariantConverter that use FromVar::convert and ToVar::convert internally |
| CJSONUtils | A mini namespace to hold utility functions for working with juce::vars |
| CFileLogger | A simple implementation of a Logger that writes to a file |
| CLogger | Acts as an application-wide logging class |
| CBigInteger | An arbitrarily large integer class |
| CExpression | A class for dynamically evaluating simple numeric expressions |
| CScope | When evaluating an Expression object, this class is used to resolve symbols and perform functions that the expression uses |
| CVisitor | Used as a callback by the Scope::visitRelativeScope() method |
| CSymbol | Represents a symbol that is used in an Expression |
| CMathConstants | Commonly used mathematical constants |
| CTolerance | A class encapsulating both relative and absolute tolerances for use in floating-point comparisons |
| CNormalisableRange | Represents a mapping between an arbitrary range of values and a normalised 0->1 range |
| CRandom | A random number generator |
| CRange | A general-purpose range object, that simply represents any linear range with a start and end point |
| CStatisticsAccumulator | A class that measures various statistics about a series of floating point values that it is given |
| CAtomic | A simple wrapper around std::atomic |
| CByteOrder | Contains static methods for converting the byte order between different endiannesses |
| CContainerDeletePolicy | Used by container classes as an indirect way to delete an object of a particular type |
| CCopyableHeapBlock | Wraps a HeapBlock, but additionally provides a copy constructor and remembers its size |
| CHeapBlock | Very simple container class to hold a pointer to some data on the heap |
| CHeavyweightLeakedObjectDetector | This class is a useful way of tracking down hard to find memory leaks when the regular LeakedObjectDetector isn't enough |
| CLeakedObjectDetector | Embedding an instance of this class inside another class can be used as a low-overhead way of detecting leaked instances |
| CScopedAutoReleasePool | A handy C++ wrapper that creates and deletes an NSAutoreleasePool object using RAII |
| CMemoryBlock | A class to hold a resizable block of raw data |
| COptionalScopedPointer | Holds a pointer to an object which can optionally be deleted when this pointer goes out of scope |
| CReferenceCountedObject | A base class which provides methods for reference-counting |
| CSingleThreadedReferenceCountedObject | Adds reference-counting to an object |
| CReferenceCountedObjectPtr | A smart-pointer class which points to a reference-counted object |
| CReservoir | Helper functions for managing buffered readers |
| CSharedResourcePointer | A smart-pointer that automatically creates and manages the lifetime of a shared static instance of a class |
| CSingletonHolder | Used by the JUCE_DECLARE_SINGLETON macros to manage a static pointer to a singleton instance |
| CWeakReference | This class acts as a pointer which will automatically become null if the object to which it points is deleted |
| CSharedPointer | This class is used internally by the WeakReference class - don't use it directly in your code! |
| CMaster | This class is embedded inside an object to which you want to attach WeakReference pointers |
| CArgumentList | Holds a list of command-line arguments, and provides useful methods for searching and operating on them |
| CArgument | One of the arguments in an ArgumentList |
| CConsoleApplication | Represents a the set of commands that a console app can perform, and provides helper functions for performing them |
| CCommand | Represents a command that can be executed if its command-line arguments are matched |
| CNullCheckedInvocation | Some helper methods for checking a callable object before invoking with the specified arguments |
| COptionsBuilder | A base class for building Options |
| COrderedContainerHelpers | A helper struct providing functions for managing sorted containers |
| CResult | Represents the 'success' or 'failure' of an operation, and holds an associated error message to describe the error when there's a failure |
| CRuntimePermissions | |
| CScopeGuard | An easy way to ensure that a function is called at the end of the current scope |
| CErasedScopeGuard | A ScopeGuard that uses a std::function internally to allow type erasure |
| CUuid | A universally unique 128-bit identifier |
| CWindowsRegistry | Contains some static helper functions for manipulating the MS Windows registry (Only available on Windows, of course!) |
| CIPAddress | Represents an IP address |
| CMACAddress | Represents a MAC network card adapter address ID |
| CNamedPipe | A cross-process pipe that can have data written to and read from it |
| CSocketOptions | Options used for the configuration of the underlying system socket in the StreamingSocket and DatagramSocket classes |
| CStreamingSocket | A wrapper for a streaming (TCP) socket |
| CDatagramSocket | A wrapper for a datagram (UDP) socket |
| CURL | Represents a URL and has a bunch of useful functions to manipulate it |
| CInputStreamOptions | Class used to create a set of options to pass to the createInputStream() method |
| CDownloadTaskListener | Used to receive callbacks for download progress |
| CDownloadTaskOptions | Holds options that can be specified when starting a new download with downloadToFile() |
| CDownloadTask | Represents a download task |
| CWebInputStream | An InputStream which can be used to read from a given URL |
| CListener | Used to receive callbacks for POST data send progress |
| CSerialisationTraits | Allows serialisation functions to be attached to a specific type without having to modify the declaration of that type |
| CNamed | Combines an object with a name |
| CSerialisationSize | Holds a reference to some kind of size value, used to indicate that an object being marshalled is of variable size (e.g |
| CAndroidDocumentInputSource | An InputSource backed by an AndroidDocument |
| CBufferedInputStream | Wraps another input stream, and reads from it using an intermediate buffer |
| CFileInputSource | A type of InputSource that represents a normal file |
| CInputSource | A lightweight object that can create a stream to read some kind of resource |
| CInputStream | The base class for streams that read data |
| CMemoryInputStream | Allows a block of data to be accessed as a stream |
| CMemoryOutputStream | Writes data to an internal memory buffer, which grows as required |
| COutputStream | The base class for streams that write data to some kind of destination |
| CSubregionStream | Wraps another input stream, and reads from a specific part of it |
| CURLInputSource | A type of InputSource that represents a URL |
| CSystemStats | Contains methods for finding out about the current hardware and OS configuration |
| CBase64 | Contains some static methods for converting between binary and the standard base-64 encoding format |
| CCharacterFunctions | A collection of functions for manipulating characters and character strings |
| CHexParser | Parses a character string, to read a hexadecimal value |
| CCharPointer_ASCII | Wraps a pointer to a null-terminated ASCII character string, and provides various methods to operate on the data |
| CCharPointer_UTF16 | Wraps a pointer to a null-terminated UTF-16 character string, and provides various methods to operate on the data |
| CCharPointer_UTF32 | Wraps a pointer to a null-terminated UTF-32 character string, and provides various methods to operate on the data |
| CCharPointer_UTF8 | Wraps a pointer to a null-terminated UTF-8 character string, and provides various methods to operate on the data |
| CIdentifier | Represents a string identifier, designed for accessing properties by name |
| CLocalisedStrings | Used to convert strings to localised foreign-language versions |
| CNewLine | This class is used for represent a new-line character sequence |
| CString | The JUCE String class! |
| CStringArray | A special array for holding a list of strings |
| CStringPairArray | A container for holding a set of strings which are keyed by another string |
| CStringPool | A StringPool holds a set of shared strings, which reduces storage overheads and improves comparison speed when dealing with many duplicate strings |
| CStringRef | A simple class for holding temporary references to a string literal or String |
| CTextDiff | Calculates and applies a sequence of changes to convert one text string into another |
| CChange | Describes a change, which can be either an insertion or deletion |
| CChildProcess | Launches and monitors a child process |
| CCriticalSection | A re-entrant mutex |
| CDummyCriticalSection | A class that can be used in place of a real CriticalSection object, but which doesn't perform any locking |
| CScopedLockType | A dummy scoped-lock type to use with a dummy critical section |
| CDynamicLibrary | Handles the opening and closing of DLLs |
| CHighResolutionTimer | A high-resolution periodic timer |
| CInterProcessLock | Acts as a critical section which processes can use to block each other |
| CScopedLockType | Automatically locks and unlocks an InterProcessLock object |
| CProcess | Represents the current executable's process |
| CReadWriteLock | A critical section that allows multiple simultaneous readers |
| CGenericScopedLock | Automatically locks and unlocks a mutex object |
| CGenericScopedUnlock | Automatically unlocks and re-locks a mutex object |
| CGenericScopedTryLock | Automatically locks and unlocks a mutex object |
| CScopedReadLock | Automatically locks and unlocks a ReadWriteLock object |
| CScopedTryReadLock | Automatically locks and unlocks a ReadWriteLock object |
| CScopedWriteLock | Automatically locks and unlocks a ReadWriteLock object |
| CScopedTryWriteLock | Automatically locks and unlocks a ReadWriteLock object |
| CSpinLock | A simple spin-lock class that can be used as a simple, low-overhead mutex for uncontended situations |
| CThread | Encapsulates a thread |
| CRealtimeOptions | A selection of options available when creating realtime threads |
| CListener | Used to receive callbacks for thread exit calls |
| CThreadLocalValue | Provides cross-platform support for thread-local objects |
| CThreadPoolJob | A task that is executed by a ThreadPool object |
| CThreadPoolOptions | A set of threads that will run a list of jobs |
| CThreadPool | A set of threads that will run a list of jobs |
| CJobSelector | A callback class used when you need to select which ThreadPoolJob objects are suitable for some kind of operation |
| CTimeSliceClient | Used by the TimeSliceThread class |
| CTimeSliceThread | A thread that keeps a list of clients, and calls each one in turn, giving them all a chance to run some sort of short task |
| CWaitableEvent | Allows threads to wait for events triggered by other threads |
| CPerformanceCounter | A timer for measuring performance of code and dumping the results to a file |
| CStatistics | Holds the current statistics |
| CScopedTimeMeasurement | Simple RAII class for measuring the time spent in a scope |
| CRelativeTime | A relative measure of time |
| CTime | Holds an absolute date and time |
| CUnitTest | This is a base class for classes that perform a unit test |
| CUnitTestRunner | Runs a set of unit tests |
| CTestResult | Contains the results of a test |
| CXmlDocument | Parses a text-based XML document and creates an XmlElement object from it |
| CXmlAttribute | A name-value pair representing an attribute of an XML tag |
| CXmlElement | Used to build a tree of elements representing an XML document |
| CTextFormat | A struct containing options for formatting the text when representing an XML element as a string |
| CGZIPCompressorOutputStream | A stream which uses zlib to compress the data written into it |
| CGZIPDecompressorInputStream | This stream will decompress a source-stream using zlib |
| CZipFile | Decodes a ZIP file from a stream |
| CZipEntry | Contains information about one of the entries in a ZipFile |
| CBuilder | Used to create a new zip file |
| CBlowFish | BlowFish encryption class |
| CPrimes | Prime number creation class |
| CRSAKey | RSA public/private key-pair encryption class |
| CMD5 | MD5 checksum class |
| CSHA256 | SHA-256 secure hash generator |
| CWhirlpool | Whirlpool hash class |
| CApplicationProperties | Manages a collection of properties |
| CPropertiesFile | Wrapper on a file that stores a list of key/value data pairs |
| COptions | Structure describing properties file options |
| CUndoableAction | Used by the UndoManager class to store an action which can be done and undone |
| CUndoManager | Manages a list of undo/redo commands |
| CCachedValue | This class acts as a typed wrapper around a property inside a ValueTree |
| CValue | Represents a shared variant value |
| CListener | Receives callbacks when a Value object changes |
| CValueSource | Used internally by the Value class as the base class for its shared value objects |
| CValueTree | A powerful tree structure that can be used to hold free-form data, and which can handle its own undo and redo behaviour |
| CIterator | Iterator for a ValueTree |
| CListener | Listener class for events that happen to a ValueTree |
| CValueTreePropertyWithDefault | This class acts as a wrapper around a property inside a ValueTree |
| CValueTreeSynchroniser | This class can be used to watch for all changes to the state of a ValueTree, and to convert them to a transmittable binary encoding |
| CActionBroadcaster | Manages a list of ActionListeners, and can send them messages |
| CActionListener | Interface class for delivery of events that are sent by an ActionBroadcaster |
| CAsyncUpdater | Has a callback method that is triggered asynchronously |
| CChangeBroadcaster | Holds a list of ChangeListeners, and sends messages to them when instructed |
| CChangeListener | Receives change event callbacks that are sent out by a ChangeBroadcaster |
| CLockingAsyncUpdater | A bit like an AsyncUpdater, but guarantees that after cancelPendingUpdate() returns, the async function will never be called until triggerAsyncUpdate() is called again |
| CChildProcessManager | Manages a set of ChildProcesses and periodically checks their return value |
| CChildProcessWorker | Acts as the worker end of a coordinator/worker pair of connected processes |
| CChildProcessCoordinator | Acts as the coordinator in a coordinator/worker pair of connected processes |
| CInterprocessConnection | Manages a simple two-way messaging connection to another process, using either a socket or a named pipe as the transport medium |
| CInterprocessConnectionServer | An object that waits for client sockets to connect to a port on this host, and creates InterprocessConnection objects for each one |
| CNetworkServiceDiscovery | Contains classes that implement a simple protocol for broadcasting the availability and location of a discoverable service on the local network, and for maintaining a list of known services |
| CAdvertiser | An object which runs a thread to repeatedly broadcast the existence of a discoverable service |
| CService | Contains information about a service that has been found on the network |
| CAvailableServiceList | Watches the network for broadcasts from Advertiser objects, and keeps a list of all the currently active instances |
| CJUCEApplicationBase | Abstract base class for application classes |
| CCallbackMessage | A message that invokes a callback method when it gets delivered |
| CDeletedAtShutdown | Classes derived from this will be automatically deleted when the application exits |
| CScopedJuceInitialiser_GUI | A utility object that helps you initialise and shutdown JUCE correctly using an RAII pattern |
| CMessage | The base class for objects that can be sent to a MessageListener |
| CMessageListener | MessageListener subclasses can post and receive Message objects |
| CMessageManager | This class is in charge of the application's event-dispatch loop |
| CMessageBase | Internal class used as the base class for all message objects |
| CLock | A lock you can use to lock the message manager |
| CMessageManagerLock | Used to make sure that the calling thread has exclusive access to the message loop |
| CMountedVolumeListChangeDetector | An instance of this class will provide callbacks when drives are mounted or unmounted on the system |
| CMultiTimer | A type of timer class that can run multiple timers with different frequencies, all of which share a single callback |
| CTimedCallback | Utility class wrapping a single non-null callback called by a Timer |
| CTimer | Makes repeated callbacks to a virtual method at a specified time interval |
| CColour | Represents a colour, also including a transparency value |
| CColourGradient | Describes the layout and colours that should be used to paint a colour gradient |
| CFillType | Represents a colour or fill pattern to use for rendering paths |
| CPixelARGB | Represents a 32-bit INTERNAL pixel with premultiplied alpha, and can perform compositing operations with it |
| CPixelRGB | Represents a 24-bit RGB pixel, and can perform compositing operations on it |
| CPixelAlpha | Represents an 8-bit single-channel pixel, and can perform compositing operations on it |
| CGraphics | A graphics context, used for drawing a component or image |
| CScopedSaveState | Uses RAII to save and restore the state of a graphics context |
| CLowLevelGraphicsContext | Interface class for graphics context objects, used internally by the Graphics class |
| CLowLevelGraphicsSoftwareRenderer | A lowest-common-denominator implementation of LowLevelGraphicsContext that does all its rendering in memory |
| CDropShadow | Defines a drop-shadow effect |
| CDropShadowEffect | An effect filter that adds a drop-shadow behind the image's content |
| CGlowEffect | A component effect that adds a coloured blur around the component's contents |
| CImageEffectFilter | A graphical effect filter that can be applied to components |
| CAttributedString | A text string with a set of colour/font settings that are associated with sub-ranges of the text |
| CAttribute | An attribute that has been applied to a range of characters in an AttributedString |
| CFont | Represents a particular font, including its size, style, etc |
| CFontFeatureTag | Represents a single OpenType font feature |
| CFontFeatureSetting | Represents a single OpenType font feature setting |
| CFontOptions | Options that describe a particular font |
| CPositionedGlyph | A glyph from a particular font, with a particular size, style, typeface and position |
| CGlyphArrangement | A set of glyphs, each with a position |
| CGlyphArrangementOptions | Options that can be used to affect the layout produced by GlyphArrangement::addFittedText |
| CTextLayout | A Pre-formatted piece of text, which may contain multiple fonts and colours |
| CGlyph | A positioned glyph |
| CRun | A sequence of glyphs with a common font and colour |
| CLine | A line containing a sequence of glyph-runs |
| CColourLayer | A single path-based layer of a colour glyph |
| CImageLayer | A bitmap representing (part of) a glyph, most commonly used to represent colour emoji glyphs |
| CGlyphLayer | A single layer that makes up part of a glyph image |
| CTypefaceMetrics | Font metrics using JUCE conventions |
| CTypeface | A typeface represents a size-independent font |
| CAffineTransform | Represents a 2D affine-transformation matrix |
| CBorderSize | Specifies a set of gaps to be left around the sides of a rectangle |
| CEdgeTable | A table of horizontal scan-line segments - used for rasterising Paths |
| CLine | Represents a line |
| CParallelogram | Represents a parallelogram that is defined by 3 points |
| CPath | A path is a sequence of lines and curves that may either form a closed shape or be open-ended |
| CIterator | Iterates the lines and curves that a path contains |
| CPathFlatteningIterator | Flattens a Path object into a series of straight-line sections |
| CPathStrokeType | Describes a type of stroke used to render a solid outline along a path |
| CPoint | A pair of (x, y) coordinates |
| CRectangle | Manages a rectangle and allows geometric operations to be performed on it |
| CRectangleList | Maintains a set of rectangles as a complex region |
| CImage | Holds a fixed-size bitmap |
| CBitmapData | Retrieves a section of an image as raw pixel data, so it can be read or written to |
| CBitmapDataReleaser | Used internally by custom image types to manage pixel data lifetime |
| CImagePixelDataBackupExtensions | The methods on this interface allow clients of ImagePixelData to query and control the automatic-backup process from graphics memory to main memory, if this mechanism is relevant and supported |
| CImagePixelData | This is a base class for holding image data in implementation-specific ways |
| CListener | Used to receive callbacks for image data changes |
| CImageType | This base class is for handlers that control a type of image manipulation format, e.g |
| CSoftwareImageType | An image storage type which holds the pixels in-memory as a simple block of values |
| CNativeImageType | An image storage type which holds the pixels using whatever is the default storage format on the current platform |
| CImageCache | A global cache of images that have been loaded from files or memory |
| CImageConvolutionKernel | Represents a filter kernel to use in convoluting an image |
| CImageFileFormat | Base-class for codecs that can read and write image file formats such as PNG, JPEG, etc |
| CPNGImageFormat | A subclass of ImageFileFormat for reading and writing PNG files |
| CJPEGImageFormat | A subclass of ImageFileFormat for reading and writing JPEG files |
| CGIFImageFormat | A subclass of ImageFileFormat for reading GIF files |
| CImagePixelDataNativeExtensions | |
| CScaledImage | An image that will be resampled before it is drawn |
| CJustification | Represents a type of justification to be used when positioning graphical items |
| CRectanglePlacement | Defines the method used to position some kind of rectangular object within a rectangular viewport |
| CAccessibilityActions | A simple wrapper for building a collection of supported accessibility actions and corresponding callbacks for a UI element |
| CAccessibilityCellInterface | An abstract interface which represents a UI element that supports a cell interface |
| CAccessibilityTableInterface | An abstract interface which represents a UI element that supports a table interface |
| CSpan | A simple span of elements |
| CAccessibilityTextInterface | An abstract interface which represents a UI element that supports a text interface |
| CAccessibilityValueInterface | An abstract interface representing the value of an accessibility element |
| CAccessibleValueRange | Represents the range of this value, if supported |
| CMinAndMax | The minimum and maximum values for this range, inclusive |
| CAccessibilityTextValueInterface | A value interface that represents a text value |
| CAccessibilityNumericValueInterface | A value interface that represents a non-ranged numeric value |
| CAccessibilityRangedNumericValueInterface | A value interface that represents a ranged numeric value |
| CAccessibilityHandler | Base class for accessible Components |
| CInterfaces | Utility struct which holds one or more accessibility interfaces |
| CAccessibleState | Represents the state of an accessible UI element |
| CJUCEApplication | An instance of this class is used to specify initialisation and shutdown code for the application |
| CArrowButton | A button with an arrow in it |
| CButton | A base class for buttons |
| CListener | Used to receive callbacks when a button is clicked |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide button-drawing functionality |
| CDrawableButton | A button that displays a Drawable |
| CHyperlinkButton | A button showing an underlined weblink, that will launch the link when it's clicked |
| CImageButton | As the title suggests, this is a button containing an image |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CShapeButton | A button that contains a filled shape |
| CTextButton | A button that uses the standard lozenge-shaped background with a line of text on it |
| CToggleButton | A button that can be toggled on/off |
| CToolbarButton | A type of button designed to go on a toolbar |
| CApplicationCommandInfo | Holds information describing an application command |
| CApplicationCommandManager | One of these objects holds a list of all the commands your app can perform, and despatches these commands when needed |
| CApplicationCommandManagerListener | A listener that receives callbacks from an ApplicationCommandManager when commands are invoked or the command list is changed |
| CApplicationCommandTarget | A command target publishes a list of command IDs that it can perform |
| CInvocationInfo | Contains contextual details about the invocation of a command |
| CKeyPressMappingSet | Manages and edits a list of keypresses, which it uses to invoke the appropriate command in an ApplicationCommandManager |
| CCachedComponentImage | Base class used internally for structures that can store cached images of component state |
| CComponent | The base class for all JUCE user-interface objects |
| CSafePointer | Holds a pointer to some type of Component, which automatically becomes null if the component is deleted |
| CBailOutChecker | A class to keep an eye on a component and check for it being deleted |
| CPositioner | Base class for objects that can be used to automatically position a component according to some kind of algorithm |
| CComponentListener | Gets informed about changes to a component's hierarchy or position |
| CComponentTraverser | Base class for traversing components |
| CFocusTraverser | Controls the order in which focus moves between components |
| CModalComponentManager | Manages the system's stack of modal components |
| CCallback | Receives callbacks when a modal component is dismissed |
| CKey | |
| CModalCallbackFunction | This class provides some handy utility methods for creating ModalComponentManager::Callback objects that will invoke a static function with some parameters when a modal component is dismissed |
| CFocusChangeListener | Classes can implement this interface and register themselves with the Desktop class to receive callbacks when the currently focused component changes |
| CDarkModeSettingListener | Classes can implement this interface and register themselves with the Desktop class to receive callbacks when the operating system dark mode setting changes |
| CDesktop | Describes and controls aspects of the computer's desktop |
| CDisplays | Manages details about connected display devices |
| CDisplay | Represents a connected display device |
| CDrawable | The base class for objects which can draw themselves, e.g |
| CDrawableComposite | A drawable object which acts as a container for a set of other Drawables |
| CDrawableImage | A drawable object which is a bitmap image |
| CDrawablePath | A drawable object which renders a filled or outlined shape |
| CDrawableRectangle | A Drawable object which draws a rectangle |
| CDrawableShape | A base class implementing common functionality for Drawable classes which consist of some kind of filled and stroked outline |
| CDrawableText | A drawable object which renders a line of text |
| CContentSharer | Functions that allow sharing content between apps and devices |
| CDirectoryContentsDisplayComponent | A base class for components that display a list of the files in a directory |
| CDirectoryContentsList | A class to asynchronously scan for details about the files in a directory |
| CFileInfo | Contains cached information about one of the files in a DirectoryContentsList |
| CFileBrowserComponent | A component for browsing and selecting a file or directory to open or save |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide various file-browser layout and drawing methods |
| CFileBrowserListener | A listener for user selection events in a file browser |
| CFileChooser | Creates a dialog box to choose a file or directory to load or save |
| CFileChooserDialogBox | A file open/save dialog box |
| CFileListComponent | A component that displays the files in a directory as a listbox |
| CFilenameComponentListener | Listens for events happening to a FilenameComponent |
| CFilenameComponent | Shows a filename as an editable text box, with a 'browse' button and a drop-down list for recently selected files |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CFilePreviewComponent | Base class for components that live inside a file chooser dialog box and show previews of the files that get selected |
| CFileSearchPathListComponent | Shows a set of file paths in a list, allowing them to be added, removed or re-ordered |
| CFileTreeComponent | A component that displays the files in a directory as a treeview |
| CImagePreviewComponent | A simple preview component that shows thumbnails of image files |
| CCaretComponent | |
| CKeyboardFocusTraverser | Controls the order in which keyboard focus moves between components |
| CKeyListener | Receives callbacks when keys are pressed |
| CKeyPress | Represents a key press, including any modifier keys that are needed |
| CModifierKeys | Represents the state of the mouse buttons and modifier keys |
| CSystemClipboard | Handles reading/writing to the system's clipboard |
| CTextEditorKeyMapper | This class is used to invoke a range of text-editor navigation methods on an object, based upon a keypress event |
| CTextInputTarget | An abstract base class which can be implemented by components that function as text editors |
| CAnimatedPosition | Models a 1-dimensional position that can be dragged around by the user, and which will then continue moving with a customisable physics behaviour when released |
| CListener | Implement this class if you need to receive callbacks when the value of an AnimatedPosition changes |
| CBorderedComponentBoundsConstrainer | A ComponentBoundsConstrainer that can be used to add a constant border onto another ComponentBoundsConstrainer |
| CComponentAnimator | This class has been superseded, it is now recommended you use the Animator class in the juce_animation module |
| CComponentBoundsConstrainer | A class that imposes restrictions on a Component's size or position |
| CComponentBuilder | Loads and maintains a tree of Components from a ValueTree that represents them |
| CTypeHandler | The class is a base class for objects that manage the loading of a type of component from a ValueTree |
| CImageProvider | This class is used when references to images need to be stored in ValueTrees |
| CComponentMovementWatcher | An object that watches for any movement of a component or any of its parent components |
| CConcertinaPanel | A panel which holds a vertical stack of components which can be expanded and contracted |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CFlexBox | Represents a FlexBox container, which contains and manages the layout of a set of FlexItem objects |
| CFlexItem | Describes the properties of an item inside a FlexBox container |
| CMargin | Represents a margin |
| CGrid | Container that handles geometry for grid layouts (fixed columns and rows) using a set of declarative rules |
| CPx | A size in pixels |
| CFr | A fractional ratio integer |
| CTrackInfo | Represents a track |
| CGridItem | Defines an item in a Grid |
| CSpan | Represents a span |
| CProperty | Represents a property |
| CStartAndEndProperty | Represents start and end properties |
| CMargin | Represents a margin |
| CGroupComponent | A component that draws an outline around itself and has an optional title at the top, for drawing an outline around a group of controls |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CMultiDocumentPanelWindow | This is a derivative of DocumentWindow that is used inside a MultiDocumentPanel component |
| CMultiDocumentPanel | A component that contains a set of other components either in floating windows or tabs |
| CResizableBorderComponent | A component that resizes its parent component when dragged |
| CZone | Represents the different sections of a resizable border, which allow it to resized in different ways |
| CResizableCornerComponent | A component that resizes a parent component when dragged |
| CResizableEdgeComponent | A component that resizes its parent component when dragged |
| CScrollBar | A scrollbar component |
| CListener | A class for receiving events from a ScrollBar |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide scrollbar-drawing functionality |
| CSidePanel | A component that is positioned on either the left- or right-hand side of its parent, containing a header and some content |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide SidePanel drawing functionality |
| CStretchableLayoutManager | For laying out a set of components, where the components have preferred sizes and size limits, but where they are allowed to stretch to fill the available space |
| CStretchableLayoutResizerBar | A component that acts as one of the vertical or horizontal bars you see being used to resize panels in a window |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CStretchableObjectResizer | A utility class for fitting a set of objects whose sizes can vary between a minimum and maximum size, into a space |
| CTabBarButton | In a TabbedButtonBar, this component is used for each of the buttons |
| CTabbedButtonBar | A vertical or horizontal bar containing tabs that you can select |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide window drawing functionality |
| CTabbedComponent | A component with a TabbedButtonBar along one of its sides |
| CViewport | A Viewport is used to contain a larger child component, and allows the child to be automatically scrolled around |
| CExtraLookAndFeelBaseClasses | This class is used to hold a few look and feel base classes which are associated with classes that may not be present because they're from modules other than juce_gui_basics |
| CLassoComponentMethods | This abstract base class is implemented by LookAndFeel classes |
| CKeyMappingEditorComponentMethods | This abstract base class is implemented by LookAndFeel classes |
| CAudioDeviceSelectorComponentMethods | This abstract base class is implemented by LookAndFeel classes |
| CLookAndFeel | LookAndFeel objects define the appearance of all the JUCE widgets, and subclasses can be used to apply different 'skins' to the application |
| CLookAndFeel_V1 | The original JUCE look-and-feel, as used back from 2002 to about 2007ish |
| CLookAndFeel_V2 | This LookAndFeel subclass implements the juce style from around 2008-12 |
| CLookAndFeel_V3 | The latest JUCE look-and-feel style, as introduced in 2013 |
| CLookAndFeel_V4 | The latest JUCE look-and-feel style, as introduced in 2017 |
| CColourScheme | A struct containing the set of colours to apply to the GUI |
| CBurgerMenuComponent | A component which lists all menu items and groups them into categories by their respective parent menus |
| CMenuBarComponent | A menu bar component |
| CMenuBarModel | A class for controlling MenuBar components |
| CListener | A class to receive callbacks when a MenuBarModel changes |
| CPopupMenu | Creates and displays a popup-menu |
| CItem | Describes a popup menu item |
| COptions | Class used to create a set of options to pass to the show() method |
| CMenuItemIterator | Allows you to iterate through the items in a pop-up menu, and examine their properties |
| CCustomComponent | A user-defined component that can be used as an item in a popup menu |
| CCustomCallback | A user-defined callback that can be used for specific items in a popup menu |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide menu drawing functionality |
| CBubbleComponent | A component for showing a message or other graphics inside a speech-bubble-shaped outline, pointing at a location on the screen |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CDropShadower | Adds a drop-shadow to a component |
| CFocusOutline | Adds a focus outline to a component |
| COutlineWindowProperties | Defines the focus outline window properties |
| CComponentDragger | An object to take care of the logic for dragging components around with the mouse |
| CDragAndDropContainer | Enables drag-and-drop behaviour for a component and all its sub-components |
| CDragAndDropTarget | Components derived from this class can have things dropped onto them by a DragAndDropContainer |
| CSourceDetails | Contains details about the source of a drag-and-drop operation |
| CFileDragAndDropTarget | Components derived from this class can have files dropped onto them by an external application |
| CLassoSource | A class used by the LassoComponent to manage the things that it selects |
| CLassoComponent | A component that acts as a rectangular selection region, which you drag with the mouse to select groups of objects (in conjunction with a SelectedItemSet) |
| CMouseCursor | Represents a mouse cursor image |
| CMouseEvent | Contains position and status information about a mouse event |
| CMouseWheelDetails | Contains status information about a mouse wheel event |
| CPenDetails | Contains status information about a pen event |
| CMouseInactivityDetector | This object watches for mouse-events happening within a component, and if the mouse remains still for long enough, triggers an event to indicate that it has become inactive |
| CListener | Classes should implement this to receive callbacks from a MouseInactivityDetector when the mouse becomes active or inactive |
| CMouseInputSource | Represents a linear source of mouse events from a mouse device or individual finger in a multi-touch environment |
| CMouseListener | A MouseListener can be registered with a component to receive callbacks about mouse events that happen to that component |
| CSelectedItemSet | Manages a list of selectable items |
| CTextDragAndDropTarget | Components derived from this class can have text dropped onto them by an external application |
| CTooltipClient | Components that want to use pop-up tooltips should implement this interface |
| CSettableTooltipClient | An implementation of TooltipClient that stores the tooltip string and a method for changing it |
| CMarkerList | Holds a set of named marker points along a one-dimensional axis |
| CMarker | Represents a marker in a MarkerList |
| CListener | A class for receiving events when changes are made to a MarkerList |
| CMarkerListHolder | A base class for objects that want to provide a MarkerList |
| CValueTreeWrapper | Forms a wrapper around a ValueTree that can be used for storing a MarkerList |
| CRelativeCoordinate | Expresses a coordinate as a dynamically evaluated expression |
| CStrings | A set of static strings that are commonly used by the RelativeCoordinate class |
| CStandardStrings | |
| CRelativeCoordinatePositionerBase | Base class for Component::Positioners that are based upon relative coordinates |
| CComponentScope | Used for resolving a RelativeCoordinate expression in the context of a component |
| CRelativeParallelogram | A parallelogram defined by three RelativePoint positions |
| CRelativePoint | An X-Y position stored as a pair of RelativeCoordinate values |
| CRelativePointPath | A path object that consists of RelativePoint coordinates rather than the normal fixed ones |
| CElementBase | Base class for the elements that make up a RelativePointPath |
| CStartSubPath | Class for the start sub path element |
| CCloseSubPath | Class for the close sub path element |
| CLineTo | Class for the line to element |
| CQuadraticTo | Class for the quadratic to element |
| CCubicTo | Class for the cubic to element |
| CRelativeRectangle | A rectangle stored as a set of RelativeCoordinate values |
| CBooleanPropertyComponent | A PropertyComponent that contains an on/off toggle button |
| CButtonPropertyComponent | A PropertyComponent that contains a button |
| CChoicePropertyComponent | A PropertyComponent that shows its value as a combo box |
| CMultiChoicePropertyComponent | A PropertyComponent that shows its value as an expandable list of ToggleButtons |
| CPropertyComponent | A base class for a component that goes in a PropertyPanel and displays one of an item's properties |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CPropertyPanel | A panel that holds a list of PropertyComponent objects |
| CSliderPropertyComponent | A PropertyComponent that shows its value as a slider |
| CTextPropertyComponent | A PropertyComponent that shows its value as editable text |
| CListener | Used to receive callbacks for text changes |
| CComboBox | A component that lets the user choose from a drop-down list of choices |
| CListener | A class for receiving events from a ComboBox |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide ComboBox functionality |
| CImageComponent | A component that simply displays an image |
| CLabel | A component that displays a text string, and can optionally become a text editor when clicked |
| CListener | A class for receiving events from a Label |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide label drawing functionality |
| CListBoxModel | A subclass of this is used to drive a ListBox |
| CListBox | A list of items that can be scrolled vertically |
| CProgressBar | A progress bar component |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CSliderListener | A class for receiving callbacks from a Slider or WebSliderRelay |
| CSlider | A slider control for changing a value |
| CRotaryParameters | Structure defining rotary parameters for a slider |
| CSliderLayout | A struct defining the placement of the slider area and the text box area relative to the bounds of the whole Slider component |
| CScopedDragNotification | An RAII class for sending slider listener drag messages |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide slider drawing functionality |
| CTableHeaderComponent | A component that displays a strip of column headings for a table, and allows these to be resized, dragged around, etc |
| CListener | Receives events from a TableHeaderComponent when columns are resized, moved, etc |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CTableListBoxModel | One of these is used by a TableListBox as the data model for the table's contents |
| CTableListBox | A table of cells, using a TableHeaderComponent as its header |
| CTextEditor | An editable text box |
| CListener | Receives callbacks from a TextEditor component when it changes |
| CInputFilter | Base class for input filters that can be applied to a TextEditor to restrict the text that can be entered |
| CLengthAndCharacterRestriction | An input filter for a TextEditor that limits the length of text and/or the characters that it may contain |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide TextEditor drawing functionality |
| CToolbar | A toolbar component |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CToolbarItemComponent | A component that can be used as one of the items in a Toolbar |
| CToolbarItemFactory | A factory object which can create ToolbarItemComponent objects |
| CToolbarItemPalette | A component containing a list of toolbar items, which the user can drag onto a toolbar to add them |
| CTreeViewItem | An item in a TreeView |
| COpennessRestorer | This handy class takes a copy of a TreeViewItem's openness when you create it, and restores that openness state when its destructor is called |
| CTreeView | A tree-view component |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide TreeView drawing functionality |
| CAlertWindow | A window that displays a message and has buttons for the user to react to it |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide alert-window drawing functionality |
| CCallOutBox | A box with a small arrow that can be used as a temporary pop-up window to show extra controls when a button or other component is clicked |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes |
| CComponentPeer | The Component class uses a ComponentPeer internally to create and manage a real operating-system window |
| COptionalBorderSize | Represents the window borders around a window component |
| CDragInfo | Structure to describe drag and drop information |
| CScaleFactorListener | Used to receive callbacks when the OS scale factor of this ComponentPeer changes |
| CVBlankListener | Used to receive callbacks on every vertical blank event of the display that the peer currently belongs to |
| CDialogWindow | A dialog-box style window |
| CLaunchOptions | This class defines a collection of settings to be used to open a DialogWindow |
| CDocumentWindow | A resizable window with a title bar and maximise, minimise and close buttons |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide window drawing functionality |
| CMessageBoxOptions | Class used to create a set of options to pass to the AlertWindow and NativeMessageBox methods for showing dialog boxes |
| CNativeMessageBox | This class contains some static methods for showing native alert windows |
| CNativeScaleFactorNotifier | Calls a function every time the native scale factor of a component's peer changes |
| CResizableWindow | A base class for top-level windows that can be dragged around and resized |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide window drawing functionality |
| CScopedMessageBox | Objects of this type can be used to programmatically close message boxes |
| CThreadWithProgressWindow | A thread that automatically pops up a modal dialog box with a progress bar and cancel button while it's busy running |
| CTooltipWindow | A window that displays a pop-up tooltip when the mouse hovers over another component |
| CLookAndFeelMethods | This abstract base class is implemented by LookAndFeel classes to provide window drawing functionality |
| CTopLevelWindow | A base class for top-level windows |
| CVBlankAttachment | Helper class to synchronise Component updates to the vertical blank event of the display that the Component is presented on |
| CWindowUtils | Windowing helper functions |
| CCodeDocument | A class for storing and manipulating a source code file |
| CPosition | A position in a code document |
| CListener | An object that receives callbacks from the CodeDocument when its text changes |
| CIterator | Iterates the text in a CodeDocument |
| CCodeEditorComponent | A text editor component designed specifically for source code |
| CState | Can be used to save and restore the editor's caret position, selection state, etc |
| CColourScheme | Defines a syntax highlighting colour scheme |
| CTokenType | Defines a colour for a token type |
| CCodeTokeniser | A base class for tokenising code so that the syntax can be displayed in a code editor |
| CCPlusPlusCodeTokeniser | A simple lexical analyser for syntax colouring of C++ code |
| CCppTokeniserFunctions | Class containing some basic functions for simple tokenising of C++ code |
| CStringIterator | A class that can be passed to the CppTokeniserFunctions functions in order to parse a String |
| CLuaTokeniser | |
| CXmlTokeniser | |
| CFileBasedDocument | A class to take care of the logic involved with the loading/saving of some kind of document |
| CActiveXControlComponent | A Windows-specific class that can create and embed an ActiveX control inside itself |
| CAndroidViewComponent | An Android-specific class that can create and embed a View inside itself |
| CHWNDComponent | A Windows-specific class that can create and embed a HWND inside itself |
| CNSViewComponent | A Mac-specific class that can create and embed an NSView inside itself |
| CUIViewComponent | An iOS-specific class that can create and embed an UIView inside itself |
| CXEmbedComponent | A Linux-specific class that can embed a foreign X11 widget |
| CAnimatedAppComponent | A base class for writing simple one-page graphical apps |
| CAppleRemoteDevice | Receives events from an Apple IR remote control device (Only available in OSX!) |
| CBubbleMessageComponent | A speech-bubble component that displays a short message |
| CColourSelector | A component that lets the user choose a colour |
| CKeyMappingEditorComponent | A component to allow editing of the keymaps stored by a KeyPressMappingSet object |
| CPreferencesPanel | A component with a set of buttons at the top for changing between pages of preferences |
| CPushNotifications | Singleton class responsible for push notifications functionality |
| CNotification | Represents a notification that can be sent or received |
| CAction | Represents an action on a notification that can be presented as a button or a text input |
| CProgress | Used to represent a progress of some operation |
| CLedBlinkPattern | Allows to control the time the device's led is on and off |
| CSettings | Describes settings we want to use for current device |
| CCategory | Describes a category of a notification |
| CChannel | Android API level 26 or higher only: Represents notification channel through which notifications will be sent |
| CChannelGroup | Android API level 26 or higher only: represents a channel group |
| CListener | Register a listener (ideally on application startup) to receive information about notifications received and any callbacks to async functions called |
| CRecentlyOpenedFilesList | Manages a set of files for use as a list of recently-opened documents |
| CSplashScreen | A component for showing a splash screen while your app starts up |
| CSystemTrayIconComponent | This component sits in the taskbar tray as a small icon |
| CWebViewLifetimeListener | Type for a listener registered with WebBrowserComponent::Options::withWebViewLifetimeListener |
| CWebBrowserComponent | A component that displays an embedded web browser |
| CResource | A resource returned by a ResourceProvider |
| COptions | Options to configure WebBrowserComponent |
| CWinWebView2 | Options specific to the WebView2 backend |
| CAppleWkWebView | Options specific to the WkWebView backend used on Apple systems |
| CEvaluationResult | On MacOS, iOS and Linux getResult will return a nullptr if the evaluation failed |
| CError | A simple error type class |
| CWebControlParameterIndexReceiver | This is a helper class for implementing AudioProcessorEditor::getControlParameterIndex with GUIs using a WebBrowserComponent |
| CWebSliderRelay | Helper class that relays audio parameter information to an object inside a WebBrowserComponent |
| CListener | |
| CWebToggleButtonRelay | Helper class that relays audio parameter information to an object inside a WebBrowserComponent |
| CListener | |
| CWebComboBoxRelay | Helper class that relays audio parameter information to an object inside a WebBrowserComponent |
| CListener | |
| CJavascriptEngine | This class is a wrapper around QuickJS, an ES2023 compliant, embeddable javascript engine |
| CJSCursor | A high-level wrapper around an owning root JSObject and a hierarchical path relative to it |
| CJSObject | A JSObject represents an owning reference to the underlying JS object, meaning it will remain valid even if a subsequent script execution deletes other handles to it |
| CDraggable3DOrientation | Stores a 3D orientation, which can be rotated by dragging with the mouse |
| CMatrix3D | A 4x4 3D transformation matrix |
| CQuaternion | Holds a quaternion (a 3D vector and a scalar value) |
| CVector3D | A three-coordinate vector |
| COpenGLContext | Creates an OpenGL context, which can be attached to a component |
| COpenGLFrameBuffer | Creates an openGL frame buffer |
| COpenGLGraphicsContextCustomShader | Used to create custom shaders for use with an openGL 2D rendering context |
| COpenGLHelpers | A set of miscellaneous openGL helper functions |
| COpenGLImageType | A type of ImagePixelData that stores its image data in an OpenGL framebuffer, allowing a JUCE Image object to wrap a framebuffer |
| COpenGLPixelFormat | Represents the various properties of an OpenGL pixel format |
| COpenGLRenderer | A base class that should be implemented by classes which want to render openGL on a background thread |
| COpenGLShaderProgram | Manages an OpenGL shader program |
| CUniform | Represents an openGL uniform value |
| CAttribute | Represents an openGL vertex attribute value |
| COpenGLTexture | Creates an openGL texture from an Image |
| COpenGLAppComponent | A base class for writing simple one-page graphical apps |
| COSCAddress | An OSC address |
| COSCAddressPattern | An OSC address pattern |
| COSCArgument | An OSC argument |
| COSCBundle | An OSC bundle |
| CElement | An OSC bundle element |
| COSCMessage | An OSC Message |
| COSCReceiver | A class for receiving OSC data |
| CMessageLoopCallback | Use this struct as the template parameter for Listener and ListenerWithOSCAddress to receive incoming OSC data on the message thread |
| CRealtimeCallback | Use this struct as the template parameter for Listener and ListenerWithOSCAddress to receive incoming OSC data immediately after it arrives, called directly on the network thread that listens to incoming OSC traffic |
| CListener | A class for receiving OSC data from an OSCReceiver |
| CListenerWithOSCAddress | A class for receiving only those OSC messages from an OSCReceiver that match a given OSC address |
| COSCSender | An OSC message sender |
| COSCTimeTag | An OSC time tag |
| COSCTypes | The definitions of supported OSC types and their associated OSC type tags, as defined in the OpenSoundControl 1.0 specification |
| COSCColour | Holds a 32-bit RGBA colour for passing to and from an OSCArgument |
| COSCException | Base class for exceptions that can be thrown by methods in the OSC module |
| COSCFormatError | Exception type thrown when the OSC module fails to parse something because of a data format not compatible with the OpenSoundControl 1.0 specification |
| COSCInternalError | Exception type thrown in cases of unexpected errors in the OSC module |
| CInAppPurchases | Provides in-app purchase functionality |
| CProduct | Represents a product available in the store |
| CPurchase | Represents a purchase of a product in the store |
| CDownload | IOS only: represents in-app purchase download |
| CListener | Represents an object that gets notified about events such as product info returned or product purchase finished |
| CPurchaseInfo | Structure holding purchase information |
| CKeyGeneration | Contains static utilities for generating key-files that can be unlocked by the OnlineUnlockStatus class |
| COnlineUnlockForm | Acts as a GUI which asks the user for their details, and calls the appropriate methods on your OnlineUnlockStatus object to attempt to register the app |
| COnlineUnlockStatus | A base class for online unlocking systems |
| CLicenseResult | The possible error strings that can applyKeyFile() can return on failure |
| CUnlockResult | This provides some details about the reply that the server gave in a call to attemptWebserverUnlock() |
| CMachineIDUtilities | This class contains some utility functions that might help with machine ID generation |
| CTracktionMarketplaceStatus | An implementation of the OnlineUnlockStatus class which talks to the Tracktion Marketplace server |
| CCameraDevice | Controls any video capture devices that might be available |
| CListener | Receives callbacks with individual frames from a CameraDevice |
| CVideoComponent | A component that can play a movie |
